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

controllers/new_mobile_api_controllers/new_dialysis_api_controller.go

 	limit, _ := this.GetInt64("limit")
 	page, _ := this.GetInt64("page")
 	fmt.Println("病人ID", newPatientInfo.BloodId)
-	advice, total, err := service.GetNewDoctorAdvice(newPatientInfo.BloodId, doctor_type, startime, endtime, limit, page, orgid)
-	one, t, date, err := service.GetNewDoctorAdviceOne(newPatientInfo.BloodId, page, orgid)
-	fmt.Print(one, t, date, err)
+	advice, _, err := service.GetNewDoctorAdvice(newPatientInfo.BloodId, doctor_type, startime, endtime, limit, page, orgid)
+	one, total, err := service.GetNewDoctorAdviceOne(newPatientInfo.BloodId, doctor_type, startime, endtime, limit, page, orgid)
+	fmt.Println("err------------------------", err)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 
 func (this *NewDialysisApiController) GetMyInformation() {
 	id, _ := this.GetInt64("id")
-	fmt.Println("id--------------", id)
 	roleInfo, err := service.GetPosition(id)
+
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 
 func (this *NewDialysisApiController) GetOrgName() {
 
-	orgid := this.GetMobileAdminUserInfo().Org.Id
-	name, err := service.GetOrgName(orgid)
+	id, _ := this.GetInt64("id")
+	name, err := service.GetOrgName(id)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 func (this *NewDialysisApiController) DeleteBed() {
 	id, _ := this.GetInt64("id")
 	fmt.Println("id", id)
-	err := service.DeleteBed(id)
-	fmt.Println("删除失败", err)
-	returnData := make(map[string]interface{}, 0)
-	returnData["msg"] = "删除失败"
-	this.ServeSuccessJSON(returnData)
-	return
+	nowDateTime := time.Now()
+	nowDate := nowDateTime.Format("2006-01-02")
+	nowDate += " 00:00:00"
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", nowDate, loc)
+	fmt.Println(theTime.Unix())
+	adminInfo := this.GetMobileAdminUserInfo()
+	orgid := adminInfo.Org.Id
+	_, errcode := service.GetSchedu(id, theTime.Unix(), orgid)
+	fmt.Println("errcode", errcode)
+	if errcode == gorm.ErrRecordNotFound {
+		err := service.DeleteBed(id)
+		fmt.Println("删除失败", err)
+		returnData := make(map[string]interface{}, 0)
+		returnData["msg"] = "删除失败"
+		this.ServeSuccessJSON(returnData)
+		return
+	} else if errcode == nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+
 }
 
 func (this *NewDialysisApiController) LoginOut() {
 
 	this.DelSession("mobile_admin_user_info")
 	this.Ctx.SetCookie("token_cookie", "")
+	id, _ := this.GetInt64("id")
+	fmt.Println("id------------------------------------------", id)
+	loginLog := models.SgjUserAdminLoginLog{
+		AdminUserId: id,
+		OrgId:       0,
+		AppId:       0,
+		Ip:          utils.GetIP(this.Ctx.Request),
+		OperateType: 2,
+		AppType:     0,
+		Ctime:       time.Now().Unix(),
+	}
+	err := service.CreateLoginLod(&loginLog)
+	fmt.Println("err--------", err)
 	returnData := make(map[string]interface{}, 0)
 	returnData["msg"] = "删除失败"
 	this.ServeSuccessJSON(returnData)
 }
 
 func (this *NewDialysisApiController) GetOrgInformation() {
+	id, _ := this.GetInt64("id")
+	information, err := service.GetOrgInformation(id)
+	name, err := service.GetShortName(information.OrgType)
+	typeName, err := service.GetTypeName(name.Pid)
+	//获取省
+	province, err := service.GetOrgProvince(information.Province)
+	cityes, err := service.GetOrgProvince(information.City)
+	district, err := service.GetOrgProvince(information.District)
+	fmt.Print("err", err)
+	//if err != nil {
+	//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+	//	return
+	//}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"information": information,
+		"name":        name,
+		"typeName":    typeName,
+		"province":    province,
+		"city":        cityes,
+		"district":    district,
+	})
+}
+
+func (this *NewDialysisApiController) GetAllOrgType() {
+
+	orgType, _ := service.GetAllOrgType()
+	returnData := make(map[string]interface{}, 0)
+	returnData["orgType"] = orgType
+	this.ServeSuccessJSON(returnData)
+}
+
+func (this *NewDialysisApiController) EditOrg() {
+	id, _ := this.GetInt64("id")
+	fmt.Println("id", id)
+	name := this.GetString("org_name")
+	fmt.Println("name", name)
+	provinceName := this.GetString("provinces_name")
+	fmt.Println("provinceName", provinceName)
+	cityName := this.GetString("city_name")
+	fmt.Println("cityName", cityName)
+	districtName := this.GetString("district_name")
+	fmt.Println("districtName", districtName)
+	address := this.GetString("address")
+	fmt.Println("address", address)
+	org_type := this.GetString("org_type")
+	fmt.Println("org_type", org_type)
+	contactName := this.GetString("contact_name")
+	fmt.Println("contactName", contactName)
+	orgPhone := this.GetString("telephone")
+	fmt.Println("orgPhone", orgPhone)
+	provinceID := 0
+	cityID := 0
+	districtID := 0
+	province, getProvinceErr := service.GetProvinceWithName(provinceName)
+	if getProvinceErr != nil {
+		utils.ErrorLog("查询省名失败：%v", getProvinceErr)
+		this.Data["json"] = enums.MakeFailResponseJSONWithSGJErrorCode(enums.ErrorCodeDataException)
+		this.ServeJSON()
+		return
+	} else if province != nil {
+		provinceID = int(province.ID)
+		city, getCityErr := service.GetCityWithName(province.ID, cityName)
+		if getCityErr != nil {
+			utils.ErrorLog("查询城市名失败：%v", getCityErr)
+			this.Data["json"] = enums.MakeFailResponseJSONWithSGJErrorCode(enums.ErrorCodeDataException)
+			this.ServeJSON()
+			return
+		} else if city != nil {
+			cityID = int(city.ID)
+			district, getDistrictErr := service.GetDistrictWithName(city.ID, districtName)
+			if getDistrictErr != nil {
+				utils.ErrorLog("查询区县名失败：%v", getDistrictErr)
+				this.Data["json"] = enums.MakeFailResponseJSONWithSGJErrorCode(enums.ErrorCodeDataException)
+				this.ServeJSON()
+				return
+			} else if district != nil {
+				districtID = int(district.ID)
+			}
+		}
+	}
+
+	orgType := service.GetOrgTypeByName(org_type)
+	fmt.Println(provinceID, cityID, districtID)
+	org := models.SgjUserOrg{
+		OrgName:      name,
+		OrgShortName: name,
+		Province:     int64(provinceID),
+		City:         int64(cityID),
+		District:     int64(districtID),
+		Address:      address,
+		OrgType:      orgType.ID,
+		Telephone:    orgPhone,
+		ContactName:  contactName,
+	}
+
+	fmt.Println("org", org)
+	err := service.UpdateOrg(id, org)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"org": org,
+	})
+}
+
+func (this *NewDialysisApiController) GetMyInforName() {
+
+	id, _ := this.GetInt64("id")
+	Rolename, err := service.GetMyInfoName(id)
+	Username, err := service.GetAdminName(Rolename.AdminUserId)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"Rolename": Rolename,
+		"Username": Username,
+	})
+}
 
+func (this *NewDialysisApiController) GetPartionDetail() {
+	id, _ := this.GetInt64("id")
+	partionDetail, err := service.GetPartionDetail(id)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"partionDetail": partionDetail,
+	})
+}
+
+func (this *NewDialysisApiController) UpdatePartition() {
+	id, _ := this.GetInt64("id")
+	name := this.GetString("name")
+	zoneType, _ := this.GetInt64("type")
+	strInt64 := strconv.FormatInt(zoneType, 10)
+	typeid, _ := strconv.Atoi(strInt64)
+	zone := models.DeviceZone{
+		Name: name,
+		Type: typeid,
+	}
+	err := service.UpdatePartition(id, &zone)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"zone": zone,
+	})
+}
+
+func (this *NewDialysisApiController) GetGroupDetail() {
+	id, _ := this.GetInt64("id")
+	groupDetail, err := service.GetGroupDetail(id)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"groupDetail": groupDetail,
+	})
+
+}
+
+func (this *NewDialysisApiController) UpdateGroup() {
+	id, _ := this.GetInt64("id")
+	name := this.GetString("name")
+	group := models.DeviceGroup{Name: name}
+	err := service.UpdateGroup(id, &group)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"group": group,
+	})
+}
+
+func (this *NewDialysisApiController) GetBedDetail() {
 	adminUser := this.GetMobileAdminUserInfo()
-	id := adminUser.Org.Id
-	information, err := service.GetOrgInformation(id)
+	orgid := adminUser.Org.Id
+	id, _ := this.GetInt64("id")
+	zone, _ := service.GetAllZoneOne(orgid)
+	group, err := service.GetAllGroupOne(orgid)
+	bedDetail, err := service.GetBedDetail(id)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 	}
 	this.ServeSuccessJSON(map[string]interface{}{
-		"information": information,
+		"zone":      zone,
+		"group":     group,
+		"bedDetail": bedDetail,
+	})
+}
+
+func (this *NewDialysisApiController) UpdatedBed() {
+	id, _ := this.GetInt64("id")
+	name := this.GetString("name")
+	fmt.Println("name", name)
+	zone, _ := this.GetInt64("zone")
+	fmt.Println("zone", zone)
+	group, _ := this.GetInt64("group")
+	fmt.Println("group", group)
+	number := models.DeviceNumber{
+		Number:  name,
+		ZoneID:  zone,
+		GroupID: group,
+	}
+	err := service.UpdatedBed(id, &number)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"number": number,
 	})
 }

controllers/new_mobile_api_controllers/new_mobile_api_router_register.go

 	beego.Router("/m/api/patient/getallorganization", &NewDialysisApiController{}, "Get:GetAllOrganization")
 	beego.Router("/m/api/patient/getmyorganazition", &NewDialysisApiController{}, "Get:GetMyOrganazition")
 	beego.Router("/m/api/org/getorginformation", &NewDialysisApiController{}, "Get:GetOrgInformation")
+	beego.Router("/m/api/patient/getallorgtype", &NewDialysisApiController{}, "Get:GetAllOrgType")
+	beego.Router("/m/api/patient/editorg", &NewDialysisApiController{}, "Get:EditOrg")
+	beego.Router("/m/api/patient/getmyinforname", &NewDialysisApiController{}, "Get:GetMyInforName")
+	beego.Router("/m/api/patient/getpartiondetail", &NewDialysisApiController{}, "Get:GetPartionDetail")
+	beego.Router("/m/api/patient/updatepartition", &NewDialysisApiController{}, "Get:UpdatePartition")
+	beego.Router("/m/api/patient/getgroupdetail", &NewDialysisApiController{}, "Get:GetGroupDetail")
+	beego.Router("/m/api/patient/updategroup", &NewDialysisApiController{}, "Get:UpdateGroup")
+	beego.Router("/m/api/patient/getbeddetail", &NewDialysisApiController{}, "Get:GetBedDetail")
+	beego.Router("/m/api/patient/updatebed", &NewDialysisApiController{}, "Get:UpdatedBed")
 }

models/org_models.go

 func (SgjUserOrg) TableName() string {
 	return "sgj_user_org"
 }
+
+type SgjUserDistrict struct {
+	ID        int64  `gorm:"column:id" json:"id" form:"id"`
+	Name      string `gorm:"column:name" json:"name" form:"name"`
+	Level     int64  `gorm:"column:level" json:"level" form:"level"`
+	Upid      int64  `gorm:"column:upid" json:"upid" form:"upid"`
+	Path      string `gorm:"column:path" json:"path" form:"path"`
+	Namepath  string `gorm:"column:namepath" json:"namepath" form:"namepath"`
+	Initial   string `gorm:"column:initial" json:"initial" form:"initial"`
+	Longitude string `gorm:"column:longitude" json:"longitude" form:"longitude"`
+	Latitude  string `gorm:"column:latitude" json:"latitude" form:"latitude"`
+	Adcode    int64  `gorm:"column:adcode" json:"adcode" form:"adcode"`
+}
+
+func (SgjUserDistrict) TableName() string {
+	return "sgj_user_district"
+}
+
+type SgjUserOrgType struct {
+	ID          int64  `gorm:"column:id" json:"id" form:"id"`
+	Name        string `gorm:"column:name" json:"name" form:"name"`
+	ShortName   string `gorm:"column:short_name" json:"short_name" form:"short_name"`
+	Pid         int64  `gorm:"column:pid" json:"pid" form:"pid"`
+	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"`
+	SortNo      int64  `gorm:"column:sort_no" json:"sort_no" form:"sort_no"`
+}
+
+func (SgjUserOrgType) TableName() string {
+	return "sgj_user_org_type"
+}

models/patient_models.go

 
 	return "xt_patients"
 }
+
+type SgjUserAdminLoginLog struct {
+	ID          int64  `gorm:"column:id" json:"id" form:"id"`
+	AdminUserId int64  `gorm:"column:admin_user_id" json:"admin_user_id" form:"admin_user_id"`
+	OrgId       int64  `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	AppId       int64  `gorm:"column:app_id" json:"app_id" form:"app_id"`
+	Ip          string `gorm:"column:ip" json:"ip" form:"ip"`
+	OperateType int64  `gorm:"column:operate_type" json:"operate_type" form:"operate_type"`
+	AppType     int64  `gorm:"column:app_type" json:"app_type" form:"app_type"`
+	Ctime       int64  `gorm:"column:ctime" json:"ctime" form:"ctime"`
+}
+
+func (SgjUserAdminLoginLog) TableName() string {
+
+	return "sgj_user_admin_login_log"
+}

service/patientmanage_service.go

 		db = db.Where("x.start_time>=?", start)
 	}
 	if end > 0 {
-		db = db.Where("start_time<=?", end)
+		db = db.Where("x.start_time<=?", end)
 	}
 	//offset := (page - 1) * limit
 	err = db.Group("x.id").Count(&total).Select("x.id, x.user_org_id, x.patient_id, x.advice_type, x.advice_date, x.record_date, x.start_time, x.advice_name,x.advice_desc, x.reminder_date, x.drug_spec, x.drug_spec_unit, x.single_dose, x.single_dose_unit, x.prescribing_number, x.prescribing_number_unit, x.delivery_way, x.execution_frequency, x.advice_doctor, x.status, x.created_time,x.updated_time, x.advice_affirm, x.remark, x.stop_time, x.stop_reason, x.stop_doctor, x.stop_state, x.parent_id, x.execution_time, x.execution_staff, x.execution_state, x.checker, x.check_state, x.check_time, x.groupno,x.remind_type,x.frequency_type,x.day_count,x.week_day,x.parent_id,r.user_name, IF(x.parent_id > 0, x.parent_id, x.id) as advice_order").Joins("Left join sgj_users.sgj_user_admin_role as r on r.admin_user_id = x.advice_doctor").Order("start_time desc, groupno desc, advice_order desc, id asc").Scan(&doctoradvice).Error
 
 }
 
-func GetNewDoctorAdviceOne(patientID int64, page int64, orgID int64) (doctoradvice []*models.DoctorAdvice, total int64, date int64, err error) {
-
-	var advicesCount models.UserDoctorAdvicesCount
-
-	err = XTReadDB().Model(&models.DoctorAdvice{}).Where("patient_id = ? and user_org_id = ? and status =1", patientID, orgID).Select("count(distinct record_date) as count,patient_id").Scan(&advicesCount).Error
-
-	if err != nil {
-		return
+func GetNewDoctorAdviceOne(patientID int64, advice_type int64, start int64, end int64, limit int64, page int64, orgID int64) (doctoradvice []*models.DoctorAdvice, total int64, err error) {
+	fmt.Println("advicetype------------------------------", advice_type)
+	db := readDb.Table("xt_doctor_advice as x").Where("x.status = 1")
+	table := UserReadDB().Table("sgj_user_admin_role as r")
+	fmt.Println("table", table)
+	if orgID > 0 {
+		db = db.Where("x.user_org_id=?", orgID)
 	}
-	total = advicesCount.Count
-	if total == 0 || page > total {
-		return
+	if patientID > 0 {
+		db = db.Where("x.patient_id = ?", patientID)
 	}
-
-	var Id models.AdviceDate
-
-	err = XTReadDB().Model(models.DoctorAdvice{}).Where("patient_id = ? and user_org_id = ? and status = 1", patientID, orgID).Select("record_date").Group("record_date").Order("created_time desc").Offset(page - 1).Limit(10).Scan(&Id).Error
-	if err != nil {
-		return
+	if advice_type > 0 {
+		db = db.Where("x.advice_type = ?", advice_type)
+	} else if advice_type == 0 {
+		db = db.Where("x.advice_type in (?)", []int{1, 3})
 	}
-
-	if Id.RecordDate == 0 {
-		return
+	if start > 0 {
+		db = db.Where("x.start_time>=?", start)
 	}
-
-	date = Id.RecordDate
-	fmt.Println("结构是==============", Id.RecordDate)
-	doctoradvice, err = GetAdvices(orgID, patientID, Id.RecordDate)
-	if err != nil {
-		return
+	if end > 0 {
+		db = db.Where("x.start_time<=?", end)
 	}
+	offset := (page - 1) * limit
+	err = db.Order("x.start_time desc").Group("x.start_time").Count(&total).Offset(offset).Limit(limit).Select("x.id, x.user_org_id, x.patient_id, x.advice_type, x.advice_date, x.record_date, x.start_time, x.advice_name,x.advice_desc, x.reminder_date, x.drug_spec, x.drug_spec_unit, x.single_dose, x.single_dose_unit, x.prescribing_number, x.prescribing_number_unit, x.delivery_way, x.execution_frequency, x.advice_doctor, x.status, x.created_time,x.updated_time, x.advice_affirm, x.remark, x.stop_time, x.stop_reason, x.stop_doctor, x.stop_state, x.parent_id, x.execution_time, x.execution_staff, x.execution_state, x.checker, x.check_state, x.check_time, x.groupno,x.remind_type,x.frequency_type,x.day_count,x.week_day,x.parent_id,r.user_name, IF(x.parent_id > 0, x.parent_id, x.id) as advice_order").Joins("Left join sgj_users.sgj_user_admin_role as r on r.admin_user_id = x.advice_doctor").Scan(&doctoradvice).Error
+	fmt.Print("错误是什么", err)
 	return
-
 }
 
 func GetDryWeight(patientid int64, startime int64, endtime int64, limit int64, page int64, orgId int64) (dryWeight []*models.XtPatientDryweight, total int64, err error) {
 func GetDoctorAdviceDetail(id int64, orgid int64) (advices []*models.DoctorAdvices, err error) {
 
 	db := XTReadDB().Table("xt_doctor_advice as x")
-	err = db.Order("x.id desc").Select("x.id,x.user_org_id,x.patient_id,x.advice_type,x.advice_date,x.start_time,x.advice_name,x.advice_desc,x.reminder_date,x.single_dose,x.single_dose_unit,x.prescribing_number,x.prescribing_number_unit,x.delivery_way,x.execution_frequency,x.advice_doctor,x.status,x.created_time,x.updated_time,x.advice_affirm,x.remark,x.stop_time,x.stop_reason,x.stop_doctor,x.stop_state,x.parent_id,x.execution_time,x.execution_staff,x.execution_state,x.checker,x.record_date,x.dialysis_order_id,x.check_time,x.check_state,x.drug_spec,x.drug_spec_unit,x.groupno,x.remind_type,x.frequency_type,x.day_count,x.week_day,x.template_id,x.modifier,s.name").Joins("left join xt_patients as s on s.id=x.patient_id").Where("x.groupno = ? and x.status = 1 and x.user_org_id = ?", id, orgid).Scan(&advices).Error
+	err = db.Order("x.id desc").Select("x.id,x.user_org_id,x.patient_id,x.advice_type,x.advice_date,x.start_time,x.advice_name,x.advice_desc,x.reminder_date,x.single_dose,x.single_dose_unit,x.prescribing_number,x.prescribing_number_unit,x.delivery_way,x.execution_frequency,x.advice_doctor,x.status,x.created_time,x.updated_time,x.advice_affirm,x.remark,x.stop_time,x.stop_reason,x.stop_doctor,x.stop_state,x.parent_id,x.execution_time,x.execution_staff,x.execution_state,x.checker,x.record_date,x.dialysis_order_id,x.check_time,x.check_state,x.drug_spec,x.drug_spec_unit,x.groupno,x.remind_type,x.frequency_type,x.day_count,x.week_day,x.template_id,x.modifier,s.name").Joins("left join xt_patients as s on s.id=x.patient_id").Where("x.start_time = ? and x.status = 1 and x.user_org_id = ?", id, orgid).Scan(&advices).Error
 
 	return advices, err
 }
 
 func DeleteManagement(groupid int64, orgid int64) error {
 
-	err := XTWriteDB().Model(models.DoctorAdvice{}).Where("groupno=? and user_org_id = ?", groupid, orgid).Update(map[string]interface{}{"status": 0, "updated_time": time.Now().Unix()}).Error
+	err := XTWriteDB().Model(models.DoctorAdvice{}).Where("start_time =? and user_org_id = ?", groupid, orgid).Update(map[string]interface{}{"status": 0, "updated_time": time.Now().Unix()}).Error
 	return err
 }
 
 
 func DeletePatient(id int64) error {
 
-	err = XTWriteDB().Model(models.DoctorAdvice{}).Where("id=? and parent_id = ?", id, id).Update(map[string]interface{}{"status": 0, "updated_time": time.Now().Unix()}).Error
+	err = XTWriteDB().Model(models.DoctorAdvice{}).Where("id=? or parent_id = ?", id, id).Update(map[string]interface{}{"status": 0, "updated_time": time.Now().Unix()}).Error
 	return err
 }
 
 		db = db.Where("x.org_id = ?", orgid)
 	}
 	offset := (page - 1) * limit
-	err = db.Group("x.id").Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Select("x.id,x.org_id,x.name,x.type,n.number").Joins("left join xt_device_number as n on n.zone_id = x.id").Scan(&zone).Error
+	err = db.Group("x.id").Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Select("x.id,x.org_id,x.name,x.type,n.number").Joins("left join xt_device_number as n on n.zone_id = x.id AND n.status = 1").Scan(&zone).Error
 	return zone, total, err
 }
 
 		db = db.Where("x.org_id = ?", orgid)
 	}
 	offset := (page - 1) * limit
-	err = db.Group("x.id").Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Select("x.id,x.org_id,x.name,x.status,x.ctime,x.mtime,n.number").Joins("left join xt_device_number as n on n.group_id = x.id").Scan(&group).Error
+	err = db.Group("x.id").Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Select("x.id,x.org_id,x.name,x.status,x.ctime,x.mtime,n.number").Joins("left join xt_device_number as n on n.group_id = x.id And n.status = 1").Scan(&group).Error
 	return group, total, err
 }
 
 		db = db.Where("x.org_id = ?", orgid)
 	}
 	offset := (page - 1) * limit
-	err = db.Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Select("x.id,x.org_id,x.number,x.group_id,x.zone_id,x.status").Find(&number).Error
+	err = db.Count(&total).Offset(offset).Limit(limit).Order("x.ctime asc").Select("x.id,x.org_id,x.number,x.group_id,x.zone_id,x.status").Find(&number).Error
 
 	return number, total, err
 }
 
+func GetSchedu(bedid int64, thetime int64, orgid int64) (*models.XtSchedule, error) {
+	schedule := models.XtSchedule{}
+	err := XTReadDB().Model(&schedule).Where("bed_id = ? and schedule_date = ? and user_org_id = ? and status = 1", bedid, thetime, orgid).Find(&schedule).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &schedule, nil
+
+}
+
 func DeleteBed(id int64) error {
 	err := XTWriteDB().Model(models.DeviceNumber{}).Where("id=?", id).Update(map[string]interface{}{"status": 0, "ctime": time.Now().Unix()}).Error
 	return err
 	err := UserReadDB().Where("id=? and status = 1", id).Find(&org).Error
 	return org, err
 }
+
+func GetShortName(orgtype int64) (models.SgjUserOrgType, error) {
+
+	orgType := models.SgjUserOrgType{}
+	err := UserReadDB().Model(&orgType).Where("id=? and status = 1", orgtype).Find(&orgType).Error
+	return orgType, err
+}
+
+func GetTypeName(id int64) (models.SgjUserOrgType, error) {
+	orgType := models.SgjUserOrgType{}
+	err := UserReadDB().Model(&orgType).Where("id=? and status = 1", id).Find(&orgType).Error
+	return orgType, err
+}
+
+func GetOrgProvince(id int64) (models.SgjUserDistrict, error) {
+
+	district := models.SgjUserDistrict{}
+	err := UserReadDB().Model(&district).Where("id=?", id).Find(&district).Error
+	return district, err
+}
+
+func GetAllOrgType() (orgType []*models.SgjUserOrgType, err error) {
+
+	err = UserReadDB().Model(&models.SgjUserOrgType{}).Where("status= ? AND id = ? OR id = ? OR id = ? OR id = ? OR id = ? OR id = ?", 1, 1, 7, 12, 16, 21, 26).Find(&orgType).Error
+	return
+}
+
+func UpdateOrg(id int64, org models.SgjUserOrg) error {
+
+	err := UserWriteDB().Model(&org).Where("id = ?", id).Update(map[string]interface{}{"org_name": org.OrgName, "org_short_name": org.OrgShortName, "province": org.Province, "city": org.City, "district": org.District, "address": org.Address, "org_type": org.OrgType, "telephone": org.Telephone, "contact_name": org.ContactName, "mtime": time.Now().Unix()}).Error
+	return err
+}
+
+func GetMyInfoName(id int64) (models.SgjUserAdminRole, error) {
+	role := models.SgjUserAdminRole{}
+	err := UserReadDB().Model(&role).Where("id=? and status = 1", id).Find(&role).Error
+	return role, err
+}
+
+func GetAdminName(id int64) (models.AdminUser, error) {
+	user := models.AdminUser{}
+	err := UserReadDB().Model(&user).Where("id=? and status =1", id).Find(&user).Error
+	return user, err
+}
+
+func GetPartionDetail(id int64) (models.DeviceZone, error) {
+
+	zone := models.DeviceZone{}
+	err := XTReadDB().Model(&zone).Where("id=? and status = 1", id).Find(&zone).Error
+	return zone, err
+}
+
+func UpdatePartition(id int64, zone *models.DeviceZone) error {
+
+	err := XTWriteDB().Model(&zone).Where("id=?", id).Update(map[string]interface{}{"name": zone.Name, "type": zone.Type, "mtime": time.Now().Unix()}).Error
+	return err
+}
+
+func GetGroupDetail(id int64) (models.DeviceGroup, error) {
+	group := models.DeviceGroup{}
+	err := XTReadDB().Model(&group).Where("id=? and status = 1", id).Find(&group).Error
+	return group, err
+}
+
+func UpdateGroup(id int64, group *models.DeviceGroup) error {
+
+	err := XTWriteDB().Model(&group).Where("id=?", id).Update(map[string]interface{}{"name": group.Name, "mtime": time.Now().Unix()}).Error
+	return err
+}
+
+func GetBedDetail(id int64) (models.DeviceNumber, error) {
+	number := models.DeviceNumber{}
+	err := XTReadDB().Model(&number).Where("id=? and status =1", id).Find(&number).Error
+	return number, err
+}
+
+func UpdatedBed(id int64, number *models.DeviceNumber) error {
+
+	err = XTWriteDB().Model(&number).Where("id=?", id).Update(map[string]interface{}{"number": number.Number, "zone_id": number.ZoneID, "group_id": number.GroupID, "mtime": time.Now().Unix()}).Error
+	return err
+}
+
+func CreateLoginLod(log *models.SgjUserAdminLoginLog) error {
+
+	err := UserWriteDB().Model(&log).Create(&log).Error
+	return err
+}