bug修改

controllers/mobile_api_controllers/dialysis_api_controller.go

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

controllers/new_mobile_api_controllers/common_api_controller.go

 		Sort:            sort,
 	}
 	err = service.UpdarteConfiguration(&standard, id)
+	fmt.Println("爆粗========================================", err)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 	endtime, _ := this.GetInt64("endtime")
 	fmt.Println("结束时间", endtime)
 	total := service.GetPatientTotalCount(orgid)
+
 	_, totalSex, err := service.GetManPatientTotal(orgid)
 
 	if err != nil {
 	orgId := adminUser.CurrentOrgId
 
 	dialysislist, total, err := service.GetDialysisList(statime, entime, page, limit, orgId)
-
 	prescriptionList, _ := service.GetAllDialysisList(statime, entime, orgId)
 	list, totallist, _ := service.GetDialysisPatientList(statime, entime, page, limit, orgId)
 	fmt.Println("err", err)
 func (this *CommonApiController) GetPrescritionByName() {
 	adminUser := this.GetAdminUserInfo()
 	orgId := adminUser.CurrentOrgId
-	keyword := this.GetString("keyword")
+	//keyword := this.GetString("keyword")
+	patientid, _ := this.GetInt64("patientid")
 	startime := this.GetString("startime")
 	fmt.Println(startime)
 	endtime := this.GetString("endtime")
 	fmt.Println("limit", limit)
 	page, _ := this.GetInt64("page")
 	fmt.Println("page", page)
-	patient, total, err := service.GetPrescritionByName(orgId, keyword, statime, entime, limit, page)
+	patient, total, err := service.GetPrescritionByName(orgId, patientid, statime, entime, limit, page)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 	page, _ := this.GetInt64("page")
 	fmt.Println("page", page)
 	modeId, _ := this.GetInt64("mode_id")
-	statistics, ttd, total, err := service.GetStatistics(orgId, statime, entime, value, limit, page, modeId)
+	treatinfo, total, err := service.GetTreateInfo(orgId, statime, entime, value, limit, page)
+	statistics, ttd, _ := service.GetStatistics(orgId, statime, entime, modeId)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 		"statistics": statistics,
 		"ttd":        ttd,
 		"total":      total,
+		"treatinfo":  treatinfo,
 	})
 }
 
 func (this *CommonApiController) GetSearchPatientInfo() {
 	adminUser := this.GetAdminUserInfo()
 	orgId := adminUser.CurrentOrgId
-	keyword := this.GetString("keyword")
-	fmt.Println("keyword", keyword)
+	//keyword := this.GetString("keyword")
+	//fmt.Println("keyword", keyword)
+	patientid, _ := this.GetInt64("patientid")
 	startime := this.GetString("startime")
 	endtime := this.GetString("endtime")
 	startDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", startime)
 	endDate, _ := utils.ParseTimeStringToTime("2006-01-02", endtime)
 	entime := endDate.Unix()
 	fmt.Println("结束日期", entime)
-	PatientsInfo, err := service.GetSearchPatientInfo(orgId, keyword, statime, entime)
+	PatientsInfo, err := service.GetSearchPatientInfo(orgId, patientid, statime, entime)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 	orgid := this.GetAdminUserInfo().CurrentOrgId
 	//获取系统数据
 	normdata, err := service.GetNormDataByOrgId(orgid)
-	fmt.Println("normdata==============================", normdata)
+
 	if len(normdata) == 0 {
 		normdata, err := service.GetNormData(0)
-		fmt.Println("normdata=============================+++++", normdata)
+
 		if err != nil {
 			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 			return
 func (this *CommonApiController) GetCartogramList() {
 	adminUser := this.GetAdminUserInfo()
 	orgid := adminUser.CurrentOrgId
+	fmt.Println("orgid", orgid)
 	lapstor, _ := this.GetInt64("lapstor")
 	fmt.Println("lapstor", lapstor)
 	startime := this.GetString("startime")
 	fmt.Println(orgid)
 	lapstor, _ := this.GetInt64("lapstor")
 	fmt.Println("lapstor", lapstor)
-	keyword := this.GetString("keyword")
-	fmt.Println("keyword", keyword)
+	patientid, _ := this.GetInt64("patientid")
 	startime := this.GetString("startime")
 	fmt.Println("开始时间", startime)
 	startimeStr, _ := utils.ParseTimeStringToTime("2006-01-02", startime)
 	endtimeStrs, _ := utils.ParseTimeStringToTime("2006-01-02 15:04:05", endtimeStr)
 	endtimeStrsUnix := endtimeStrs.Unix()
 	fmt.Println("结束时间搓", endtimeStrsUnix)
-	patients, err := service.GetPatientNames(orgid, keyword)
-	patientcontorDetail, err := service.GetLastPatientsControlTwo(orgid, patients.ID, startimeStrUnix, endtimeStrsUnix)
+	patients, err := service.GetPatientNames(orgid, patientid)
+	patientcontorDetail, err := service.GetLastPatientsControlTwo(orgid, patientid, startimeStrUnix, endtimeStrsUnix)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 		"list": list,
 	})
 }
+
+func (this *CommonApiController) GetTreatlist() {
+	adminuser := this.GetAdminUserInfo()
+	orgId := adminuser.CurrentOrgId
+	startime := this.GetString("start_time")
+	fmt.Println(startime)
+	endtime := this.GetString("end_time")
+	startDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", startime)
+	fmt.Println("parseDateErr", parseDateErr)
+	statime := startDate.Unix()
+	fmt.Println("开始时间", statime)
+	endDate, _ := utils.ParseTimeStringToTime("2006-01-02", endtime)
+	entime := endDate.Unix()
+	fmt.Println("结束日期", entime)
+	value, _ := this.GetInt64("value")
+	fmt.Println("value", value)
+
+	list, err := service.GetTreatList(orgId, statime, entime, value)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+
+	this.ServeSuccessJSON(map[string]interface{}{
+
+		"list": list,
+	})
+}

controllers/new_mobile_api_controllers/common_api_router.go

 	beego.Router("/com/api/getcartogramlist", &CommonApiController{}, "Get:GetCartogramList")
 	beego.Router("/com/api/getpatientcontor", &CommonApiController{}, "Get:GetPatientContor")
 	beego.Router("/com/api/getqualitycontrol", &CommonApiController{}, "Get:GetQualityControl")
+	beego.Router("/com/api/gettreatlist", &CommonApiController{}, "Get:GetTreatlist")
 }

controllers/new_mobile_api_controllers/new_common_api_controller.go

 func (this *NewCommonApiController) ToSearchPatient() {
 	adminUser := this.GetMobileAdminUserInfo()
 	orgId := adminUser.Org.Id
-	keyword := this.GetString("keyword")
+	//keyword := this.GetString("keyword")
+	patientid, _ := this.GetInt64("patientid")
 	startime := this.GetString("startime")
 	fmt.Println(startime)
 	endtime := this.GetString("endtime")
 	fmt.Println("limit", limit)
 	page, _ := this.GetInt64("page")
 	fmt.Println("page", page)
-	patient, total, err := service.GetPrescritionByName(orgId, keyword, statime, entime, limit, page)
+	patient, total, err := service.GetPrescritionByName(orgId, patientid, statime, entime, limit, page)
+	fmt.Println("报错==========", err)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 	fmt.Println("page", page)
 	modeId, _ := this.GetInt64("mode_id")
 	fmt.Println("modeId", modeId)
-	statistics, ttd, total, err := service.GetStatistics(orgId, statime, entime, value, limit, page, modeId)
+	treatinfo, total, err := service.GetTreateInfo(orgId, statime, entime, value, limit, page)
+	statistics, ttd, err := service.GetStatistics(orgId, statime, entime, modeId)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 		"statistics": statistics,
 		"ttd":        ttd,
 		"total":      total,
+		"treatinfo":  treatinfo,
 	})
 }
 
 func (this *NewCommonApiController) GetSeachPatientDetail() {
 	adminUser := this.GetMobileAdminUserInfo()
 	orgId := adminUser.Org.Id
-	keyword := this.GetString("keyword")
-	fmt.Println("keyword", keyword)
+	//keyword := this.GetString("keyword")
+	//fmt.Println("keyword", keyword)
+	patientid, _ := this.GetInt64("patientid")
 	startime := this.GetString("startime")
 	endtime := this.GetString("endtime")
 	startDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", startime)
 	endDate, _ := utils.ParseTimeStringToTime("2006-01-02", endtime)
 	entime := endDate.Unix()
 	fmt.Println("结束日期", entime)
-	PatientsInfo, err := service.GetSearchPatientInfo(orgId, keyword, statime, entime)
+	PatientsInfo, err := service.GetSearchPatientInfo(orgId, patientid, statime, entime)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 		"control": control,
 	})
 }
+
+func (this *NewCommonApiController) GetMobileTreatlist() {
+	adminUser := this.GetMobileAdminUserInfo()
+	orgId := adminUser.Org.Id
+	startime := this.GetString("startime")
+	fmt.Println(startime)
+	endtime := this.GetString("endtime")
+	startDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", startime)
+	fmt.Println("parseDateErr", parseDateErr)
+	statime := startDate.Unix()
+	fmt.Println("开始时间", statime)
+	endDate, _ := utils.ParseTimeStringToTime("2006-01-02", endtime)
+	entime := endDate.Unix()
+	fmt.Println("结束日期", entime)
+	value, _ := this.GetInt64("value")
+	fmt.Println("value", value)
+	list, err := service.GetTreatList(orgId, statime, entime, value)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+
+	this.ServeSuccessJSON(map[string]interface{}{
+
+		"list": list,
+	})
+}

controllers/new_mobile_api_controllers/new_common_api_router.go

 	beego.Router("m/api/getmobilecartogramlist", &NewCommonApiController{}, "Get:GetMobileCartogramlist")
 	beego.Router("/m/api/getmobilequalitycontrol", &NewCommonApiController{}, "Get:GetMobileQualityControl")
 	beego.Router("/m/api/toseachpatientscontrol", &NewCommonApiController{}, "Get:GetSeachPatientsControl")
+	beego.Router("/m/api/getmobiletreatlist", &NewCommonApiController{}, "Get:GetMobileTreatlist")
 }

models/common_models.go

 
 	return "xt_inspection"
 }
+
+type BloodDialysisOrder struct {
+	ID                 int64  `gorm:"column:id" json:"id" form:"id"`
+	DialysisDate       int64  `gorm:"column:dialysis_date" json:"dialysis_date" form:"dialysis_date"`
+	UserOrgId          int64  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PatientId          int64  `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	PrescriptionId     int64  `gorm:"column:prescription_id" json:"prescription_id" form:"prescription_id"`
+	Stage              int64  `gorm:"column:stage" json:"stage" form:"stage"`
+	Remark             string `gorm:"column:remark" json:"remark" form:"remark"`
+	BedId              int64  `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
+	StartNurse         int64  `gorm:"column:start_nurse" json:"start_nurse" form:"start_nurse"`
+	FinishNurse        int64  `gorm:"column:finish_nurse" json:"finish_nurse" form:"finish_nurse"`
+	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"`
+	PunctureNurse      int64  `gorm:"column:puncture_nurse" json:"puncture_nurse" form:"puncture_nurse"`
+	Creator            int64  `gorm:"column:creator" json:"creator" form:"creator"`
+	Modifier           int64  `gorm:"column:modifier" json:"modifier" form:"modifier"`
+	FinishCreator      int64  `gorm:"column:finish_creator" json:"finish_creator" form:"finish_creator"`
+	FinishModifier     int64  `gorm:"column:finish_modifier" json:"finish_modifier" form:"finish_modifier"`
+	SchedualType       int64  `gorm:"column:schedual_type" json:"schedual_type" form:"schedual_type"`
+	StartTime          int64  `gorm:"column:start_time" json:"start_time" form:"start_time"`
+	EndTime            int64  `gorm:"column:end_time" json:"end_time" form:"end_time"`
+	ModeId             int64  `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	Name               string `gorm:"column:name" json:"name" form:"name"`
+	DialysisNo         string `gorm:"column:dialysis_no" json:"dialysis_no" form:"dialysis_no"`
+	IdCardNo           string `gorm:"column:id_card_no" json:"id_card_no" form:"id_card_no"`
+	TotalDialysis      int64  `gorm:"column:total_dialysis" json:"total_dialysis" form:"total_dialysis"`
+	UserSysBeforeCount int64  `gorm:"column:user_sys_before_count" json:"user_sys_before_count" form:"user_sys_before_count"`
+}
+
+type TreatDialysisOrder struct {
+	Date string `json:"date"`
+}
+
+type TreatTotalStruct struct {
+	Number string `json:"number"`
+	ModeID string `json:"mode_id"`
+}

service/common_service.go

 	return patients, err
 }
 
-func GetDialysisList(startime int64, endtime int64, page int64, limit int64, orgid int64) (prescription []*models.BloodDialysisPrescription, total int64, err error) {
-	db := XTReadDB().Table("xt_dialysis_prescription as p").Where("p.status =1 ")
-	table := XTReadDB().Table("xt_patients as s")
-	fmt.Println("table", table)
+func GetDialysisList(startime int64, endtime int64, page int64, limit int64, orgid int64) (order []*models.BloodDialysisOrder, total int64, err error) {
+
+	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status = 1")
+	table := XTReadDB().Table("xt_schedule as s")
+	fmt.Println(table)
+	d := XTReadDB().Table("xt_patients as p")
+	fmt.Println(d)
 	if orgid > 0 {
-		db = db.Where("p.user_org_id = ?", orgid)
+		db = db.Where("o.user_org_id = ?", orgid)
 	}
 	if startime > 0 {
-		db = db.Where("p.record_date >= ?", startime)
+		db = db.Where("o.dialysis_date>=?", startime)
 	}
 	if endtime > 0 {
-		db = db.Where("p.record_date <=?", endtime)
+		db = db.Where("o.dialysis_date<=?", endtime)
 	}
 	offset := (page - 1) * limit
-	err = db.Group("p.patient_id,p.mode_id").Select("p.mode_id,p.patient_id,s.name,s.id_card_no,s.dialysis_no,s.total_dialysis,s.user_sys_before_count").Joins("left join xt_patients as s on s.id = p.patient_id").Count(&total).Offset(offset).Limit(limit).Scan(&prescription).Error
-	return prescription, total, err
+	err = db.Group("s.patient_id,s.mode_id").Select("s.mode_id,o.patient_id,p.name,p.id_card_no,p.dialysis_no,p.total_dialysis,p.user_sys_before_count").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Joins("left join  xt_patients as p on p.id = o.patient_id").Where("s.schedule_date = o.dialysis_date ").Count(&total).Offset(offset).Limit(limit).Scan(&order).Error
+	return order, total, err
+
 }
 
-func GetAllDialysisList(startime int64, endtime int64, orgid int64) (prescription []*models.BloodDialysisPrescription, err error) {
+func GetAllDialysisList(startime int64, endtime int64, orgid int64) (order []*models.BloodDialysisOrder, err error) {
 
-	db := XTReadDB().Table("xt_dialysis_prescription as p").Where("p.status =1 ")
-	table := XTReadDB().Table("xt_patients as s")
+	table := XTReadDB().Table("xt_schedule as s")
 	fmt.Println(table)
+	d := XTReadDB().Table("xt_patients as p")
+	fmt.Println(d)
+	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status = 1")
 	if orgid > 0 {
-		db = db.Where("p.user_org_id = ?", orgid)
+		db = db.Where("o.user_org_id = ?", orgid)
 	}
 	if startime > 0 {
-		db = db.Where("p.record_date >= ?", startime)
+		db = db.Where("o.dialysis_date>=?", startime)
 	}
 	if endtime > 0 {
-		db = db.Where("p.record_date <=?", endtime)
+		db = db.Where("o.dialysis_date<=?", endtime)
 	}
-	err = db.Group("p.patient_id,p.mode_id").Select("p.mode_id,p.patient_id,s.name,s.id_card_no,s.dialysis_no,s.total_dialysis,s.user_sys_before_count").Joins("left join xt_patients as s on s.id = p.patient_id").Scan(&prescription).Error
-	return prescription, err
+	err = db.Group("s.patient_id,s.mode_id").Select("s.mode_id,s.patient_id,p.name,p.id_card_no,p.dialysis_no,p.total_dialysis,p.user_sys_before_count").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Joins("left join xt_patients as p on p.id = o.patient_id").Where("s.schedule_date = o.dialysis_date ").Scan(&order).Error
+	return order, err
 }
 
-func GetDialysisPatientList(startime int64, endtime int64, page int64, limit int64, orgid int64) (prescription []*models.BloodDialysisPrescription, total int64, err error) {
-	db := XTReadDB().Table("xt_dialysis_prescription as p").Where("p.status =1 ")
-	table := XTReadDB().Table("xt_patients as s")
-	fmt.Println("table", table)
+func GetDialysisPatientList(startime int64, endtime int64, page int64, limit int64, orgid int64) (order []*models.BloodDialysisOrder, total int64, err error) {
+
+	table := XTReadDB().Table("xt_schedule as s")
+	fmt.Println(table)
+	d := XTReadDB().Table("xt_patients as p")
+	fmt.Println(d)
+	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status = 1")
 	if orgid > 0 {
-		db = db.Where("p.user_org_id = ?", orgid)
+		db = db.Where("o.user_org_id = ?", orgid)
 	}
 	if startime > 0 {
-		db = db.Where("p.record_date >= ?", startime)
+		db = db.Where("o.dialysis_date>=?", startime)
 	}
 	if endtime > 0 {
-		db = db.Where("p.record_date <=?", endtime)
+		db = db.Where("o.dialysis_date<=?", endtime)
 	}
 	offset := (page - 1) * limit
-	err = db.Group("p.patient_id").Select("p.mode_id,p.patient_id,s.name,s.id_card_no,s.dialysis_no,s.total_dialysis,s.user_sys_before_count").Joins("left join xt_patients as s on s.id = p.patient_id").Count(&total).Offset(offset).Limit(limit).Scan(&prescription).Error
-	return prescription, total, err
+	err = db.Group("s.patient_id").Select("s.mode_id,o.patient_id,p.name,p.id_card_no,p.dialysis_no,p.total_dialysis,p.user_sys_before_count").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Joins("left join  xt_patients as p on p.id = o.patient_id").Where("s.schedule_date = o.dialysis_date ").Count(&total).Offset(offset).Limit(limit).Scan(&order).Error
+	return order, total, err
 }
 
 func GetLastSort(orgid int64) (models.XtQualityControlStandard, error) {
 	return prescription, total, err
 }
 
-func GetPrescritionByName(orgid int64, keywords string, startime int64, endtime int64, limit int64, page int64) (prescription []*models.BloodDialysisPrescription, total int64, err error) {
+func GetPrescritionByName(orgid int64, patient_id int64, startime int64, endtime int64, limit int64, page int64) (prescription []*models.BloodDialysisPrescription, total int64, err error) {
 
 	db := XTReadDB().Table("xt_dialysis_prescription as p").Where("p.status =1 ")
 	table := XTReadDB().Table("xt_patients as s")
 	fmt.Println(table)
-	if len(keywords) > 0 {
-		likeKey := "%" + keywords + "%"
-		db = db.Where("s.name LIKE ? OR s.dialysis_no LIKE ?", likeKey, likeKey)
+	//if len(keywords) > 0 {
+	//	likeKey := "%" + keywords + "%"
+	//	db = db.Where("s.name LIKE ? OR s.dialysis_no LIKE ?", likeKey, likeKey)
+	//}
+	if patient_id > 0 {
+		db = db.Where("s.id = ?", patient_id)
 	}
 	if orgid > 0 {
 		db = db.Where("p.user_org_id = ?", orgid)
 	return prescription, total, err
 }
 
-func GetStatistics(orgID int64, startime int64, endtime int64, lapseto int64, limit int64, page int64, modeID int64) (dtd []*DialysisTotalDataStruct, ttd []*DialysisTotalDataStruct, total int64, err error) {
-	db := readDb
-	sql := "s.mode_id,from_unixtime(s.record_date, '%Y%m%d') as date, count(s.record_date) as number"
-	datesql := "s.record_date as date"
-	group := "from_unixtime(s.record_date, '%Y%m%d')"
-	db = db.Table("xt_dialysis_prescription as s")
+func GetTreateInfo(orgID int64, startime int64, endtime int64, lapseto int64, limit int64, page int64) (blood []*models.TreatDialysisOrder, total int64, err error) {
+
+	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status =  1")
+	table := XTReadDB().Table("xt_schedule as s")
+	fmt.Println(table)
+	p := XTReadDB().Table("xt_patients as p")
+	fmt.Println(p)
+	sql := "from_unixtime(o.dialysis_date, '%Y%m%d') AS date"
+
 	if orgID > 0 {
-		db = db.Where("s.user_org_id = ?", orgID)
-	}
-	if modeID > 0 {
-		db = db.Where("s.mode_id=?", modeID)
+		db = db.Where("o.user_org_id = ?", orgID)
 	}
 	if startime > 0 {
-		db = db.Where("s.record_date>=?", startime)
+		db = db.Where("o.dialysis_date >=?", startime)
 	}
 	if endtime > 0 {
-		db = db.Where("s.record_date<=?", endtime)
+		db = db.Where("o.dialysis_date<=?", endtime)
+	}
+	if lapseto == 0 {
+		db = db.Where("p.lapseto = 1 or p.lapseto = 2")
 	}
-	db = db.Where("s.status=1")
+	if lapseto > 0 {
+		db = db.Where("p.lapseto = ?", lapseto)
+	}
+	offset := (page - 1) * limit
+	err = db.Group("o.dialysis_date").Select(sql).Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Joins("left join xt_patients as p on p.id = o.patient_id").Where("s.schedule_date = o.dialysis_date").Count(&total).Offset(offset).Limit(limit).Scan(&blood).Error
+	return blood, total, err
 
+}
+func GetTreatList(orgid int64, startime int64, endtime int64, lapseto int64) (ttd []*models.TreatTotalStruct, err error) {
+	db := XTReadDB().Table("xt_dialysis_order as o").Where("o.status =  1")
+	table := XTReadDB().Table("xt_schedule as s")
+	fmt.Println(table)
+	p := XTReadDB().Table("xt_patients as p")
+	fmt.Println(p)
+	if orgid > 0 {
+		db = db.Where("o.user_org_id = ?", orgid)
+	}
+	if startime > 0 {
+		db = db.Where("o.dialysis_date>=?", startime)
+	}
+	if endtime > 0 {
+		db = db.Where("o.dialysis_date<=?", endtime)
+	}
+	if lapseto == 0 {
+		db = db.Where("p.lapseto = 1 or p.lapseto = 2")
+	}
 	if lapseto > 0 {
-		joinString := "JOIN xt_patients as p ON s.patient_id=p.id and p.lapseto=? and p.status=1"
-		joinParams := make([]interface{}, 0)
-		joinParams = append(joinParams, lapseto)
-		if orgID > 0 {
-			joinString += "AND p.user_org_id=?"
-			joinParams = append(joinParams, orgID)
-		}
+		db = db.Where("p.lapseto = ?", lapseto)
+	}
+	err = db.Select("s.mode_id, count(s.mode_id) as number").Joins("left join xt_schedule as s on s.patient_id = o.patient_id").Joins("left join xt_patients as p on p.id = o.patient_id").Where("s.schedule_date = o.dialysis_date").Group("s.mode_id").Order("s.mode_id asc").Find(&ttd).Error
+	return ttd, err
+}
 
-		db = db.Joins(joinString, joinParams...)
+func GetStatistics(orgID int64, startime int64, endtime int64, modeID int64) (dtd []*DialysisTotalDataStruct, ttd []*DialysisTotalDataStruct, err error) {
+	db := readDb
+	sql := "s.mode_id,from_unixtime(o.dialysis_date, '%Y%m%d') as date, count(o.dialysis_date) as number"
+	datesql := " o.dialysis_date as date"
+	group := "from_unixtime(o.dialysis_date, '%Y%m%d')"
+	db = db.Table(" xt_dialysis_order AS o").Joins("left join xt_schedule as s on o.patient_id = s.patient_id").Where("s.schedule_date = o.dialysis_date")
+	if orgID > 0 {
+		db = db.Where("o.user_org_id = ?", orgID)
+	}
+	if modeID > 0 {
+		db = db.Where("s.mode_id=?", modeID)
 	}
+	if startime > 0 {
+		db = db.Where("o.dialysis_date>=?", startime)
+	}
+	if endtime > 0 {
+		db = db.Where("o.dialysis_date<=?", endtime)
+	}
+	db = db.Where("o.status=1")
 
 	err = db.Select("s.mode_id, count(s.mode_id) as number").Group("s.mode_id").Order("s.mode_id asc").Find(&ttd).Error
 	if err != nil {
 		return
 	}
 
-	offset := (page - 1) * limit
-
 	var ds []*DialysisTotalDataStruct
-	err = db.Select(datesql).Group(group).Count(&total).Order("date asc").Offset(offset).Limit(limit).Find(&ds).Error
+	err = db.Select(datesql).Group(group).Find(&ds).Error
 	if err != nil {
 		return
 	}
 			dates = append(dates, d.Date)
 		}
 
-		db = db.Where("s.record_date IN (?)", dates)
+		db = db.Where("o.dialysis_date IN (?)", dates)
 
 	}
 
-	err = db.Select(sql).Group(group + ", s.mode_id").Order("date asc, mode_id").Find(&dtd).Error
+	err = db.Select(sql).Group(group + ", s.mode_id").Order("date asc, s.mode_id").Find(&dtd).Error
 	return
+
 }
 
 func GetInspectionTotalCount(orgid int64) (configuration []*models.CheckConfiguration, err error) {
 	return
 }
 
-func GetSearchPatientInfo(orgid int64, keywords string, startime int64, endtime int64) (projectCounts []*models.UserInspectionProjectCounts, err error) {
+func GetSearchPatientInfo(orgid int64, keywords int64, startime int64, endtime int64) (projectCounts []*models.UserInspectionProjectCounts, err error) {
 
 	db := XTReadDB().Table("xt_inspection as x").Where("x.status = 1")
 	table := XTReadDB().Table("xt_inspection_reference as r")
 	fmt.Println(d)
 	p := XTReadDB().Table("xt_patients as p")
 	fmt.Println(p)
-	if len(keywords) > 0 {
-		likeKey := "%" + keywords + "%"
-		db = db.Where("p.name LIKE ? OR p.dialysis_no LIKE ?", likeKey, likeKey)
+	//if len(keywords) > 0 {
+	//	likeKey := "%" + keywords + "%"
+	//	db = db.Where("p.name LIKE ? OR p.dialysis_no LIKE ?", likeKey, likeKey)
+	//}
+	if keywords > 0 {
+		db = db.Where("x.patient_id = ?", keywords)
 	}
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	return inspection, err
 }
 
-func GetPatientNames(orgid int64, patientname string) (models.XtPatients, error) {
+func GetPatientNames(orgid int64, patientid int64) (models.XtPatients, error) {
 	patients := models.XtPatients{}
-	err := readDb.Where("user_org_id = ? and (name=? or dialysis_no=?) and status = 1", orgid, patientname, patientname).Find(&patients).Error
+	err := readDb.Where("user_org_id = ? and id = ? and status = 1", orgid, patientid).Find(&patients).Error
 	return patients, err
 }