XT_New/controllers/manage_api_controller.go

package controllers

import (
	"XT_New/enums"
	"XT_New/models"
	"XT_New/service"
	"XT_New/utils"
	"encoding/json"
	"fmt"
	"github.com/astaxie/beego"
	"github.com/jinzhu/gorm"
	"strconv"
	"time"
	"unsafe"
)

type MachineApiController struct {
	BaseAuthAPIController
}

func ManageRouters() {
	beego.Router("/api/management/savemanageinfo", &MachineApiController{}, "post:SaveManageInfo")
	beego.Router("/api/management/updatemachineinfo", &MachineApiController{}, "post:UpdateMachineInfo")
	beego.Router("/api/manage/updatemacheinettwo", &MachineApiController{}, "post:Updatemacheinetwo")
	beego.Router("/api/management/getallequimentname", &MachineApiController{}, "get:GetAllEquimentName")
	beego.Router("/api/management/saveplan", &MachineApiController{}, "post:SavePlan")
	beego.Router("/api/management/getallplan", &MachineApiController{}, "get:GetAllPlan")
	beego.Router("/api/management/getallplandetail", &MachineApiController{}, "get:GetAllPlanDetail")
	beego.Router("/api/management/geteditmachine", &MachineApiController{}, "get:GetEditMahchine")
	beego.Router("/api/staff/deleteplans", &MachineApiController{}, "delete:DeletePlans")
	beego.Router("/api/manage/editplandetail", &MachineApiController{}, "get:EditPlanDetail")
	beego.Router("/api/manage/updateplaninfo", &MachineApiController{}, "post:UpdatePlanInfo")
	beego.Router("/api/manage/getcomprehensive", &MachineApiController{}, "get:GetComprehensive")
	beego.Router("/api/manage/saveinformation", &MachineApiController{}, "Post:SaveInformation")
	beego.Router("/api/manage/getpatientinfo", &MachineApiController{}, "Get:GetPatientInfo")
	beego.Router("/api/manage/changeclass", &MachineApiController{}, "Get:GetPatient")
	beego.Router("/api/manage/changepatient", &MachineApiController{}, "Get:ChangePatient")
	beego.Router("/api/manage/getallorganization", &MachineApiController{}, "Get:GetAllOrganization")
	beego.Router("/api/manage/getregisterinfo", &MachineApiController{}, "Get:GetRegisterInfo")
	beego.Router("/api/manage/getinformationdata", &MachineApiController{}, "Get:GetInformationData")
	beego.Router("/api/manage/getorgname", &MachineApiController{}, "Get:GetOrgName")
	beego.Router("/api/manage/savebacteria", &MachineApiController{}, "Post:SaveBacteria")
	beego.Router("/api/manage/savelincomycin", &MachineApiController{}, "Post:SaveLinconmycin")
	beego.Router("/api/manage/savequalitycontrol", &MachineApiController{}, "Post:SaveQualityControl")
	beego.Router("/api/manage/getallqulityinfo", &MachineApiController{}, "Get:GetAllQulityInfo")
	beego.Router("/api/manage/editculture", &MachineApiController{}, "Get:EditCulture")
	beego.Router("/api/manage/updateculture", &MachineApiController{}, "Post:UpdateCulture")
	beego.Router("/api/manage/deletecultrue", &MachineApiController{}, "delete:DeleteCultrue")
	beego.Router("/api/manage/editdialystate", &MachineApiController{}, "Get:EditDialystate")
	beego.Router("/api/manage/updatedialystate", &MachineApiController{}, "Post:Updatedialystate")
	beego.Router("/api/manage/deletedialystate", &MachineApiController{}, "delete:DeleteDialystate")
	beego.Router("/api/manage/edition", &MachineApiController{}, "Get:Edition")
	beego.Router("/api/manage/updateion", &MachineApiController{}, "Post:UpdateIon")
	beego.Router("/api/manage/deleteion", &MachineApiController{}, "delete:DeleteIon")
	beego.Router("/api/manage/query", &MachineApiController{}, "Get:GetQuery")
	beego.Router("/api/manage/saverepair", &MachineApiController{}, "Post:SaveRepair")
	beego.Router("/api/manage/getallrepair", &MachineApiController{}, "Get:GetAllRepair")
	beego.Router("/api/manage/editrepair", &MachineApiController{}, "Get:EditRepair")
	beego.Router("/api/manage/updaterepair", &MachineApiController{}, "Post:UpdateRepair")
	beego.Router("/api/manage/deleterepair", &MachineApiController{}, "delete:DeleteRepair")
	beego.Router("/api/manage/queryrepair", &MachineApiController{}, "Get:GetRepair")
	beego.Router("/api/manage/edituser", &MachineApiController{}, "Get:EditUser")
	beego.Router("/api/manage/deleteform", &MachineApiController{}, "delete:DeleteForm")
	beego.Router("/api/manage/updateform", &MachineApiController{}, "Post:UpdateForm")
	beego.Router("/api/manage/queryinfo", &MachineApiController{}, "Get:QueryInfo")
	beego.Router("/api/manage/insertautodata", &MachineApiController{}, "Get:InsertAutoData")
	beego.Router("/api/manage/getallequittype", &MachineApiController{}, "Get:GetAllEquitType")
	beego.Router("/api/manage/getuserform", &MachineApiController{}, "Get:GetUserForm")
	beego.Router("/api/manage/getbedform", &MachineApiController{}, "Get:GetBedForm")
	beego.Router("/api/manage/gettotalcount", &MachineApiController{}, "Get:GetTotalCount")
	beego.Router("/api/manage/getotalnumber", &MachineApiController{}, "Get:GetTotalNumber")
	beego.Router("/api/manage/gettimewarning", &MachineApiController{}, "Get:GetTimeWarning")
	beego.Router("/api/manage/savemanageinfotwo", &MachineApiController{}, "post:SaveManageinfoTwo")
	beego.Router("/api/management/updatemachineinfotwo", &MachineApiController{}, "post:UpdateMachinetwo")
	beego.Router("/api/manage/getallpatient", &MachineApiController{}, "get:GetAllpatient")
	beego.Router("/api/manage/changebed", &MachineApiController{}, "get:ChangeBed")
	beego.Router("/api/manage/getpatientdetail", &MachineApiController{}, "get:GetPatientDetail")
	beego.Router("/api/manage/changrun", &MachineApiController{}, "post:SaveReminder")
	beego.Router("/api/manage/getremanderdata", &MachineApiController{}, "get:GetRemanderData")
	beego.Router("/api/manage/opendelete", &MachineApiController{}, "delete:OpenDelete")
	beego.Router("/api/manage/deleteuserlogin", &MachineApiController{}, "delete:DeleteUserLogin")
	beego.Router("/api/manage/deletecultrues", &MachineApiController{}, "delete:DeleteCultrues")
	beego.Router("/api/manage/deletedialystates", &MachineApiController{}, "delete:DeleteDialystates")
	beego.Router("/api/manage/deleteions", &MachineApiController{}, "delete:Deleteions")
	beego.Router("/api/manage/deleterepairs", &MachineApiController{}, "delete:DeleteRepairs")
	beego.Router("/api/manage/savemode", &MachineApiController{}, "post:SaveMode")
	beego.Router("/api/manage/getallmode", &MachineApiController{}, "get:GetAllMode")
	beego.Router("/api/manage/editmode", &MachineApiController{}, "get:EditMode")
	beego.Router("/api/manage/updatemode", &MachineApiController{}, "post:UpdateMode")
	beego.Router("/api/manage/deletemode", &MachineApiController{}, "delete:DeleteMode")
	beego.Router("/api/manage/selectchange", &MachineApiController{}, "Get:SelectChange")
	beego.Router("/api/manage/selectbed", &MachineApiController{}, "get:SelectBed")
	beego.Router("/api/manage/getime", &MachineApiController{}, "get:GetTimeData")
	beego.Router("/api/manage/deleteimages", &MachineApiController{}, "delete:DeleteImages")
	beego.Router("/api/manage/getusermachtotalcount", &MachineApiController{}, "Get:GetUserMachTotalCount")
	beego.Router("/api/manage/getusertotalcount", &MachineApiController{}, "Get:GetUserTotalCount")
	beego.Router("/api/manage/deletemanagement", &MachineApiController{}, "Get:DeleteManagement")

	beego.Router("/api/manage/saveoxygenates", &MachineApiController{}, "Post:SaveOxygenates")
	beego.Router("/api/manage/savehardwater", &MachineApiController{}, "Post:SaveHardWater")
	beego.Router("/api/manage/savewater", &MachineApiController{}, "Post:SaveWater")
	beego.Router("/api/manage/savedeviceph", &MachineApiController{}, "Post:SaveDevicePH")
	beego.Router("/api/manage/editoxygenates", &MachineApiController{}, "Get:EditOxygenates")
	beego.Router("/api/manage/updateoxygenates", &MachineApiController{}, "Post:UpdateOxygenates")
	beego.Router("/api/manage/edithardwater", &MachineApiController{}, "Get:EditHardWater")
	beego.Router("/api/manage/editwater", &MachineApiController{}, "Get:EditWater")
	beego.Router("/api/manage/editdeviceph", &MachineApiController{}, "Get:EditDevicePh")
	beego.Router("/api/manage/getalldoctlist", &MachineApiController{}, "Get:GetAllDoctorList")
	beego.Router("/api/manage/saveairdisinfect", &MachineApiController{}, "Get:SaveAirDisinfect")
	beego.Router("/api/manage/getairlist", &MachineApiController{}, "Get:GetAirList")
	beego.Router("/api/manage/getairdisinfctdetal", &MachineApiController{}, "Get:GetAirDisinfetDetail")
	beego.Router("/api/manage/updateairdisinfect", &MachineApiController{}, "Get:UpdateAirDisinfect")
	beego.Router("/api/manage/deleteairdisinfect", &MachineApiController{}, "Get:DeleteAirDisinfect")
	beego.Router("/api/manage/savebodydisinfect", &MachineApiController{}, "Get:SaveBodyDisinfect")
	beego.Router("/api/manage/getbodylist", &MachineApiController{}, "Get:GetBodyList")
	beego.Router("/api/manage/getbodydisinfectdetal", &MachineApiController{}, "Get:GetBodyDisinfetDetail")
	beego.Router("/api/manage/updatebodydisinfect", &MachineApiController{}, "Get:UpdateBodyDisinfect")
	beego.Router("/api/manage/deletebodydisinfect", &MachineApiController{}, "Get:DeleteBodyDisInfect")
	beego.Router("/api/manage/updatehadwater", &MachineApiController{}, "Post:UpdateHadWater")
	beego.Router("/api/manage/updatewater", &MachineApiController{}, "Post:UpdateWater")
	beego.Router("/api/manage/updatedeviceph", &MachineApiController{}, "Post:UpdateDevicePh")
	beego.Router("/api/manage/deleteoxygenates", &MachineApiController{}, "Get:DeleteOxygenates")
	beego.Router("/api/manage/deletehadwater", &MachineApiController{}, "Get:DeleteHadWater")
	beego.Router("/api/manage/deletewater", &MachineApiController{}, "Get:DeleteWater")
	beego.Router("/api/manage/deletedeviceph", &MachineApiController{}, "Get:DeleteDevicePh")

	//	新版本
	beego.Router("/api/manage/getalldoctorlist", &MachineApiController{}, "Get:GetAllDoctorList")

	beego.Router("/api/manage/savewaterlist", &MachineApiController{}, "Post:SaveWaterList")
	beego.Router("/api/manage/getwaterformlist", &MachineApiController{}, "Get:GetWaterFormList")
	beego.Router("/api/manage/dialysisdeletewater", &MachineApiController{}, "Get:DeleteDialysisWater")
	beego.Router("/api/manage/getdialysiswaterdetail", &MachineApiController{}, "Get:GetDialysisWaterDetail")
	beego.Router("/api/manage/updatedialysiswater", &MachineApiController{}, "Post:UpdateDialysisWater")
	beego.Router("/api/manage/deletebatchdialysiswater", &MachineApiController{}, "Delete:DeleteBatchDialysisWater")

	beego.Router("/api/manage/savenewairdisinfect", &MachineApiController{}, "Post:SaveNewAirDisInfect")
	beego.Router("/api/manage/getnewairdisinfectlist", &MachineApiController{}, "Get:GetNewAirDisinfectList")
	beego.Router("/api/manage/getnewairdisinfectbyidlist", &MachineApiController{}, "Get:GetNewAirDisinfectByIdList")
	beego.Router("/api/manage/updatenewairdisinfect", &MachineApiController{}, "Post:UpdateNewAirDisInfect")
	beego.Router("/api/manage/deletenewairdisinfect", &MachineApiController{}, "Get:DeleteNewAirDisinfect")

	beego.Router("/api/manage/saveobjtabledisinfect", &MachineApiController{}, "Post:SaveObjTableDisInfect")
	beego.Router("/api/manage/getobjcttabledisinfectlist", &MachineApiController{}, "Get:GetObjectTableDisinfectList")
	beego.Router("/api/manage/getobjecttabledisinfectbyidlist", &MachineApiController{}, "Get:GetObjectTableDisinfectByList")
	beego.Router("/api/manage/updateobjecttabledisinfect", &MachineApiController{}, "Post:UpdateObjectTableDisinfect")
	beego.Router("/api/manage/deleteobjecttabledisinfect", &MachineApiController{}, "Get:DeleteObjectTableDisinfect")
	beego.Router("/api/manage/getairdisinfectionlongtime", &MachineApiController{}, "Get:GetAirDisinfectionLongTime")
	beego.Router("/api/manage/getobjcttabledisinfectlongtime", &MachineApiController{}, "Get:GetObjectDisInfectionLongTime")

	beego.Router("/api/manage/getinformationmanalist", &MachineApiController{}, "Get:GetInformationmanalist")

	beego.Router("/api/manage/saveobjectregistration", &MachineApiController{}, "Post:SaveObjectRegistration")
	beego.Router("/api/manage/getregistrationdisinfectlist", &MachineApiController{}, "Get:GetRegistrationDisinfectList")
	beego.Router("/api/manage/getobjectregistrationbyidlist", &MachineApiController{}, "Get:GetObjectRegistrationByIdList")
	beego.Router("/api/manage/updateobjectregistration", &MachineApiController{}, "Post:UpdateObjectRegistration")
	beego.Router("/api/manage/deleteobjectregistration", &MachineApiController{}, "Get:DeleteObjectTregistration")

	beego.Router("/api/manage/getregistgoodinforlist", &MachineApiController{}, "Get:GetRegistGoodInforList")
	beego.Router("/api/manage/getregistnumber", &MachineApiController{}, "Get:GetRegistNumber")

	beego.Router("/api/manage/savesetairdisinfect", &MachineApiController{}, "Get:SaveSetAirDisInfect")
	beego.Router("/api/manage/getsetairinfectbyid", &MachineApiController{}, "Get:GetSetAirInfectById")
	beego.Router("/api/manage/savenewairwaydisinfect", &MachineApiController{}, "Post:SaveNewAirWayDisinfect")
	beego.Router("/api/manage/getnewairwaydisinfectlist", &MachineApiController{}, "Get:GetNewAirWayDisinfectList")
	beego.Router("/api/manage/getairdisinfectwaylongtime", &MachineApiController{}, "Get:GetAirDisinfectWayLongTime")
	beego.Router("/api/manage/getnewairwaydisinfectbyidlist", &MachineApiController{}, "Get:GetNewAirWayDisinfectByIdList")
	beego.Router("/api/manage/updatenewairwaydisinfect", &MachineApiController{}, "Post:UpdateNewAirWayDisInfect")
	beego.Router("/api/manage/deletenewairwaydisinfect", &MachineApiController{}, "Get:DeleteNewAirWayDisinfect")

	beego.Router("/api/manage/setobjectdisinfect", &MachineApiController{}, "Get:SaveSetObjectDisinfect")
	beego.Router("/api/manage/getobjectwaydisinfect", &MachineApiController{}, "Get:GetObjectWayDisinect")
	beego.Router("/api/manage/saveobjectwaytabledisinfect", &MachineApiController{}, "Post:SaveObjectWayTableDisinfect")
	beego.Router("/api/manage/getobjcettabledisinfectwaylist", &MachineApiController{}, "Get:GetObjectAbleDisInfectWayList")
	beego.Router("/api/manage/getobjecttabledisinfectwaybylist", &MachineApiController{}, "Get:GetObjectAbledDisInfectWayById")
	beego.Router("/api/manage/updateobjectwaytabledisinfect", &MachineApiController{}, "Post:UpdateObjectWayAbleDisinfect")
	beego.Router("/api/manage/deleteobjecttablewaydisinfect", &MachineApiController{}, "Get:DeleteObjectAbleWayDisinfect")
}

func (this *MachineApiController) SaveManageInfo() {
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)

	serial_numbe := dataBody["serial_number"].(string)

	device_type := int64(dataBody["device_type"].(float64))

	bed_number := int64(dataBody["bed_number"].(float64))

	//通过床位id获取区号id
	number, err := service.GetZoneId(bed_number, orgid)

	device_name := dataBody["device_name"].(string)

	manufacture_factory := dataBody["manufacture_factory"].(string)

	service_manufacturer := dataBody["service_manufacturer"].(string)

	unittype := int64(dataBody["unit_type"].(float64))
	unit_type := strconv.FormatInt(unittype, 10)

	use_section := dataBody["use_section"].(string)

	section_number := dataBody["section_number"].(string)

	buy_date := dataBody["buy_date"].(string)

	timeLayout := "2006-01-02 15:04:05"
	theTime, err := utils.ParseTimeStringToTime(timeLayout, buy_date+" 00:00:00")
	buydate := theTime.Unix()
	int_num := *(*int)(unsafe.Pointer(&buydate))
	if int_num < 0 {
		buydate = 0
	}

	install_date := dataBody["install_date"].(string)
	toTime, err := utils.ParseTimeStringToTime(timeLayout, install_date+" 00:00:00")
	installdate := toTime.Unix()
	buy_num := *(*int)(unsafe.Pointer(&installdate))
	if buy_num < 0 {
		installdate = 0
	}

	start_date := dataBody["start_date"].(string)
	stringToTime, err := utils.ParseTimeStringToTime(timeLayout, start_date+" 00:00:00")
	startdate := stringToTime.Unix()
	start_num := *(*int)(unsafe.Pointer(&startdate))
	if start_num < 0 {
		startdate = 0
	}
	maintenance_engineer := dataBody["maintenance_engineer"].(string)
	telephone := dataBody["telephone"].(string)
	guarantee_date := dataBody["guarantee_date"].(string)
	machine_status := int64(dataBody["machine_status"].(float64))
	user_total := dataBody["user_total"].(string)
	disinfection_mode := int64(dataBody["Disinfection_mode"].(float64))
	remarks := dataBody["remarks"].(string)
	rubbish_date := dataBody["rubbish_date"].(string)
	timeStringToTime, err := utils.ParseTimeStringToTime(timeLayout, rubbish_date+" 00:00:00")
	rubbishdate := timeStringToTime.Unix()
	rubb_num := *(*int)(unsafe.Pointer(&rubbishdate))
	if rubb_num < 0 {
		rubbishdate = 0
	}
	rubbish_reason := int64(dataBody["rubbish_reason"].(float64))
	user_year := dataBody["user_year"].(string)
	work_time := dataBody["work_time"].(string)
	treat_types := dataBody["treat_type"].([]interface{})
	revers := int64(dataBody["revers_mode"].(float64))
	zone_id := int64(dataBody["zone_id"].(float64))
	ids := make([]int64, 0)
	for _, treat := range treat_types {
		id := int64(treat.(float64))
		ids = append(ids, id)
	}

	//查询机位号是否绑定设备
	thisAddmacher, err := service.GetEquitmentByBedID(bed_number, orgid)
	if thisAddmacher.ID > 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeEquitNoExist)
		return
	}

	addmacher := &models.DeviceAddmacher{
		SerialNumber:        serial_numbe,
		DeviceType:          device_type,
		BedNumber:           number.Number,
		BedId:               bed_number,
		ZoneId:              zone_id,
		DeviceName:          device_name,
		ManufactureFactory:  manufacture_factory,
		ServiceManufacturer: service_manufacturer,
		UnitType:            unittype,
		UseSection:          use_section,
		SectionNumber:       section_number,
		BuyDate:             buydate,
		InstallDate:         installdate,
		StartDate:           startdate,
		MaintenaceEngineer:  maintenance_engineer,
		Telephone:           telephone,
		GuaranteeDate:       guarantee_date,
		MachineStatus:       machine_status,
		UserTotal:           user_total,
		DisinfectionMode:    disinfection_mode,
		Remarks:             remarks,
		RubbishDate:         rubbishdate,
		RubbishReason:       rubbish_reason,
		UserYear:            user_year,
		WorkTime:            work_time,
		ReversMode:          revers,
		Status:              1,
		Ctime:               time.Now().Unix(),
		UserOrgId:           orgid,
	}
	err = service.CreateMacher(addmacher)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加设备失败")
		return
	}
	deviceAddmacher, err := service.GetLastMacherData(orgid)
	//	fmt.Println("错误是什么", err)
	equimentname := models.DeviceEquimentname{
		EquitmentName: unit_type,
		Status:        1,
		UserOrgId:     orgid,
		Ctime:         time.Now().Unix(),
		EquitmentId:   deviceAddmacher.ID,
		BedId:         bed_number,
	}
	error := service.AddTreatMode(deviceAddmacher.ID, orgid, ids)
	fmt.Println("error:", error)
	err = service.CreateEquimentName(equimentname)
	fmt.Println("添加设备型号失败", err)
	this.ServeSuccessJSON(map[string]interface{}{
		"addmacher": addmacher,
	})
}

func (this *MachineApiController) UpdateMachineInfo() {
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	id := int64(dataBody["id"].(float64))
	serial_number := dataBody["serial_number"].(string)
	device_type := int64(dataBody["devicetype"].(float64))
	bed_number := int64(dataBody["bed_number"].(float64))
	number, err := service.GetZoneId(bed_number, orgid)
	device_name := dataBody["device_name"].(string)
	manufacture_factory := dataBody["manufacture_factory"].(string)
	service_manufacturer := dataBody["service_manufacturer"].(string)
	unit_type := int64(dataBody["unit_type"].(float64))
	use_section := dataBody["use_section"].(string)
	section_number := dataBody["section_number"].(string)
	buy_date := dataBody["buy_date"].(string)
	timeLayout := "2006-01-02 15:04:05"
	theTime, err := utils.ParseTimeStringToTime(timeLayout, buy_date+" 00:00:00")
	buydate := theTime.Unix()
	int_num := *(*int)(unsafe.Pointer(&buydate))
	if int_num < 0 {
		buydate = 0
	}
	install_date := dataBody["install_date"].(string)
	toTime, err := utils.ParseTimeStringToTime(timeLayout, install_date+" 00:00:00")
	installdate := toTime.Unix()
	buy_num := *(*int)(unsafe.Pointer(&installdate))
	if buy_num < 0 {
		installdate = 0
	}
	start_date := dataBody["start_date"].(string)
	stringToTime, err := utils.ParseTimeStringToTime(timeLayout, start_date+" 00:00:00")
	startdate := stringToTime.Unix()
	start_num := *(*int)(unsafe.Pointer(&startdate))
	if start_num < 0 {
		startdate = 0
	}
	maintenance_engineer := dataBody["maintenance_engineer"].(string)
	telephone := dataBody["telephone"].(string)
	guarantee_date := dataBody["guarantee_date"].(string)
	machine_status := int64(dataBody["machine_status"].(float64))
	user_total := dataBody["user_total"].(string)
	remarks := dataBody["remarks"].(string)
	rubbish_date := dataBody["rubbish_date"].(string)
	timeStringToTime, err := utils.ParseTimeStringToTime(timeLayout, rubbish_date+" 00:00:00")
	rubbishdate := timeStringToTime.Unix()
	rubb_num := *(*int)(unsafe.Pointer(&rubbishdate))
	if rubb_num < 0 {
		rubbishdate = 0
	}
	rubbish_reason := int64(dataBody["rubbish_reason"].(float64))
	user_year := dataBody["user_year"].(string)
	work_time := dataBody["work_time"].(string)
	treat_types := dataBody["treat_type"].([]interface{})
	ids := make([]int64, 0)
	for _, treat := range treat_types {
		id := int64(treat.(float64))
		ids = append(ids, id)
	}
	thisAddmacher, err := service.GetEquitmentByBedID(bed_number, orgid)
	if thisAddmacher.ID > 0 && thisAddmacher.ID != id {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisNoExist)
		return
	}
	zone_id := int64(dataBody["zone_id"].(float64))
	addmacher := models.DeviceAddmacher{
		ID:                  id,
		SerialNumber:        serial_number,
		DeviceType:          device_type,
		BedNumber:           number.Number,
		BedId:               bed_number,
		DeviceName:          device_name,
		ManufactureFactory:  manufacture_factory,
		ServiceManufacturer: service_manufacturer,
		UnitType:            unit_type,
		UseSection:          use_section,
		SectionNumber:       section_number,
		BuyDate:             buydate,
		InstallDate:         installdate,
		StartDate:           startdate,
		MaintenaceEngineer:  maintenance_engineer,
		Telephone:           telephone,
		GuaranteeDate:       guarantee_date,
		MachineStatus:       machine_status,
		UserTotal:           user_total,
		Remarks:             remarks,
		RubbishDate:         rubbishdate,
		RubbishReason:       rubbish_reason,
		UserYear:            user_year,
		WorkTime:            work_time,
		ZoneId:              zone_id,
	}
	err = service.UpdateMachine(id, orgid, &addmacher)
	errors := service.UpdateTreatMode(id, orgid, ids)
	fmt.Println("更新透析模式失败", errors)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"addmacher": addmacher,
	})
}

func (this *MachineApiController) UpdateMachinetwo() {
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	id := int64(dataBody["id"].(float64))
	bed_nunmber := dataBody["beds"].(string)
	serial_number := dataBody["serial_number"].(string)
	device_type := int64(dataBody["devicetype"].(float64))
	device_name := dataBody["device_name"].(string)
	manufacture_factory := dataBody["manufacture_factory"].(string)
	service_manufacturer := dataBody["service_manufacturer"].(string)
	unit_type := int64(dataBody["unit_type"].(float64))
	use_section := dataBody["use_section"].(string)
	section_number := dataBody["section_number"].(string)
	buy_date := dataBody["buy_date"].(string)
	timeLayout := "2006-01-02 15:04:05"
	theTime, err := utils.ParseTimeStringToTime(timeLayout, buy_date+" 00:00:00")
	buydate := theTime.Unix()
	int_num := *(*int)(unsafe.Pointer(&buydate))
	if int_num < 0 {
		buydate = 0
	}
	install_date := dataBody["install_date"].(string)
	toTime, err := utils.ParseTimeStringToTime(timeLayout, install_date+" 00:00:00")
	installdate := toTime.Unix()
	buy_num := *(*int)(unsafe.Pointer(&installdate))
	if buy_num < 0 {
		installdate = 0
	}
	start_date := dataBody["start_date"].(string)
	stringToTime, err := utils.ParseTimeStringToTime(timeLayout, start_date+" 00:00:00")
	startdate := stringToTime.Unix()
	start_num := *(*int)(unsafe.Pointer(&startdate))
	if start_num < 0 {
		startdate = 0
	}
	maintenance_engineer := dataBody["maintenance_engineer"].(string)
	telephone := dataBody["telephone"].(string)
	guarantee_date := dataBody["guarantee_date"].(string)
	machine_status := int64(dataBody["machine_status"].(float64))
	user_total := dataBody["user_total"].(string)
	remarks := dataBody["remarks"].(string)
	rubbish_date := dataBody["rubbish_date"].(string)
	timeStringToTime, err := utils.ParseTimeStringToTime(timeLayout, rubbish_date+" 00:00:00")
	rubbishdate := timeStringToTime.Unix()
	rubb_num := *(*int)(unsafe.Pointer(&rubbishdate))
	if rubb_num < 0 {
		rubbishdate = 0
	}
	rubbish_reason := int64(dataBody["rubbish_reason"].(float64))
	user_year := dataBody["user_year"].(string)
	work_time := dataBody["work_time"].(string)
	disinfection_mode := int64(dataBody["Disinfection_mode"].(float64))

	revers_modes := int64(dataBody["revers_mode"].(float64))

	zone_id := int64(dataBody["zone_id"].(float64))
	addmacher := models.DeviceAddmacher{
		ID:                  id,
		SerialNumber:        serial_number,
		DeviceType:          device_type,
		BedNumber:           bed_nunmber,
		DeviceName:          device_name,
		ManufactureFactory:  manufacture_factory,
		ServiceManufacturer: service_manufacturer,
		UnitType:            unit_type,
		UseSection:          use_section,
		SectionNumber:       section_number,
		BuyDate:             buydate,
		InstallDate:         installdate,
		StartDate:           startdate,
		MaintenaceEngineer:  maintenance_engineer,
		Telephone:           telephone,
		GuaranteeDate:       guarantee_date,
		MachineStatus:       machine_status,
		UserTotal:           user_total,
		Remarks:             remarks,
		RubbishDate:         rubbishdate,
		RubbishReason:       rubbish_reason,
		UserYear:            user_year,
		WorkTime:            work_time,
		DisinfectionMode:    disinfection_mode,
		ReversMode:          revers_modes,
		ZoneId:              zone_id,
	}
	err = service.UpdateMachine(id, orgid, &addmacher)
	fmt.Println("报错", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"addmacher": addmacher,
	})
}

func (this *MachineApiController) Updatemacheinetwo() {
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	//fmt.Println("机构id", orgid)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	//fmt.Println("错误是", err)
	id := int64(dataBody["id"].(float64))
	//fmt.Println("id是什么", id)
	//serial_number := int64(dataBody["serial_number"].(float64))
	serial_number := dataBody["serial_number"].(string)
	//fmt.Println("序列号", serial_number)
	device_type := int64(dataBody["devicetype"].(float64))
	//fmt.Println("设备类型", device_type)

	//bed_number := int64(dataBody["bed_number"].(float64))
	//fmt.Println("机位号", bed_number)
	bednumber := dataBody["bed_numbers"].(string)
	//fmt.Println("机位号", bednumber)

	//number, err := service.GetZoneId(bed_number, orgid)

	//fmt.Println("number是多少", number)
	device_name := dataBody["device_name"].(string)
	//fmt.Println("设备名称", device_name)
	manufacture_factory := dataBody["manufacture_factory"].(string)
	//fmt.Println("生产厂家", manufacture_factory)
	service_manufacturer := dataBody["service_manufacturer"].(string)
	//fmt.Println("维修厂家", service_manufacturer)
	unittype := int64(dataBody["unit_type"].(float64))
	//unit_type := strconv.FormatInt(unittype, 10)
	//fmt.Println("设备型号", unit_type)
	use_section := dataBody["use_section"].(string)
	//fmt.Println("使用科室", use_section)
	section_number := dataBody["section_number"].(string)
	//fmt.Println("科室编号", section_number)
	buy_date := dataBody["buy_date"].(string)
	//fmt.Println("buy_date", buy_date)
	timeLayout := "2006-01-02 15:04:05"
	theTime, err := utils.ParseTimeStringToTime(timeLayout, buy_date+" 00:00:00")
	buydate := theTime.Unix()
	int_num := *(*int)(unsafe.Pointer(&buydate))
	if int_num < 0 {
		buydate = 0
	}
	//fmt.Println("购买日期", buydate)
	install_date := dataBody["install_date"].(string)
	toTime, err := utils.ParseTimeStringToTime(timeLayout, install_date+" 00:00:00")
	installdate := toTime.Unix()
	buy_num := *(*int)(unsafe.Pointer(&installdate))
	if buy_num < 0 {
		installdate = 0
	}
	//fmt.Println("安装日期", installdate)

	start_date := dataBody["start_date"].(string)
	stringToTime, err := utils.ParseTimeStringToTime(timeLayout, start_date+" 00:00:00")
	startdate := stringToTime.Unix()
	start_num := *(*int)(unsafe.Pointer(&startdate))
	if start_num < 0 {
		startdate = 0
	}
	//fmt.Println("启用日期", startdate)
	maintenance_engineer := dataBody["maintenance_engineer"].(string)
	//fmt.Println("维修工程", maintenance_engineer)
	telephone := dataBody["telephone"].(string)
	//fmt.Println("telephone", telephone)
	guarantee_date := dataBody["guarantee_date"].(string)
	//fmt.Println("保修期限", guarantee_date)
	machine_status := int64(dataBody["machine_status"].(float64))
	//fmt.Println("机器状态", machine_status)
	user_total := dataBody["user_total"].(string)
	//fmt.Println("初次使用次数", user_total)
	remarks := dataBody["remarks"].(string)
	//fmt.Println("备注", remarks)
	rubbish_date := dataBody["rubbish_date"].(string)
	timeStringToTime, err := utils.ParseTimeStringToTime(timeLayout, rubbish_date+" 00:00:00")
	rubbishdate := timeStringToTime.Unix()
	rubb_num := *(*int)(unsafe.Pointer(&rubbishdate))
	if rubb_num < 0 {
		rubbishdate = 0
	}
	//fmt.Println("报废日期", rubbishdate)
	rubbish_reason := int64(dataBody["rubbish_reason"].(float64))
	//fmt.Println("报废原因", rubbish_reason)
	user_year := dataBody["user_year"].(string)
	//fmt.Println("使用年限", user_year)
	work_time := dataBody["work_time"].(string)
	//fmt.Println("工作时长", work_time)
	addmacher := models.DeviceAddmacher{
		ID:                  id,
		SerialNumber:        serial_number,
		DeviceType:          device_type,
		BedNumber:           bednumber,
		DeviceName:          device_name,
		ManufactureFactory:  manufacture_factory,
		ServiceManufacturer: service_manufacturer,
		UnitType:            unittype,
		UseSection:          use_section,
		SectionNumber:       section_number,
		BuyDate:             buydate,
		InstallDate:         installdate,
		StartDate:           startdate,
		MaintenaceEngineer:  maintenance_engineer,
		Telephone:           telephone,
		GuaranteeDate:       guarantee_date,
		MachineStatus:       machine_status,
		UserTotal:           user_total,
		Remarks:             remarks,
		RubbishDate:         rubbishdate,
		RubbishReason:       rubbish_reason,
		UserYear:            user_year,
		WorkTime:            work_time,
	}
	//fmt.Println("addmacher", addmacher)
	err = service.UpdateMachine(id, orgid, &addmacher)
	//fmt.Println("报错", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"addmacher": addmacher,
	})
}

func (this *MachineApiController) GetAllEquimentName() {
	adminUser := this.GetAdminUserInfo()
	orgid := adminUser.CurrentOrgId
	equit, err := service.GetAllEquimentName(orgid)
	list, _ := service.GetAllDeviceMode(orgid)

	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"equit": equit,
		"list":  list,
	})
}

func (this *MachineApiController) SavePlan() {
	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	device_type := int64(dataBody["device_type"].(float64))
	disinfec_time := dataBody["disinfec_time"].(string)
	time := dataBody["time"].([]interface{})
	ids := make([]int64, 0)
	for _, t := range time {
		id := int64(t.(float64))
		ids = append(ids, id)
	}
	classtime := dataBody["class_time"].([]interface{})
	classids := make([]int64, 0)
	for _, class := range classtime {
		id := int64(class.(float64))
		classids = append(classids, id)
	}
	way := int64(dataBody["way"].(float64))
	machinedisinfectant := int64(dataBody["machine_disinfectant"].(float64))
	disinfectantway := int64(dataBody["disinfectant_way"].(float64))
	disinfectant := int64(dataBody["disinfectant"].(float64))
	bed_way := int64(dataBody["bed_way"].(float64))
	bed, err := service.GetBed(id)
	_, errcode := service.QueryPlan(orgid, device_type, ids, classids, id)

	if errcode == gorm.ErrRecordNotFound {
		err = service.AddPlan(orgid, device_type, disinfec_time, ids, classids, way, machinedisinfectant, disinfectantway, disinfectant, id, bed.BedId, bed_way)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加计划失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"msg": "msg",
		})
	} else if errcode == nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "已存在")
		return
	} else {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "已存在")
		return
	}

}

func (this *MachineApiController) GetAllPlan() {
	adminUserin := this.GetAdminUserInfo()
	orgid := adminUserin.CurrentOrgId
	plan, err := service.GetAllPlan(orgid)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"plan": plan,
	})
}

func (this *MachineApiController) GetAllPlanDetail() {
	//id, _ := this.GetInt64("id")
	//更据设备ID获取设备型号
	//fmt.Print("=================失败ID",id)
	unitype := this.GetString("unitype")
	deviceType, err2 := service.GetDeviceType(unitype)
	fmt.Print("eer2", err2)
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	//fmt.Println("orgid", orgid)
	plandetail, err := service.GetAllPlanDetail(deviceType.ID, orgid)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"plandetail": plandetail,
	})
}

func (this *MachineApiController) GetEditMahchine() {
	id, _ := this.GetInt64("id")
	fmt.Print("id", id)
}

func (this *MachineApiController) DeletePlans() {
	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	idsInters := dataBody["ids"].([]interface{})
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	err = service.DeletePlans(OrgID, ids)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) EditPlanDetail() {
	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	plan, err := service.GetPlanDetailById(id, orgId)
	fmt.Println("err", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"plan": plan,
	})
}

func (this *MachineApiController) UpdatePlanInfo() {

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	//fmt.Println("错误是", err)
	id := int64(dataBody["id"].(float64))
	//fmt.Println("id", id)
	device_type := int64(dataBody["device_type"].(float64))
	//fmt.Println("设备型号", device_type)

	disinfec_time := int64(dataBody["disinfec_time"].(float64))
	//fmt.Println("消毒时长", disinfec_time)

	time := int64(dataBody["time"].(float64))
	//fmt.Println("时间", time)
	classtime := int64(dataBody["class_time"].(float64))
	//fmt.Println("班次", classtime)
	way := int64(dataBody["way"].(float64))
	//fmt.Println("基表消毒方式", way)

	machinedisinfectant := int64(dataBody["machine_disinfectant"].(float64))
	//fmt.Println("基表消毒液", machinedisinfectant)

	disinfectantway := int64(dataBody["disinfectant_way"].(float64))
	fmt.Println("液路消毒方式", disinfectantway)

	disinfectant := int64(dataBody["disinfectant"].(float64))
	//fmt.Println("液路消毒液", disinfectant)

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	//fmt.Println("orgid", orgid)
	plan := models.DevicePlan{
		DeviceType:          device_type,
		DisinfecTime:        disinfec_time,
		Time:                time,
		Classtime:           classtime,
		Way:                 way,
		MachineDisinfectant: machinedisinfectant,
		DisinfectanWay:      disinfectantway,
		Disinfectant:        disinfectant,
	}
	err = service.UpdatePlanInfo(id, orgid, plan)

	fmt.Println("err", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"plan": plan,
	})
}

func (this *MachineApiController) GetComprehensive() {
	zone, _ := this.GetInt64("zone")

	number, _ := this.GetInt64("number")

	devicetype, _ := this.GetInt64("devicetype")

	year, _ := this.GetInt64("year")

	startTime := this.GetString("starttime")

	device_mode, _ := this.GetInt64("device_mode")

	fmt.Println("hh232323233232232233223232323", device_mode)
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", startTime+" 00:00:00", loc)
	starts := theTime.Unix()

	endtime := this.GetString("endtime")
	location, _ := time.ParseInLocation(timeLayout+" 15:04:05", endtime+" 00:00:00", loc)
	end := location.Unix()

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	macher, err := service.GetComprehensive(zone, number, devicetype, year, starts, end, orgid, device_mode)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"macher": macher,
	})
}

func (this *MachineApiController) GetPatientInfo() {
	adminUser := this.GetAdminUserInfo()
	orgid := adminUser.CurrentOrgId
	id, _ := this.GetInt64("id")
	addmacher, _ := service.GetBedId(id)

	timeStr := time.Now().Format("2006-01-02")
	timeLayout := "2006-01-02 15:04:05"
	timeStringToTime, _ := utils.ParseTimeStringToTime(timeLayout, timeStr+" 00:00:00")
	timenow := timeStringToTime.Unix()

	//获取当天床位号排班的所有病人
	schedules, err := service.GetPatientInfo(addmacher.BedId, timenow, orgid)

	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"schedules": schedules,
	})
}

func (this *MachineApiController) GetPatient() {
	adminUser := this.GetAdminUserInfo()
	orgid := adminUser.CurrentOrgId
	//fmt.Println("机构id", orgid)
	equitid, _ := this.GetInt64("equitid")
	//fmt.Println("设备id", equitid)
	addmacher, _ := service.GetBedId(equitid)
	id, _ := this.GetInt64("id")
	//fmt.Println("班次id", id)
	timeStr := time.Now().Format("2006-01-02")
	timeLayout := "2006-01-02 15:04:05"
	//fmt.Println("timeStr:", timeStr)
	timeStringToTime, _ := utils.ParseTimeStringToTime(timeLayout, timeStr+" 00:00:00")
	timenow := timeStringToTime.Unix()
	//fmt.Println("timenow是什么", timenow)
	schedules, err := service.GetPatient(addmacher.BedId, orgid, id, timenow)

	//fmt.Println("schedules", schedules.PartitionId)
	//获取区号姓名
	zone, _ := service.GetPartitionName(schedules.PartitionId)
	//获取机位号
	number, _ := service.GetPatientNumber(schedules.BedId)
	//获取上机时间和下机时间
	order, _ := service.GetDialysisOrder(timenow, schedules.PatientId, orgid)

	//获取透析方式
	prescription, _ := service.GetDialysisWay(timenow, schedules.PatientId, orgid)

	//获取透析时长
	dislysis, _ := service.GetDialysisTime(timenow, schedules.PatientId, orgid)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patients":     schedules,
		"zone":         zone,
		"number":       number,
		"order":        order,
		"prescription": prescription,
		"dislysis":     dislysis,
	})
}

func (this *MachineApiController) GetAllOrganization() {
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	appid := adminUserInfo.CurrentAppId
	approle, err := service.GetAllOrganization(orgid, appid)
	operators, err := service.GetAdminUserEsOne(adminUserInfo.CurrentOrgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"approle":   approle,
		"operators": operators,
	})
}

func (this *MachineApiController) SaveInformation() {
	eid, _ := this.GetInt64("eid")

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId

	id := int64(dataBody["id"].(float64))
	fmt.Println("id", id)

	date := dataBody["date"].(string)
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", date+" 00:00:00", loc)
	startdate := theTime.Unix()
	classtype := int64(dataBody["classtype"].(float64))
	zone := int64(dataBody["zone"].(float64))
	bednumber := int64(dataBody["bed_number"].(float64))
	number, err := service.GetNumbers(bednumber, orgid)
	patient_time := int64(dataBody["patient_id"].(float64))
	contagion := dataBody["contagion"].(string)
	dialysis_mode := int64(dataBody["dialysis_mode"].(float64))
	startDateStr := dataBody["start_time"].(string)
	var startDataUnix int64
	if len(startDateStr) > 0 {
		startDate, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", startDateStr)
		startDataUnix = startDate.Unix()
	}

	endDateStr := dataBody["end_time"].(string)
	var endDateUnix int64
	if len(endDateStr) > 0 {
		endDate, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", endDateStr)
		endDateUnix = endDate.Unix()
	}

	dialysis_time := dataBody["dialysis_time"].(string)
	hyperfiletration := dataBody["hyperfiltratio"].(float64)
	weight_loss := dataBody["weight_loss"].(float64)
	warining_value := dataBody["warning_value"].(string)
	usertotal := int64(dataBody["user_total"].(float64))
	user_total := strconv.FormatInt(usertotal, 10)
	run := int64(dataBody["run"].(float64))
	failure_stage := int64(dataBody["failure_stage"].(float64))
	falult_desciription := dataBody["fault_description"].(string)
	code_information := dataBody["code_information"].(string)
	//机器消毒
	disinfect_type := int64(dataBody["disinfect_type"].(float64))
	disinfectant_type := int64(dataBody["disinfectant_type"].(float64))
	disinfection := int64(dataBody["disinfection"].(float64))
	machine_run := int64(dataBody["machine_run"].(float64))
	//液路
	fluid_path := int64(dataBody["fluid_path"].(float64))
	disinfectant := int64(dataBody["disinfectant"].(float64))
	disinfection_status := int64(dataBody["disinfection_status"].(float64))
	disinfection_residue := int64(dataBody["disinfection_residue"].(float64))
	longtime := dataBody["longtime"].(string)
	start_DateStr := dataBody["starttime"].(string)
	var start_DateStr_Unix int64
	if len(start_DateStr) > 0 {
		start_Date, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", start_DateStr)
		start_DateStr_Unix = start_Date.Unix()
	}

	end_DateStr := dataBody["endtime"].(string)
	var end_DateStr_Unix int64
	if len(end_DateStr) > 0 {
		end_Date, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", end_DateStr)
		end_DateStr_Unix = end_Date.Unix()
	}

	dialysis_checked := int64(dataBody["dialysis_checked"].(float64))

	dialysis_name := int64(dataBody["dialysis_name"].(float64))

	norms := dataBody["norms"].(string)

	dialysis_concentration := int64(dataBody["dialysis_concentration"].(float64))

	germ_checked := int64(dataBody["germ_checked"].(float64))

	germ_name := int64(dataBody["germ_name"].(float64))

	germ_number := dataBody["germ_number"].(string)

	clean := int64(dataBody["clean"].(float64))

	sign_name := int64(dataBody["sign_name"].(float64))

	information, errinfor := service.GetInformation(eid, startdate, orgid, classtype)

	fmt.Print("information", information)

	//获取该机器最后一次的透析次数
	lastInformation, _ := service.GetLastInformationById(eid, orgid)

	parseIntUserTotal, err := strconv.ParseInt(user_total, 10, 64)
	if parseIntUserTotal == 0 {
		var total int
		// 字符串 转 int
		intNum, _ := strconv.Atoi(lastInformation.UserTotal)
		total = intNum + 1
		itoa := strconv.Itoa(total)
		if errinfor == gorm.ErrRecordNotFound {
			infor := models.DeviceInformation{
				Date:                  startdate,
				Class:                 classtype,
				BedNumber:             bednumber,
				PatientId:             patient_time,
				Contagion:             contagion,
				DialysisMode:          dialysis_mode,
				StartTime:             startDataUnix,
				EndTime:               endDateUnix,
				DialysisHour:          dialysis_time,
				Hyperfiltratio:        hyperfiletration,
				WeightLoss:            weight_loss,
				WarningValue:          warining_value,
				UserTotal:             itoa,
				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_DateStr_Unix,
				DisinfecEndtime:       end_DateStr_Unix,
				DialysisChecked:       dialysis_checked,
				DialysisName:          dialysis_name,
				Norms:                 norms,
				DialysisConcentration: dialysis_concentration,
				GermChecked:           germ_checked,
				GermName:              germ_name,
				GermNumber:            germ_number,
				Clean:                 clean,
				SignName:              sign_name,
				Ctime:                 time.Now().Unix(),
				Status:                1,
				UserOrgId:             orgid,
				EquimentId:            eid,
				Bed:                   number.Number,
				Stime:                 startdate,
			}
			if germ_checked == 1 {
				infor.UserTotal = ""
			}
			err = service.CreateUserInformation(&infor)
			fmt.Println("使用登记错误是什么", err)
			this.ServeSuccessJSON(map[string]interface{}{
				"information": infor,
			})
		} else if errinfor == nil {
			infor := models.DeviceInformation{
				Date:                  startdate,
				Class:                 classtype,
				Zone:                  zone,
				BedNumber:             bednumber,
				PatientId:             patient_time,
				Contagion:             contagion,
				DialysisMode:          dialysis_mode,
				StartTime:             startDataUnix,
				EndTime:               endDateUnix,
				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_DateStr_Unix,
				DisinfecEndtime:       end_DateStr_Unix,
				DialysisChecked:       dialysis_checked,
				DialysisName:          dialysis_name,
				Norms:                 norms,
				DialysisConcentration: dialysis_concentration,
				GermChecked:           germ_checked,
				GermName:              germ_name,
				GermNumber:            germ_number,
				Clean:                 clean,
				SignName:              sign_name,
				Ctime:                 time.Now().Unix(),
				Status:                1,
				UserOrgId:             orgid,
				EquimentId:            eid,
				Bed:                   number.Number,
			}
			informationdata, err := service.GetLastInformationdata(eid, startdate, orgid)
			if germ_checked == 1 {
				infor.UserTotal = ""
			}
			errors := service.UpadateForm(informationdata.ID, orgid, &infor)
			//fmt.Print("报错", errors)
			if errors != nil {
				this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
				return
			}
			this.ServeSuccessJSON(map[string]interface{}{
				"infor": infor,
			})
		}
	}

	if parseIntUserTotal > 0 {
		if errinfor == gorm.ErrRecordNotFound {
			infor := models.DeviceInformation{
				Date:                  startdate,
				Class:                 classtype,
				BedNumber:             bednumber,
				PatientId:             patient_time,
				Contagion:             contagion,
				DialysisMode:          dialysis_mode,
				StartTime:             startDataUnix,
				EndTime:               endDateUnix,
				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_DateStr_Unix,
				DisinfecEndtime:       end_DateStr_Unix,
				DialysisChecked:       dialysis_checked,
				DialysisName:          dialysis_name,
				Norms:                 norms,
				DialysisConcentration: dialysis_concentration,
				GermChecked:           germ_checked,
				GermName:              germ_name,
				GermNumber:            germ_number,
				Clean:                 clean,
				SignName:              sign_name,
				Ctime:                 time.Now().Unix(),
				Status:                1,
				UserOrgId:             orgid,
				EquimentId:            eid,
				Bed:                   number.Number,
				Stime:                 startdate,
			}
			if germ_checked == 1 {
				infor.UserTotal = ""
			}
			err = service.CreateUserInformation(&infor)
			fmt.Println("使用登记错误是什么", err)
			this.ServeSuccessJSON(map[string]interface{}{
				"information": infor,
			})
		} else if errinfor == nil {
			infor := models.DeviceInformation{
				Date:                  startdate,
				Class:                 classtype,
				Zone:                  zone,
				BedNumber:             bednumber,
				PatientId:             patient_time,
				Contagion:             contagion,
				DialysisMode:          dialysis_mode,
				StartTime:             startDataUnix,
				EndTime:               endDateUnix,
				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_DateStr_Unix,
				DisinfecEndtime:       end_DateStr_Unix,
				DialysisChecked:       dialysis_checked,
				DialysisName:          dialysis_name,
				Norms:                 norms,
				DialysisConcentration: dialysis_concentration,
				GermChecked:           germ_checked,
				GermName:              germ_name,
				GermNumber:            germ_number,
				Clean:                 clean,
				SignName:              sign_name,
				Ctime:                 time.Now().Unix(),
				Status:                1,
				UserOrgId:             orgid,
				EquimentId:            eid,
				Bed:                   number.Number,
			}
			informationdata, err := service.GetLastInformationdata(eid, startdate, orgid)
			if germ_checked == 1 {
				infor.UserTotal = ""
			}
			errors := service.UpadateForm(informationdata.ID, orgid, &infor)
			//fmt.Print("报错", errors)
			if errors != nil {
				this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
				return
			}
			this.ServeSuccessJSON(map[string]interface{}{
				"infor": infor,
			})
		}
	}
}

func (this *MachineApiController) ChangePatient() {
	adminUser := this.GetAdminUserInfo()
	orgid := adminUser.CurrentOrgId
	fmt.Println("机构id", orgid)
	equitid, _ := this.GetInt64("equitid")
	fmt.Println("equitid", equitid)
	id, _ := this.GetInt64("id")
	fmt.Println("id", id)
}

func (this *MachineApiController) GetRegisterInfo() {
	timeStr := time.Now().Format("2006-01-02")
	timeLayout := "2006-01-02 15:04:05"
	//fmt.Println("timeStr:", timeStr)
	timeStringToTime, _ := utils.ParseTimeStringToTime(timeLayout, timeStr+" 00:00:00")
	timenow := timeStringToTime.Unix()
	//fmt.Println("timenow是什么", timenow)
	adminUser := this.GetAdminUserInfo()
	orgid := adminUser.CurrentOrgId
	appid := adminUser.CurrentAppId
	id, _ := this.GetInt64("id")
	//fmt.Println("设备id", id)
	information, err := service.GetRegisterInfo(orgid, id, timenow)
	fmt.Print("错误", err)
	role, err := service.GetSignName(information.SignName, orgid, appid)
	dislysis, _ := service.GetDialysisTime(timenow, information.PatientId, orgid)

	//if err != nil {
	//	//	this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
	//	//	return
	//	//}
	this.ServeSuccessJSON(map[string]interface{}{
		"information": information,
		"role":        role,
		"dislysis":    dislysis,
	})
}

func (this *MachineApiController) GetInformationData() {
	limit, _ := this.GetInt64("limit")
	//fmt.Println("limit2", limit)
	page, _ := this.GetInt64("page")
	//fmt.Println("page", page)
	adminUser := this.GetAdminUserInfo()
	orgId := adminUser.CurrentOrgId
	information, total, err := service.GetInformationData(limit, page, orgId)

	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"information": information,
		"total":       total,
	})
}
func (this *MachineApiController) GetOrgName() {
	adminUser := this.GetAdminUserInfo()
	orgid := adminUser.CurrentOrgId
	org, err := service.GetOrgName(orgid)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"org": org,
	})
}

func (this *MachineApiController) SaveBacteria() {
	id, _ := this.GetInt64("id")

	addmacher, _ := service.GetBedId(id)

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)

	date := dataBody["date"].(string)

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", date+" 00:00:00", loc)
	state_date := theTime.Unix()

	specimen := int64(dataBody["specimen"].(float64))

	cona := dataBody["concentrate_noa"].(string)

	conb := dataBody["concentrate_nob"].(string)

	samplingLoactiona := int64(dataBody["sampling_locationa"].(float64))

	detectionUnit := dataBody["detection_unit"].(string)

	sampler := int64(dataBody["sampler"].(float64))

	reportDate := dataBody["reporting_date"].(string)
	reportTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDate+" 00:00:00", loc)
	repDate := reportTime.Unix()

	detectionResult := dataBody["detection_result"].(string)
	sort := dataBody["sort"].(string)

	examination := dataBody["pass_examination"].(string)
	pass_examination, err := strconv.ParseInt(examination, 10, 64)
	modifications := int64(dataBody["modifications"].(float64))
	culture := models.DeviceCulture{
		BedId:             addmacher.BedId,
		SpelingDate:       state_date,
		Specimen:          specimen,
		ConcentrateNoa:    cona,
		ConcentrateNob:    conb,
		SamplingLocationa: samplingLoactiona,
		DetectionUnit:     detectionUnit,
		Sampler:           sampler,
		ReportingDate:     repDate,
		DetectionResult:   detectionResult,
		Ctime:             time.Now().Unix(),
		Status:            1,
		UserOrgId:         orgid,
		EquitmentId:       id,
		Bed:               addmacher.BedNumber,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}

	err = service.CreateCulture(&culture)
	//fmt.Println("创建细菌检测", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "添加失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"culture": culture,
	})
}

func (this *MachineApiController) SaveLinconmycin() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	id, _ := this.GetInt64("id")

	addmacher, _ := service.GetBedId(id)

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)

	date := dataBody["sampling_date"].(string)
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", date+" 00:00:00", loc)
	samp_date := theTime.Unix()
	specimen := int64(dataBody["specimenb"].(float64))

	cona := dataBody["concentrate_noc"].(string)

	conb := dataBody["concentrateb_nod"].(string)

	samplinglocationb := int64(dataBody["sampling_locationb"].(float64))

	detectionUnit := dataBody["detection_unit"].(string)

	samplerb := int64(dataBody["samplerb"].(float64))

	reportDate := dataBody["reporting_dateb"].(string)
	reportTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDate+" 00:00:00", loc)
	repDate := reportTime.Unix()

	detectionResult := dataBody["detection_resultb"].(string)

	sort := dataBody["sort"].(string)

	modifications := int64(dataBody["modifications"].(float64))
	examination := dataBody["pass_examination"].(string)
	pass_examination, _ := strconv.ParseInt(examination, 10, 64)
	dialysate := models.DeviceDialysate{
		SamplingDate:      samp_date,
		Specimenb:         specimen,
		ConcentrateNoc:    cona,
		ConcentratebNod:   conb,
		SamplingLocationb: samplinglocationb,
		DetectionUnit:     detectionUnit,
		Samplerb:          samplerb,
		ReportingDateb:    repDate,
		DetectionResultb:  detectionResult,
		Ctime:             time.Now().Unix(),
		Status:            1,
		UserOrgId:         orgid,
		BedId:             addmacher.BedId,
		EquitmentId:       id,
		Bed:               addmacher.BedNumber,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}
	err = service.CreateDialysate(&dialysate)
	//fmt.Println("报错", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "添加失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"dialysate": dialysate,
	})
}

func (this *MachineApiController) SaveQualityControl() {
	id, _ := this.GetInt64("id")

	addmacher, _ := service.GetBedId(id)

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")

	// 透析液离子浓度检测
	dateb := dataBody["dateb"].(string)
	inLocation, _ := time.ParseInLocation(timeLayout+" 15:04:05", dateb+" 00:00:00", loc)
	dateB := inLocation.Unix()

	samplerc := int64(dataBody["samplerc"].(float64))

	concentratenof := dataBody["concentrate_nof"].(string)

	concentrateonog := dataBody["concentrate_nog"].(string)

	dateReportc := dataBody["date_reportc"].(string)
	parseInLocation, _ := time.ParseInLocation(timeLayout+" 15:04:05", dateReportc+" 00:00:00", loc)
	datec := parseInLocation.Unix()

	actualNa := dataBody["actual_na"].(string)

	actualPna := dataBody["actual_pna"].(string)

	actualK := dataBody["actual_k"].(string)

	actualCa := dataBody["actual_ca"].(string)

	actualCi := dataBody["actual_ci"].(string)

	actualHco := dataBody["actual_hco"].(string)

	actualMg := dataBody["actual_mg"].(string)

	actulaPH := dataBody["actual_ph"].(string)

	remakes := dataBody["remakes"].(string)

	detectionUnit := dataBody["detection_unit"].(string)

	sort := dataBody["sort"].(string)

	modifications := int64(dataBody["modifications"].(float64))
	examination := dataBody["pass_examination"].(string)
	pass_examination, _ := strconv.ParseInt(examination, 10, 64)

	ion := models.DeviceIon{
		SamplingDate:    dateB,
		Samplerc:        samplerc,
		DetectionUnit:   detectionUnit,
		ConcentrateNof:  concentratenof,
		ConcentrateNog:  concentrateonog,
		DateReportc:     datec,
		ActualNa:        actualNa,
		ActualPna:       actualPna,
		ActualK:         actualK,
		ActualCa:        actualCa,
		ActualCi:        actualCi,
		ActualHco:       actualHco,
		ActualMg:        actualMg,
		ActualPh:        actulaPH,
		Remakes:         remakes,
		EquitmentId:     id,
		Status:          1,
		UserOrgId:       orgid,
		Ctime:           time.Now().Unix(),
		BedId:           addmacher.BedId,
		Bed:             addmacher.BedNumber,
		Sort:            sort,
		PassExamination: pass_examination,
		Modifications:   modifications,
	}

	createIon := service.CreateIon(&ion)
	fmt.Println("报错", createIon)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "添加失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ion": ion,
	})
}

func (this *MachineApiController) GetAllQulityInfo() {
	adminUser := this.GetAdminUserInfo()
	orgID := adminUser.CurrentOrgId
	cultures, err := service.GetAllCulture(orgID)
	dialysate, _ := service.GetAllDialysate(orgID)
	ions, _ := service.GetAllDeviceIon(orgID)

	oxygenates, _ := service.GetAllDeviceOxygenates(orgID)
	water, err := service.GetAllHadWater(orgID)
	deviceWater, err := service.GetDeviceWater(orgID)
	devicePh, err := service.GetDevicePH(orgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "添加失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"cultures":    cultures,
		"dialysate":   dialysate,
		"ions":        ions,
		"oxygenates":  oxygenates,
		"hadwater":    water,
		"deviceWater": deviceWater,
		"devicePh":    devicePh,
	})
}

func (this *MachineApiController) EditCulture() {
	id, _ := this.GetInt64("id")
	//fmt.Println("id", id)
	userid, _ := this.GetInt64("userid")
	//fmt.Println("userid", userid)
	role, _ := service.GetSampler(userid)
	culture, err := service.GetCultureById(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"culture": culture,
		"role":    role,
	})
}

func (this *MachineApiController) UpdateCulture() {
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)

	id := int64(dataBody["id"].(float64))

	date := dataBody["date"].(string)

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", date+" 00:00:00", loc)
	state_date := theTime.Unix()

	specimen := int64(dataBody["specimen"].(float64))

	cona := dataBody["concentrate_noa"].(string)

	conb := dataBody["concentrate_nob"].(string)

	samplingLoactiona := int64(dataBody["sampling_locationa"].(float64))

	detectionUnit := dataBody["detection_unit"].(string)

	sampler := int64(dataBody["sampler"].(float64))

	reportDate := dataBody["reporting_date"].(string)
	reportTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDate+" 00:00:00", loc)
	repDate := reportTime.Unix()

	detectionResult := dataBody["detection_result"].(string)

	sort := dataBody["sort"].(string)
	pass_examination := int64(dataBody["pass_examination"].(float64))
	modifications := int64(dataBody["modifications"].(float64))
	adminUser := this.GetAdminUserInfo()
	orgId := adminUser.CurrentOrgId
	culture := models.DeviceCulture{
		SpelingDate:       state_date,
		Specimen:          specimen,
		ConcentrateNoa:    cona,
		ConcentrateNob:    conb,
		SamplingLocationa: samplingLoactiona,
		DetectionUnit:     detectionUnit,
		Sampler:           sampler,
		ReportingDate:     repDate,
		DetectionResult:   detectionResult,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}
	err = service.UpdateCulture(id, orgId, &culture)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"culture": culture,
	})
}

func (this *MachineApiController) DeleteCultrue() {
	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	idsInters := dataBody["ids"].([]interface{})
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	fmt.Println("ids", ids)
	err = service.DeleteCultrue(OrgID, ids)
	fmt.Println("err", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return

}

func (this *MachineApiController) EditDialystate() {
	id, _ := this.GetInt64("id")
	fmt.Println("id是什么", id)
	dialysate, err := service.GetDialystate(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"dialysate": dialysate,
	})

}

func (this *MachineApiController) Updatedialystate() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	id := int64(dataBody["id"].(float64))
	fmt.Println("id", id)
	samplingDate := dataBody["sampling_date"].(string)
	sampdate, _ := time.ParseInLocation(timeLayout+" 15:04:05", samplingDate+" 00:00:00", loc)
	samp_date := sampdate.Unix()
	fmt.Println("取样日期", samp_date)
	specimentb := int64(dataBody["specimenb"].(float64))
	fmt.Println("取样标本", specimentb)
	concentratec := dataBody["concentrate_noc"].(string)
	fmt.Println("A浓缩液批号", concentratec)
	concentraeb := dataBody["concentrateb_nod"].(string)
	fmt.Println("B浓缩", concentraeb)
	samplinglocationb := int64(dataBody["sampling_locationb"].(float64))
	fmt.Println("采样部位", samplinglocationb)
	samplerb := int64(dataBody["samplerb"].(float64))
	fmt.Println("取样者", samplerb)
	reportDateb := dataBody["reporting_dateb"].(string)
	//fmt.Println("日期", reportDateb)
	location, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDateb+" 00:00:00", loc)
	report_date := location.Unix()
	fmt.Println("出报告2日期", report_date)
	detectionResultb := dataBody["detection_resultb"].(string)
	fmt.Println("检测结果", detectionResultb)
	detectionUnit := dataBody["detection_unit"].(string)
	fmt.Println("检测单位", detectionUnit)

	sort := dataBody["sort"].(string)
	pass_examination := int64(dataBody["pass_examination"].(float64))
	modifications := int64(dataBody["modifications"].(float64))
	adminUser := this.GetAdminUserInfo()
	orgid := adminUser.CurrentOrgId
	dialysate := models.DeviceDialysate{
		SamplingDate:      samp_date,
		Specimenb:         specimentb,
		ConcentrateNoc:    concentratec,
		ConcentratebNod:   concentraeb,
		SamplingLocationb: samplinglocationb,
		DetectionUnit:     detectionUnit,
		Samplerb:          samplerb,
		ReportingDateb:    report_date,
		DetectionResultb:  detectionResultb,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}
	err = service.Updatedialystate(id, orgid, &dialysate)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"dialysate": dialysate,
	})
}

func (this *MachineApiController) DeleteDialystate() {
	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	idsInters := dataBody["ids"].([]interface{})
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	fmt.Println("ids", ids)
	err = service.DeleteDialystate(OrgID, ids)
	fmt.Println("err", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) Edition() {
	id, _ := this.GetInt64("id")
	fmt.Println("id", id)
	ion, err := service.GetIon(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ion": ion,
	})
}

func (this *MachineApiController) UpdateIon() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	id := int64(dataBody["id"].(float64))
	fmt.Println("id", id)
	dateb := dataBody["dateb"].(string)
	inLocation, _ := time.ParseInLocation(timeLayout+" 15:04:05", dateb+" 00:00:00", loc)
	dateB := inLocation.Unix()

	samplerc := int64(dataBody["samplerc"].(float64))

	concentratenof := dataBody["concentrate_nof"].(string)

	concentrateonog := dataBody["concentrate_nog"].(string)

	dateReportc := dataBody["date_reportc"].(string)
	parseInLocation, _ := time.ParseInLocation(timeLayout+" 15:04:05", dateReportc+" 00:00:00", loc)
	datec := parseInLocation.Unix()

	actualNa := dataBody["actual_na"].(string)

	actualPna := dataBody["actual_pna"].(string)

	actualK := dataBody["actual_k"].(string)

	actualCa := dataBody["actual_ca"].(string)

	actualCi := dataBody["actual_ci"].(string)

	actualHco := dataBody["actual_hco"].(string)

	actualMg := dataBody["actual_mg"].(string)

	actulaPH := dataBody["actual_ph"].(string)

	remakes := dataBody["remakes"].(string)

	detectionUnit := dataBody["detection_unit"].(string)

	sort := dataBody["sort"].(string)
	pass_examination := int64(dataBody["pass_examination"].(float64))
	modifications := int64(dataBody["modifications"].(float64))
	ion := models.DeviceIon{
		SamplingDate:    dateB,
		Samplerc:        samplerc,
		DetectionUnit:   detectionUnit,
		ConcentrateNof:  concentratenof,
		ConcentrateNog:  concentrateonog,
		DateReportc:     datec,
		ActualNa:        actualNa,
		ActualPna:       actualPna,
		ActualK:         actualK,
		ActualCa:        actualCa,
		ActualCi:        actualCi,
		ActualHco:       actualHco,
		ActualMg:        actualMg,
		ActualPh:        actulaPH,
		Remakes:         remakes,
		Sort:            sort,
		PassExamination: pass_examination,
		Modifications:   modifications,
	}
	adminUser := this.GetAdminUserInfo()
	orgId := adminUser.CurrentOrgId
	err = service.UpdateIon(id, orgId, &ion)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ion": ion,
	})
}

func (this *MachineApiController) DeleteIon() {
	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	idsInters := dataBody["ids"].([]interface{})
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	fmt.Println("ids", ids)
	err = service.DeleteIon(OrgID, ids)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) GetQuery() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	fmt.Println("orgid", OrgID)
	bedid, _ := this.GetInt64("bedid")
	fmt.Println("bedid", bedid)
	startime := this.GetString("startime")
	fmt.Println("starttime", startime)
	inLocation, _ := time.ParseInLocation(timeLayout+" 15:04:05", startime+" 00:00:00", loc)
	start := inLocation.Unix()
	fmt.Println("start", start)
	endtime := this.GetString("endtime")
	fmt.Println("endtime", endtime)
	endLocation, _ := time.ParseInLocation(timeLayout+" 15:04:05", endtime+" 00:00:00", loc)
	end := endLocation.Unix()
	fmt.Println("end", end)
	cultures, err := service.GetCultureData(bedid, start, end, OrgID)
	fmt.Print(err)
	dialysate, err := service.GetDialysateData(bedid, start, end, OrgID)

	ions, err := service.GetDeviceIonData(bedid, start, end, OrgID)

	oxygenates, err := service.GetOxygenates(bedid, start, end, OrgID)
	hadwater, err := service.GetHardWater(bedid, start, end, OrgID)
	water, err := service.GetWater(bedid, start, end, OrgID)
	deviceph, err := service.GetDevicePh(bedid, start, end, OrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"cultures":   cultures,
		"dialysate":  dialysate,
		"ions":       ions,
		"oxygenates": oxygenates,
		"hadwater":   hadwater,
		"water":      water,
		"deviceph":   deviceph,
	})
}

func (this *MachineApiController) SaveRepair() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")

	addmacher, _ := service.GetBedId(id)
	OrgID := adminUserInfo.CurrentOrgId

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	gua_date := dataBody["guarantee_date"].(string)

	inLocation, _ := time.ParseInLocation(timeLayout+" 15:04:05", gua_date+" 00:00:00", loc)
	guaDate := inLocation.Unix()

	startDateStr := dataBody["start_time"].(string)

	startDate, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", startDateStr)

	arriveDateStr := dataBody["arrive_time"].(string)

	arriveDate, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", arriveDateStr)

	finishDateStr := dataBody["finish_time"].(string)

	finishDate, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", finishDateStr)

	totaldistance := dataBody["total_distance"].(string)

	failurestate := int64(dataBody["failure_stage"].(float64))

	codeInformation := dataBody["code_information"].(string)

	faultdescription := dataBody["fault_description"].(string)

	causeAnalysis := dataBody["cause_analysis"].(string)

	treatmentprocess := dataBody["treatment_process"].(string)

	images := dataBody["images"].(string)

	exclude := int64(dataBody["exclude"].(float64))

	reason := dataBody["reason"].(string)

	imageName := dataBody["imageName"].(string)

	function_accessories_inspection := dataBody["function_accessories_inspection"].(string)

	other_information := dataBody["other_information"].(string)

	admin_user_id := int64(dataBody["admin_user_id"].(float64))
	repair := models.DeviceRepair{
		BedId:                         addmacher.BedId,
		EquitmentId:                   id,
		GuaranteeDate:                 guaDate,
		StartTime:                     startDate.Unix(),
		ArriveTime:                    arriveDate.Unix(),
		FinishTime:                    finishDate.Unix(),
		TotalDistance:                 totaldistance,
		FailureStage:                  failurestate,
		FaultDescription:              faultdescription,
		CauseAnalysis:                 causeAnalysis,
		TreatmentProcess:              treatmentprocess,
		Images:                        images,
		Exclude:                       exclude,
		Reason:                        reason,
		Status:                        1,
		UserOrgId:                     OrgID,
		Ctime:                         time.Now().Unix(),
		CodeInformation:               codeInformation,
		ImageName:                     imageName,
		FunctionAccessoriesInspection: function_accessories_inspection,
		OtherInformation:              other_information,
		AdminUserId:                   admin_user_id,
	}
	err = service.CreateRepair(&repair)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"repair": repair,
	})
}

func (this *MachineApiController) GetAllRepair() {
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	adminUser := this.GetAdminUserInfo()
	orgID := adminUser.CurrentOrgId
	appId := adminUser.CurrentAppId
	repair, total, err := service.GetAllRepair(orgID, limit, page)

	addmacher, _ := service.GetAllMachineByOrgId(orgID)

	docList, _ := service.GetAllDoctor(orgID, appId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"repair":     repair,
		"total":      total,
		"macherList": addmacher,
		"docList":    docList,
	})
}

func (this *MachineApiController) EditRepair() {
	id, _ := this.GetInt64("id")

	appId := this.GetAdminUserInfo().CurrentAppId
	orgId := this.GetAdminUserInfo().CurrentOrgId
	repair, err := service.EditRepair(id)
	docList, _ := service.GetAllDoctor(orgId, appId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"repair":  repair,
		"docList": docList,
	})
}

func (this *MachineApiController) UpdateRepair() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	fmt.Println("orgid", OrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	id := int64(dataBody["id"].(float64))
	gua_date := dataBody["guarantee_date"].(string)
	fmt.Println("保修日期", gua_date)
	inLocation, _ := time.ParseInLocation(timeLayout+" 15:04:05", gua_date+" 00:00:00", loc)
	guaDate := inLocation.Unix()
	fmt.Println("保修日期", guaDate)

	startDateStr := dataBody["start_time"].(string)
	fmt.Println("出发时间", startDateStr)
	startDate, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", startDateStr)
	fmt.Println("触发事件", startDate.Unix())

	arriveDateStr := dataBody["arrive_time"].(string)
	fmt.Println("到达时间", arriveDateStr)
	arriveDate, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", arriveDateStr)
	fmt.Println("到达时间", arriveDate.Unix())

	finishDateStr := dataBody["finish_time"].(string)
	fmt.Println("完成时间", finishDateStr)
	finishDate, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", finishDateStr)
	fmt.Println("完成时间", finishDate.Unix())

	totaldistance := dataBody["total_distance"].(string)
	fmt.Println("总公里输", totaldistance)

	failurestate := int64(dataBody["failure_stage"].(float64))
	fmt.Println("故事范式阶段", failurestate)

	codeInformation := dataBody["code_information"].(string)
	fmt.Println("故事提示信息及代码", codeInformation)

	faultdescription := dataBody["fault_description"].(string)
	fmt.Println("故障描述", faultdescription)

	causeAnalysis := dataBody["cause_analysis"].(string)
	fmt.Println("原因分析", causeAnalysis)

	treatmentprocess := dataBody["treatment_process"].(string)
	fmt.Println("处理过程", treatmentprocess)

	images := dataBody["images"].(string)
	fmt.Println("上传图片", images)

	exclude := int64(dataBody["exclude"].(float64))
	fmt.Println("故障是否排除", exclude)

	reason := dataBody["reason"].(string)
	fmt.Println("原因", reason)

	imageName := dataBody["image_name"].(string)

	function_accessories_inspection := dataBody["function_accessories_inspection"].(string)

	other_information := dataBody["other_information"].(string)

	admin_user_id := int64(dataBody["admin_user_id"].(float64))
	deviceRepair := models.DeviceRepair{
		GuaranteeDate:                 guaDate,
		StartTime:                     startDate.Unix(),
		ArriveTime:                    arriveDate.Unix(),
		FinishTime:                    finishDate.Unix(),
		TotalDistance:                 totaldistance,
		FailureStage:                  failurestate,
		FaultDescription:              faultdescription,
		CauseAnalysis:                 causeAnalysis,
		TreatmentProcess:              treatmentprocess,
		Images:                        images,
		Exclude:                       exclude,
		Reason:                        reason,
		CodeInformation:               codeInformation,
		ImageName:                     imageName,
		FunctionAccessoriesInspection: function_accessories_inspection,
		OtherInformation:              other_information,
		AdminUserId:                   admin_user_id,
	}
	err = service.UpdateRepair(id, OrgID, &deviceRepair)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"repair": deviceRepair,
	})
}

func (this *MachineApiController) DeleteRepair() {
	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	idsInters := dataBody["ids"].([]interface{})
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	fmt.Println("ids", ids)
	err = service.DeleteRepair(OrgID, ids)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) GetRepair() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	fmt.Println("orgid", OrgID)
	bedid, _ := this.GetInt64("bedid")
	fmt.Println("bedid", bedid)
	startime := this.GetString("startime")
	fmt.Println("starttime", startime)
	inLocation, _ := time.ParseInLocation(timeLayout+" 15:04:05", startime+" 00:00:00", loc)
	start := inLocation.Unix()
	fmt.Println("start", start)
	endtime := this.GetString("endtime")
	fmt.Println("endtime", endtime)
	endLocation, _ := time.ParseInLocation(timeLayout+" 15:04:05", endtime+" 00:00:00", loc)
	end := endLocation.Unix()
	fmt.Println("end", end)
	repair, err := service.GetRepair(bedid, start, end, OrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"repair": repair,
	})
}

func (this *MachineApiController) EditUser() {
	adminUser := this.GetAdminUserInfo()
	orgId := adminUser.CurrentOrgId
	id, _ := this.GetInt64("id")
	fmt.Println("id", id)
	patientid, _ := this.GetInt64("patientid")
	device, _ := service.GetUserInformation(id)
	//获取初次使用记录
	macher, _ := service.GetUserTotalByMacher(device.EquimentId)
	count, _ := service.GetUserTotalCount(orgId, device.BedNumber)
	patients, _ := service.GetPatientInfoMation(patientid)

	this.ServeSuccessJSON(map[string]interface{}{
		"device":   device,
		"patients": patients,
		"count":    count,
		"macher":   macher,
	})
}

func (this *MachineApiController) DeleteForm() {
	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	idsInters := dataBody["ids"].([]interface{})
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	fmt.Println("ids", ids)
	err = service.DeleteForm(OrgID, ids)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败:（"+err.Error()+"）")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) UpdateForm() {
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是", err)
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	date := dataBody["spling_date"].(string)
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", date+" 00:00:00", loc)
	startdate := theTime.Unix()
	fmt.Println("日期", startdate)

	id := int64(dataBody["id"].(float64))
	fmt.Println("id", id)
	classtype := int64(dataBody["classtype"].(float64))
	fmt.Println("班次", classtype)
	zone := int64(dataBody["zone"].(float64))
	fmt.Println("分区", zone)
	bednumber := int64(dataBody["bed_number"].(float64))
	fmt.Println("床位号", bednumber)
	number, _ := service.GetNumbers(bednumber, orgid)
	patient_id := int64(dataBody["patient_id"].(float64))
	fmt.Println("患者", patient_id)
	contagion := dataBody["contagion"].(string)
	fmt.Println("传染病", contagion)
	dialysis_mode := int64(dataBody["dialysis_mode"].(float64))
	fmt.Println("透析方式", dialysis_mode)

	startDateStr := dataBody["start_time"].(string)
	fmt.Println("上机时间", startDateStr)
	startDate, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", startDateStr)
	fmt.Println("上机时间", startDate.Unix())

	endDateStr := dataBody["end_time"].(string)
	fmt.Println("上机时间", startDateStr)
	endDate, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", endDateStr)
	fmt.Println("上机时间", endDate.Unix())

	dialysis_time := dataBody["dialysis_time"].(string)
	fmt.Println("透析时长", dialysis_time)

	hyperfiletration := dataBody["hyperfiltratio"].(float64)
	fmt.Println("实际超滤量", hyperfiletration)
	weight_loss := dataBody["weight_loss"].(float64)
	fmt.Println("体重减少", weight_loss)
	warining_value := dataBody["warning_value"].(string)
	fmt.Println("预警值", warining_value)
	//user_total := int64(dataBody["user_total"].(float64))
	user_total := dataBody["user_total"].(string)
	fmt.Println("使用次数", user_total)
	run := int64(dataBody["run"].(float64))
	fmt.Println("运行", run)
	failure_stage := int64(dataBody["failure_stage"].(float64))
	fmt.Println("故事发生阶段", failure_stage)
	falult_desciription := dataBody["fault_description"].(string)
	fmt.Println("故障描述", falult_desciription)
	code_information := dataBody["code_information"].(string)
	fmt.Println("故障提示及代码", code_information)
	//机器消毒
	disinfect_type := int64(dataBody["disinfect_type"].(float64))
	fmt.Println("消毒方式", disinfect_type)
	disinfectant_type := int64(dataBody["disinfectant_type"].(float64))
	fmt.Println("消毒液", disinfectant_type)
	disinfection := int64(dataBody["disinfection"].(float64))
	fmt.Println("消毒状态", disinfection)
	machine_run := int64(dataBody["machine_run"].(float64))
	fmt.Println("运行", machine_run)
	//液路
	fluid_path := int64(dataBody["fluid_path"].(float64))
	fmt.Println("液路消毒方式", fluid_path)
	disinfectant := int64(dataBody["disinfectant"].(float64))
	fmt.Println("消毒液", disinfectant)
	disinfection_status := int64(dataBody["disinfection_status"].(float64))
	fmt.Println("消毒状态", disinfection_status)
	disinfection_residue := int64(dataBody["disinfection_residue"].(float64))
	fmt.Println("消毒液残留", disinfection_residue)
	longtime := dataBody["longtime"].(string)
	fmt.Println("消毒时长", longtime)

	starttime := dataBody["starttime"].(string)
	disstarttime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", starttime)
	distartime := disstarttime.Unix()
	if distartime < 0 {
		distartime = 0
	}
	//fmt.Println("开始消毒时间====", distartime)

	entime := dataBody["endtime"].(string)
	disendtime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", entime)
	diendtime := disendtime.Unix()
	fmt.Println("结束消毒时间", diendtime)

	if diendtime < 0 {
		diendtime = 0
	}

	dialysis_checked := int64(dataBody["dialysis_checked"].(float64))
	//fmt.Println("更换", dialysis_checked)
	dialysis_name := int64(dataBody["dialysis_name"].(float64))
	fmt.Println("名称", dialysis_name)
	norms := dataBody["norms"].(string)
	fmt.Println("规格", norms)
	dialysis_concentration := int64(dataBody["dialysis_concentration"].(float64))
	fmt.Println("浓度", dialysis_concentration)
	germ_checked := int64(dataBody["germ_checked"].(float64))
	fmt.Println("更换", germ_checked)
	germ_name := int64(dataBody["germ_name"].(float64))
	fmt.Println("名称", germ_name)
	//germ_number := int64(dataBody["germ_number"].(float64))
	germ_number := dataBody["germ_number"].(string)
	fmt.Println("数量", germ_number)
	clean := int64(dataBody["clean"].(float64))
	fmt.Println("清洁", clean)
	sign_name := int64(dataBody["sign_name"].(float64))
	fmt.Println("签名", sign_name)
	equitment_id := int64(dataBody["equiment_id"].(float64))
	fmt.Println("设备ID", equitment_id)

	addmacher := models.DeviceAddmacher{
		BedId: bednumber,
	}
	//更新床位号
	err = service.UpdateAddMacherBedID(equitment_id, orgid, &addmacher)
	fmt.Println("更新设备失败", err)

	//更新区号
	//deviceNumber := models.DeviceNumber{
	//	ZoneID: zone,
	//}
	//err = service.UpdatedZoneID(bednumber, orgid, &deviceNumber)
	//fmt.Println("更新区号失败", err)
	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,
		DialysisConcentration: dialysis_concentration,
		GermChecked:           germ_checked,
		GermName:              germ_name,
		GermNumber:            germ_number,
		Clean:                 clean,
		SignName:              sign_name,
		Ctime:                 time.Now().Unix(),
		Status:                1,
		UserOrgId:             orgid,
		EquimentId:            id,
		Bed:                   number.Number,
		PatientId:             patient_id,
	}
	err = service.UpadateForm(id, orgid, &information)
	fmt.Println("报错", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "修改失败:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"information": information,
	})
}

func (this *MachineApiController) QueryInfo() {
	zone, _ := this.GetInt64("zone")
	fmt.Println("zone", zone)
	//bed, _ := this.GetInt64("bed")
	//fmt.Println("bed", bed)
	bed, _ := this.GetInt64("bed")
	startime := this.GetString("startime")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", startime+" 00:00:00", loc)
	startdate := theTime.Unix()
	fmt.Println("开始时间", startdate)
	endtime := this.GetString("endtime")
	theTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", endtime+" 00:00:00", loc)
	endtimes := theTimes.Unix()
	fmt.Println("结束", endtimes)
	limit, _ := this.GetInt64("limit")
	fmt.Println("limit", limit)
	page, _ := this.GetInt64("page")
	fmt.Println("page", page)
	adminUser := this.GetAdminUserInfo()
	orgId := adminUser.CurrentOrgId
	infor, total, err := service.QueryInfo(bed, startdate, endtimes, orgId, limit, page)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"infor": infor,
		"total": total,
	})
}

func (this *MachineApiController) InsertAutoData() {
	id, _ := this.GetInt64("id")
	addmacher, _ := service.GetBedId(id)
	fmt.Println("床位号", addmacher.BedId)
	adminUser := this.GetAdminUserInfo()
	timeStr := time.Now().Format("2006-01-02")
	timeLayout := "2006-01-02 15:04:05"
	fmt.Println("timeStr:", timeStr)
	timeStringToTime, _ := utils.ParseTimeStringToTime(timeLayout, timeStr+" 00:00:00")
	timenow := timeStringToTime.Unix()
	fmt.Println("timenow是什么", timenow)
	orgId := adminUser.CurrentOrgId
	dialysis, err := service.GetPatientID(id, orgId, timenow)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"dialysis": dialysis,
	})
}

func (this *MachineApiController) GetAllEquitType() {
	adminUserInfo := this.GetAdminUserInfo()
	orgID := adminUserInfo.CurrentOrgId
	fmt.Println("orgId", orgID)
	//equitname, err := service.GetAllEquitType(orgID)
	//name, err := service.GetAllEquitName(orgID)
	mode, err := service.GetAllMode(orgID)
	fmt.Print(err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"mode": mode,
	})
}

func (this *MachineApiController) GetUserForm() {
	id, _ := this.GetInt64("id")
	fmt.Println("id是什么", id)
	limit, _ := this.GetInt64("limit")
	fmt.Println("limit", limit)
	page, _ := this.GetInt64("page")
	fmt.Println("page", page)
	adminUserInfo := this.GetAdminUserInfo()
	orgID := adminUserInfo.CurrentOrgId
	fmt.Println("orgId", orgID)
	information, total, err := service.GetUserForm(id, orgID, limit, page)
	fmt.Print("information", information)
	fmt.Println("错误", err)
	addmacher, _ := service.GetBedNumber(id, orgID)
	fmt.Println("addmacher", addmacher)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"information": information,
		"total":       total,
		"addmacher":   addmacher,
	})
}

func (this *MachineApiController) GetBedForm() {
	adminUser := this.GetAdminUserInfo()
	orgId := adminUser.CurrentOrgId
	id, _ := this.GetInt64("id")
	fmt.Println("id", id)
	addmacher, err := service.GetZoneForm(id)
	bed, err := service.GetZoneId(addmacher.BedId, orgId)
	number, err := service.GetBedForm(bed.ZoneID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"addmacher": addmacher,
		"number":    number,
	})
}

func (this *MachineApiController) GetTotalCount() {
	info := this.GetAdminUserInfo()
	orgid := info.CurrentOrgId
	_, total, err := service.GetTotalCount(orgid)
	fmt.Print("------------------------------声优", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"total": total,
	})
}

func (this *MachineApiController) GetTotalNumber() {
	id, _ := this.GetInt64("id")
	fmt.Println("id", id)
	info := this.GetAdminUserInfo()
	orgId := info.CurrentOrgId
	total, _ := service.GetTotalNumber(id, orgId)
	//fmt.Println("total",total)
	//fmt.Println("====================真的",err)
	//if err != nil {
	//	this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询:（"+err.Error()+"）")
	//	return
	//}
	this.ServeSuccessJSON(map[string]interface{}{
		"total": total,
	})
}

func (this *MachineApiController) GetTimeWarning() {

	id, _ := this.GetInt64("id")
	fmt.Println("设备id", id)
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	//获取透析机消毒液更换的最后一次更换日期
	information, err := service.GetTimeWarning(id, orgId)
	//获取透析机消毒液细菌过滤器的最后一次更换日期
	deviceInformation, err := service.GetTimeLast(id, orgId)

	//获取空气滤网清洁最后一次更换日期
	clean, err := service.GetTimeLastData(id, orgId)

	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询:（"+err.Error()+"）")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"informations":      information,
		"deviceInformation": deviceInformation,
		"clean":             clean,
	})
}

func (this *MachineApiController) SaveManageinfoTwo() {
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	serial_numbe := dataBody["serial_number"].(string)
	device_type := int64(dataBody["device_type"].(float64))
	bed_number := this.GetString("beds")
	device_name := dataBody["device_name"].(string)
	manufacture_factory := dataBody["manufacture_factory"].(string)
	service_manufacturer := dataBody["service_manufacturer"].(string)
	unit_type := int64(dataBody["unit_type"].(float64))
	use_section := dataBody["use_section"].(string)
	section_number := dataBody["section_number"].(string)
	buy_date := dataBody["buy_date"].(string)

	timeLayout := "2006-01-02 15:04:05"
	theTime, err := utils.ParseTimeStringToTime(timeLayout, buy_date+" 00:00:00")
	buydate := theTime.Unix()
	int_num := *(*int)(unsafe.Pointer(&buydate))
	if int_num < 0 {
		buydate = 0
	}

	install_date := dataBody["install_date"].(string)
	toTime, err := utils.ParseTimeStringToTime(timeLayout, install_date+" 00:00:00")
	installdate := toTime.Unix()
	buy_num := *(*int)(unsafe.Pointer(&installdate))
	if buy_num < 0 {
		installdate = 0
	}

	start_date := dataBody["start_date"].(string)
	stringToTime, err := utils.ParseTimeStringToTime(timeLayout, start_date+" 00:00:00")
	startdate := stringToTime.Unix()
	start_num := *(*int)(unsafe.Pointer(&startdate))
	if start_num < 0 {
		startdate = 0
	}
	maintenance_engineer := dataBody["maintenance_engineer"].(string)
	telephone := dataBody["telephone"].(string)
	guarantee_date := dataBody["guarantee_date"].(string)
	machine_status := int64(dataBody["machine_status"].(float64))
	disinfection_mode := int64(dataBody["Disinfection_mode"].(float64))
	remarks := dataBody["remarks"].(string)
	rubbish_date := dataBody["rubbish_date"].(string)
	timeStringToTime, err := utils.ParseTimeStringToTime(timeLayout, rubbish_date+" 00:00:00")
	rubbishdate := timeStringToTime.Unix()
	rubb_num := *(*int)(unsafe.Pointer(&rubbishdate))
	if rubb_num < 0 {
		rubbishdate = 0
	}
	rubbish_reason := int64(dataBody["rubbish_reason"].(float64))
	user_year := dataBody["user_year"].(string)
	work_time := dataBody["work_time"].(string)
	revers := int64(dataBody["revers_mode"].(float64))
	zone_id := int64(dataBody["zone_id"].(float64))
	addmacher := &models.DeviceAddmacher{
		SerialNumber:        serial_numbe,
		DeviceType:          device_type,
		BedNumber:           bed_number,
		DeviceName:          device_name,
		ManufactureFactory:  manufacture_factory,
		ServiceManufacturer: service_manufacturer,
		UnitType:            unit_type,
		UseSection:          use_section,
		SectionNumber:       section_number,
		BuyDate:             buydate,
		InstallDate:         installdate,
		StartDate:           startdate,
		MaintenaceEngineer:  maintenance_engineer,
		Telephone:           telephone,
		GuaranteeDate:       guarantee_date,
		MachineStatus:       machine_status,
		DisinfectionMode:    disinfection_mode,
		Remarks:             remarks,
		RubbishDate:         rubbishdate,
		RubbishReason:       rubbish_reason,
		UserYear:            user_year,
		WorkTime:            work_time,
		ReversMode:          revers,
		Status:              1,
		Ctime:               time.Now().Unix(),
		UserOrgId:           orgid,
		ZoneId:              zone_id,
	}
	err = service.CreateMacher(addmacher)
	fmt.Println("什么原因啊", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"addmacher": addmacher,
	})
}

func (this *MachineApiController) GetAllpatient() {
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	allpatient, err := service.GetAllpatient(orgid)
	fmt.Print(err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"allpatient": allpatient,
	})
}

func (this *MachineApiController) ChangeBed() {
	id, _ := this.GetInt64("id")
	fmt.Print("id", id)
	info := this.GetAdminUserInfo()
	orgId := info.CurrentOrgId
	bed, err := service.ChangeBed(id, orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"bed": bed,
	})
}

func (this *MachineApiController) GetPatientDetail() {
	id, _ := this.GetInt64("id")
	fmt.Print("id", id)
	info := this.GetAdminUserInfo()
	orgid := info.CurrentOrgId
	patient, err := service.GetPatientDetail(id, orgid)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patient": patient,
	})
}

func (this *MachineApiController) SaveReminder() {
	id, _ := this.GetInt64("id")
	fmt.Print("码字", id)
	info := this.GetAdminUserInfo()
	orgId := info.CurrentOrgId
	remander := models.DeviceRemander{
		IsRun:     id,
		Status:    1,
		UserOrgId: orgId,
		Ctime:     time.Now().Unix(),
	}
	data, errs := service.GetRemanderData(orgId)
	if errs == gorm.ErrRecordNotFound {
		err := service.CreateRemander(&remander).Error()
		fmt.Print(err)
	} else if errs == nil {
		deviceRemander := models.DeviceRemander{
			ID:        data.ID,
			IsRun:     id,
			Status:    1,
			UserOrgId: orgId,
			Mtime:     time.Now().Unix(),
		}
		err := service.UpdateRemander(&deviceRemander)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
			return
		}
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"id": id,
	})
	return
}

func (this *MachineApiController) GetRemanderData() {
	info := this.GetAdminUserInfo()
	orgid := info.CurrentOrgId
	data, err := service.GetRemanderData(orgid)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"remander": data,
	})
}

func (this *MachineApiController) OpenDelete() {
	id, _ := this.GetInt64("id")
	err := service.DeletePlan(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) DeleteUserLogin() {
	id, _ := this.GetInt64("id")
	err := service.DeleteUserLogin(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) DeleteCultrues() {
	id, _ := this.GetInt64("id")
	err := service.DeleteCultrues(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) DeleteDialystates() {
	id, _ := this.GetInt64("id")
	err := service.DeleteDialystates(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) Deleteions() {
	id, _ := this.GetInt64("id")
	err := service.DeleteIons(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) DeleteRepairs() {
	id, _ := this.GetInt64("id")
	err := service.DeleteRepairs(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) SaveMode() {
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", orgid)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	device_mode := dataBody["device_mode"].(string)
	mode := models.DeviceMode{
		DeviceMode: device_mode,
		UserOrgId:  orgid,
		Status:     1,
		Ctime:      time.Now().Unix(),
	}
	_, errcode := service.GetMode(device_mode, orgid)
	if errcode == gorm.ErrRecordNotFound {
		err = service.SaveMode(&mode)
	} else if errcode == nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	} else {
	}
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"mode": mode,
	})
}

func (this *MachineApiController) GetAllMode() {
	fmt.Println("进来了没哟")
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	mode, err := service.GetAllMode(orgid)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"mode": mode,
	})
}

func (this *MachineApiController) EditMode() {
	id, _ := this.GetInt64("id")
	mode, err := service.GetModeById(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"mode": mode,
	})
}

func (this *MachineApiController) UpdateMode() {
	id, _ := this.GetInt64("id")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	device_mode := dataBody["device_mode"].(string)
	mode := models.DeviceMode{DeviceMode: device_mode}
	err = service.UpdateMode(id, mode)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"mode": mode,
	})
}

func (this *MachineApiController) DeleteMode() {
	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	_, errcode := service.QueryDeviceMode(id, orgid)
	if errcode == gorm.ErrRecordNotFound {
		service.DeleteMode(id)
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
		return
	} else if errcode == nil {
		return
	} else {
		fmt.Print("设备型号已存在")
	}

}

func (this *MachineApiController) SelectChange() {
	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	change, err := service.SelectChange(id, orgid)
	//fmt.Print("---------------------------", err)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"change": change,
	})

}

func (this *MachineApiController) SelectBed() {
	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	bed, err := service.SelectBed(id, orgid)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"zone": bed,
	})
}

func (this *MachineApiController) GetTimeData() {
	equitid, _ := this.GetInt64("equitid")
	fmt.Print("equitid", equitid)
	timeLayout := "2006-01-02 15:04:05"
	todaytime := this.GetString("todaytime")
	theTime, _ := utils.ParseTimeStringToTime(timeLayout, todaytime+" 00:00:00")
	fmt.Print("时间", theTime.Unix())
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	timeData, err := service.GetTimeData(equitid, orgid, theTime.Unix())
	fmt.Print("报错", err)
	timeDataTwo, err := service.GetTimeTwo(equitid, orgid, theTime.Unix())
	timeDataThree, err := service.GetTimeThree(equitid, orgid, theTime.Unix())
	fmt.Print("err报错了没有", err)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"timeData":      timeData,
		"timeDataTwo":   timeDataTwo,
		"timeDataThree": timeDataThree,
	})
}

func (this *MachineApiController) DeleteImages() {
	id, _ := this.GetInt64("id")
	err := service.DeleteImages(id)
	fmt.Print("err", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) GetUserMachTotalCount() {
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	count, err := service.GetUserMachTotalCount(orgid)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"count": count,
	})
}

func (this *MachineApiController) GetUserTotalCount() {
	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	id, _ := this.GetInt64("id")
	count, err := service.GetUserTotalCount(orgid, id)
	addmacher, err := service.GetUserTotal(orgid, id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"count":     count,
		"addmacher": addmacher,
	})
}

func (this *MachineApiController) DeleteManagement() {
	id, _ := this.GetInt64("id")
	_, err := service.DeleteEquit(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) SaveOxygenates() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	id, _ := this.GetInt64("id")

	addmacher, _ := service.GetBedId(id)

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)

	date := dataBody["sampling_date"].(string)
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", date+" 00:00:00", loc)
	samp_date := theTime.Unix()
	specimen := int64(dataBody["specimenb"].(float64))

	cona := dataBody["concentrate_noc"].(string)

	conb := dataBody["concentrateb_nod"].(string)

	samplinglocationb := int64(dataBody["sampling_locationb"].(float64))

	detectionUnit := dataBody["detection_unit"].(string)

	samplerb := int64(dataBody["samplerb"].(float64))

	reportDate := dataBody["reporting_dateb"].(string)
	reportTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDate+" 00:00:00", loc)
	repDate := reportTime.Unix()

	detectionResult := dataBody["detection_resultb"].(string)

	sort := dataBody["sort"].(string)

	modifications := int64(dataBody["modifications"].(float64))
	examination := dataBody["pass_examination"].(string)
	pass_examination, _ := strconv.ParseInt(examination, 10, 64)
	oxygenates := models.XtDeviceOxygenates{
		SamplingDate:      samp_date,
		Specimenb:         specimen,
		ConcentrateNoc:    cona,
		ConcentratebNod:   conb,
		SamplingLocationb: samplinglocationb,
		DetectionUnit:     detectionUnit,
		Samplerb:          samplerb,
		ReportingDateb:    repDate,
		DetectionResultb:  detectionResult,
		Ctime:             time.Now().Unix(),
		Status:            1,
		UserOrgId:         orgid,
		BedId:             addmacher.BedId,
		EquitmentId:       id,
		Bed:               addmacher.BedNumber,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}
	err = service.CreateOxygenates(&oxygenates)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"oxygenates": oxygenates,
	})
}

func (this *MachineApiController) SaveHardWater() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	id, _ := this.GetInt64("id")

	addmacher, _ := service.GetBedId(id)

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)

	date := dataBody["sampling_date"].(string)
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", date+" 00:00:00", loc)
	samp_date := theTime.Unix()
	specimen := int64(dataBody["specimenb"].(float64))

	cona := dataBody["concentrate_noc"].(string)

	conb := dataBody["concentrateb_nod"].(string)

	samplinglocationb := int64(dataBody["sampling_locationb"].(float64))

	detectionUnit := dataBody["detection_unit"].(string)

	samplerb := int64(dataBody["samplerb"].(float64))

	reportDate := dataBody["reporting_dateb"].(string)
	reportTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDate+" 00:00:00", loc)
	repDate := reportTime.Unix()

	detectionResult := dataBody["detection_resultb"].(string)

	sort := dataBody["sort"].(string)

	modifications := int64(dataBody["modifications"].(float64))
	examination := dataBody["pass_examination"].(string)
	pass_examination, _ := strconv.ParseInt(examination, 10, 64)
	hadwater := models.XtDeviceHadwater{
		SamplingDate:      samp_date,
		Specimenb:         specimen,
		ConcentrateNoc:    cona,
		ConcentratebNod:   conb,
		SamplingLocationb: samplinglocationb,
		DetectionUnit:     detectionUnit,
		Samplerb:          samplerb,
		ReportingDateb:    repDate,
		DetectionResultb:  detectionResult,
		Ctime:             time.Now().Unix(),
		Status:            1,
		UserOrgId:         orgid,
		BedId:             addmacher.BedId,
		EquitmentId:       id,
		Bed:               addmacher.BedNumber,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}

	err = service.CreateHadWater(&hadwater)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hadwater": hadwater,
	})
}

func (this *MachineApiController) SaveWater() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	id, _ := this.GetInt64("id")

	addmacher, _ := service.GetBedId(id)

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)

	date := dataBody["sampling_date"].(string)
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", date+" 00:00:00", loc)
	samp_date := theTime.Unix()
	specimen := int64(dataBody["specimenb"].(float64))

	cona := dataBody["concentrate_noc"].(string)

	conb := dataBody["concentrateb_nod"].(string)

	samplinglocationb := int64(dataBody["sampling_locationb"].(float64))

	detectionUnit := dataBody["detection_unit"].(string)

	samplerb := int64(dataBody["samplerb"].(float64))

	reportDate := dataBody["reporting_dateb"].(string)
	reportTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDate+" 00:00:00", loc)
	repDate := reportTime.Unix()

	detectionResult := dataBody["detection_resultb"].(string)

	sort := dataBody["sort"].(string)

	modifications := int64(dataBody["modifications"].(float64))
	examination := dataBody["pass_examination"].(string)
	pass_examination, _ := strconv.ParseInt(examination, 10, 64)
	deviceWater := models.XtDeviceWater{
		SamplingDate:      samp_date,
		Specimenb:         specimen,
		ConcentrateNoc:    cona,
		ConcentratebNod:   conb,
		SamplingLocationb: samplinglocationb,
		DetectionUnit:     detectionUnit,
		Samplerb:          samplerb,
		ReportingDateb:    repDate,
		DetectionResultb:  detectionResult,
		Ctime:             time.Now().Unix(),
		Status:            1,
		UserOrgId:         orgid,
		BedId:             addmacher.BedId,
		EquitmentId:       id,
		Bed:               addmacher.BedNumber,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}
	err = service.CreateWater(&deviceWater)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"deviceWater": deviceWater,
	})
}

func (this *MachineApiController) SaveDevicePH() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	id, _ := this.GetInt64("id")

	addmacher, _ := service.GetBedId(id)

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)

	date := dataBody["sampling_date"].(string)
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", date+" 00:00:00", loc)
	samp_date := theTime.Unix()
	specimen := int64(dataBody["specimenb"].(float64))

	cona := dataBody["concentrate_noc"].(string)

	conb := dataBody["concentrateb_nod"].(string)

	samplinglocationb := int64(dataBody["sampling_locationb"].(float64))

	detectionUnit := dataBody["detection_unit"].(string)

	samplerb := int64(dataBody["samplerb"].(float64))

	reportDate := dataBody["reporting_dateb"].(string)
	reportTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDate+" 00:00:00", loc)
	repDate := reportTime.Unix()

	detectionResult := dataBody["detection_resultb"].(string)

	sort := dataBody["sort"].(string)

	modifications := int64(dataBody["modifications"].(float64))
	examination := dataBody["pass_examination"].(string)
	pass_examination, _ := strconv.ParseInt(examination, 10, 64)
	devicePh := models.XtDevicePh{
		SamplingDate:      samp_date,
		Specimenb:         specimen,
		ConcentrateNoc:    cona,
		ConcentratebNod:   conb,
		SamplingLocationb: samplinglocationb,
		DetectionUnit:     detectionUnit,
		Samplerb:          samplerb,
		ReportingDateb:    repDate,
		DetectionResultb:  detectionResult,
		Ctime:             time.Now().Unix(),
		Status:            1,
		UserOrgId:         orgid,
		BedId:             addmacher.BedId,
		EquitmentId:       id,
		Bed:               addmacher.BedNumber,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}
	err = service.CreateDevicePh(&devicePh)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"devicePh": devicePh,
	})
}

func (this *MachineApiController) EditOxygenates() {

	id, _ := this.GetInt64("id")
	oxygenates, err := service.GetOxygenatesById(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"oxygenates": oxygenates,
	})
}

func (this *MachineApiController) UpdateOxygenates() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	id := int64(dataBody["id"].(float64))
	fmt.Println("id", id)
	samplingDate := dataBody["sampling_date"].(string)
	sampdate, _ := time.ParseInLocation(timeLayout+" 15:04:05", samplingDate+" 00:00:00", loc)
	samp_date := sampdate.Unix()

	specimentb := int64(dataBody["specimenb"].(float64))

	concentratec := dataBody["concentrate_noc"].(string)

	concentraeb := dataBody["concentrateb_nod"].(string)

	samplinglocationb := int64(dataBody["sampling_locationb"].(float64))

	samplerb := int64(dataBody["samplerb"].(float64))

	reportDateb := dataBody["reporting_dateb"].(string)

	location, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDateb+" 00:00:00", loc)
	report_date := location.Unix()

	detectionResultb := dataBody["detection_resultb"].(string)

	detectionUnit := dataBody["detection_unit"].(string)

	sort := dataBody["sort"].(string)
	pass_examination := int64(dataBody["pass_examination"].(float64))
	modifications := int64(dataBody["modifications"].(float64))
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	oxygenates := models.XtDeviceOxygenates{
		SamplingDate:      samp_date,
		Specimenb:         specimentb,
		ConcentrateNoc:    concentratec,
		ConcentratebNod:   concentraeb,
		SamplingLocationb: samplinglocationb,
		DetectionUnit:     detectionUnit,
		Samplerb:          samplerb,
		ReportingDateb:    report_date,
		DetectionResultb:  detectionResultb,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}

	err = service.UpdateOxygenates(id, orgId, &oxygenates)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"oxygenates": oxygenates,
	})
}

func (this *MachineApiController) EditHardWater() {

	id, _ := this.GetInt64("id")
	hardWater, err := service.GetHardWaterById(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hardWater": hardWater,
	})
}

func (this *MachineApiController) EditWater() {

	id, _ := this.GetInt64("id")
	water, err := service.GetWaterById(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"water": water,
	})
}

func (this *MachineApiController) EditDevicePh() {

	id, _ := this.GetInt64("id")
	deviceph, err := service.GetDevicePhById(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"deviceph": deviceph,
	})
}

func (this *MachineApiController) GetAllDoctorList() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	appId := this.GetAdminUserInfo().CurrentAppId
	list, err := service.GetAllDoctorTwo(orgId, appId)
	operators, err := service.GetAdminUserEsOne(orgId)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":      list,
		"operators": operators,
	})
}

func (this *MachineApiController) SaveAirDisinfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	check_out, err := this.GetInt64("check_out")
	class, err := this.GetInt64("class")
	create_time := this.GetString("created_time")
	createTime, err := time.ParseInLocation(timeLayout+" 15:04:05", create_time+" 00:00:00", loc)
	creator, err := this.GetInt64("creator")
	detection_result := this.GetString("detection_result")
	detection_time := this.GetString("detection_time")
	detectionTime, err := time.ParseInLocation(timeLayout+" 15:04:05", detection_time+" 00:00:00", loc)
	disinfection_fluid := this.GetString("disinfection_fluid")
	disinfection_methods := this.GetString("disinfection_methods")
	modifications, _ := this.GetInt64("modifications")
	sort := this.GetString("sort")
	upload_time := this.GetString("upload_time")
	uploadTime, err := time.ParseInLocation(timeLayout+" 15:04:05", upload_time+" 00:00:00", loc)
	start_time := this.GetString("start_time")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	detection := models.XtAerialDetection{
		CheckOut:            check_out,
		Class:               class,
		CreatedTime:         createTime.Unix(),
		Creator:             creator,
		DetectionResult:     detection_result,
		DetectionTime:       detectionTime.Unix(),
		DisinfectionFluid:   disinfection_fluid,
		DisinfectionMethods: disinfection_methods,
		Modifications:       modifications,
		Sort:                sort,
		UploadTime:          uploadTime.Unix(),
		StartTime:           startTime.Unix(),
		UserOrgId:           orgId,
		Ctime:               time.Now().Unix(),
		Status:              1,
	}

	err = service.CreateAerialDetection(&detection)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": detection,
	})
}

func (this *MachineApiController) GetAirList() {

	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	list, total, err := service.GetAirList(limit, page, orgId)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":  list,
		"total": total,
	})
}

func (this *MachineApiController) GetAirDisinfetDetail() {
	id, _ := this.GetInt64("id")
	detail, err := service.GetAirDisinfectDetail(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"detail": detail,
	})
}

func (this *MachineApiController) UpdateAirDisinfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	check_out, err := this.GetInt64("check_out")
	class, err := this.GetInt64("class")
	create_time := this.GetString("created_time")

	createTime, err := time.ParseInLocation(timeLayout+" 15:04:05", create_time+" 00:00:00", loc)
	creator, err := this.GetInt64("creator")
	detection_result := this.GetString("detection_result")
	detection_time := this.GetString("detection_time")
	detectionTime, err := time.ParseInLocation(timeLayout+" 15:04:05", detection_time+" 00:00:00", loc)
	disinfection_fluid := this.GetString("disinfection_fluid")
	disinfection_methods := this.GetString("disinfection_methods")
	modifications, _ := this.GetInt64("modifications")
	sort := this.GetString("sort")
	upload_time := this.GetString("upload_time")
	uploadTime, err := time.ParseInLocation(timeLayout+" 15:04:05", upload_time+" 00:00:00", loc)
	start_time := this.GetString("start_time")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	detection := models.XtAerialDetection{
		CheckOut:            check_out,
		Class:               class,
		CreatedTime:         createTime.Unix(),
		Creator:             creator,
		DetectionResult:     detection_result,
		DetectionTime:       detectionTime.Unix(),
		DisinfectionFluid:   disinfection_fluid,
		DisinfectionMethods: disinfection_methods,
		Modifications:       modifications,
		Sort:                sort,
		UploadTime:          uploadTime.Unix(),
		StartTime:           startTime.Unix(),
		UserOrgId:           orgId,
		Ctime:               time.Now().Unix(),
		Status:              1,
	}
	err = service.UpdateAeriaDetection(&detection, id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"detection": detection,
	})
}

func (this *MachineApiController) DeleteAirDisinfect() {

	id, _ := this.GetInt64("id")
	err := service.DeleteAirDisinfect(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) SaveBodyDisinfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	check_out, err := this.GetInt64("check_out")
	class, err := this.GetInt64("class")
	create_time := this.GetString("created_time")
	createTime, err := time.ParseInLocation(timeLayout+" 15:04:05", create_time+" 00:00:00", loc)
	creator, err := this.GetInt64("creator")
	detection_result := this.GetString("detection_result")
	detection_time := this.GetString("detection_time")
	detectionTime, err := time.ParseInLocation(timeLayout+" 15:04:05", detection_time+" 00:00:00", loc)
	disinfection_fluid := this.GetString("disinfection_fluid")
	disinfection_methods := this.GetString("disinfection_methods")
	modifications, _ := this.GetInt64("modifications")
	sort := this.GetString("sort")
	upload_time := this.GetString("upload_time")
	uploadTime, err := time.ParseInLocation(timeLayout+" 15:04:05", upload_time+" 00:00:00", loc)
	start_time := this.GetString("start_time")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	detection := models.XtBodyDetection{
		CheckOut:            check_out,
		Class:               class,
		CreatedTime:         createTime.Unix(),
		Creator:             creator,
		DetectionResult:     detection_result,
		DetectionTime:       detectionTime.Unix(),
		DisinfectionFluid:   disinfection_fluid,
		DisinfectionMethods: disinfection_methods,
		Modifications:       modifications,
		Sort:                sort,
		UploadTime:          uploadTime.Unix(),
		StartTime:           startTime.Unix(),
		UserOrgId:           orgId,
		Ctime:               time.Now().Unix(),
		Status:              1,
	}

	err = service.SaveBodyDetection(&detection)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"detection": detection,
	})
}

func (this *MachineApiController) GetBodyList() {

	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	list, total, err := service.GetBodyList(limit, page, orgId)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":  list,
		"total": total,
	})
}

func (this *MachineApiController) GetBodyDisinfetDetail() {

	id, _ := this.GetInt64("id")
	detail, err := service.GetBodyDisinfectDetail(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"detail": detail,
	})
}

func (this *MachineApiController) UpdateBodyDisinfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	check_out, _ := this.GetInt64("check_out")
	class, _ := this.GetInt64("class")
	create_time := this.GetString("created_time")

	createTime, err := time.ParseInLocation(timeLayout+" 15:04:05", create_time+" 00:00:00", loc)
	creator, err := this.GetInt64("creator")
	detection_result := this.GetString("detection_result")
	detection_time := this.GetString("detection_time")
	detectionTime, err := time.ParseInLocation(timeLayout+" 15:04:05", detection_time+" 00:00:00", loc)
	disinfection_fluid := this.GetString("disinfection_fluid")
	disinfection_methods := this.GetString("disinfection_methods")
	modifications, _ := this.GetInt64("modifications")
	sort := this.GetString("sort")
	upload_time := this.GetString("upload_time")
	uploadTime, err := time.ParseInLocation(timeLayout+" 15:04:05", upload_time+" 00:00:00", loc)
	start_time := this.GetString("start_time")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	detection := models.XtBodyDetection{
		CheckOut:            check_out,
		Class:               class,
		CreatedTime:         createTime.Unix(),
		Creator:             creator,
		DetectionResult:     detection_result,
		DetectionTime:       detectionTime.Unix(),
		DisinfectionFluid:   disinfection_fluid,
		DisinfectionMethods: disinfection_methods,
		Modifications:       modifications,
		Sort:                sort,
		UploadTime:          uploadTime.Unix(),
		StartTime:           startTime.Unix(),
		UserOrgId:           orgId,
		Ctime:               time.Now().Unix(),
		Status:              1,
	}

	err = service.UpdateBodyDetection(&detection, id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"detection": detection,
	})
}

func (this *MachineApiController) DeleteBodyDisInfect() {

	id, _ := this.GetInt64("id")
	err := service.DeleteBodyDisInfect(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) UpdateHadWater() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	id := int64(dataBody["id"].(float64))
	fmt.Println("id", id)
	samplingDate := dataBody["sampling_date"].(string)
	sampdate, _ := time.ParseInLocation(timeLayout+" 15:04:05", samplingDate+" 00:00:00", loc)
	samp_date := sampdate.Unix()

	specimentb := int64(dataBody["specimenb"].(float64))

	concentratec := dataBody["concentrate_noc"].(string)

	concentraeb := dataBody["concentrateb_nod"].(string)

	samplinglocationb := int64(dataBody["sampling_locationb"].(float64))

	samplerb := int64(dataBody["samplerb"].(float64))

	reportDateb := dataBody["reporting_dateb"].(string)

	location, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDateb+" 00:00:00", loc)
	report_date := location.Unix()

	detectionResultb := dataBody["detection_resultb"].(string)

	detectionUnit := dataBody["detection_unit"].(string)

	sort := dataBody["sort"].(string)
	pass_examination := int64(dataBody["pass_examination"].(float64))
	modifications := int64(dataBody["modifications"].(float64))
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	hadWater := models.XtDeviceHadwater{
		SamplingDate:      samp_date,
		Specimenb:         specimentb,
		ConcentrateNoc:    concentratec,
		ConcentratebNod:   concentraeb,
		SamplingLocationb: samplinglocationb,
		DetectionUnit:     detectionUnit,
		Samplerb:          samplerb,
		ReportingDateb:    report_date,
		DetectionResultb:  detectionResultb,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}
	err = service.UpdateHadWater(id, orgId, &hadWater)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hadWater": hadWater,
	})
}

func (this *MachineApiController) UpdateWater() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	id := int64(dataBody["id"].(float64))
	fmt.Println("id", id)
	samplingDate := dataBody["sampling_date"].(string)
	sampdate, _ := time.ParseInLocation(timeLayout+" 15:04:05", samplingDate+" 00:00:00", loc)
	samp_date := sampdate.Unix()

	specimentb := int64(dataBody["specimenb"].(float64))

	concentratec := dataBody["concentrate_noc"].(string)

	concentraeb := dataBody["concentrateb_nod"].(string)

	samplinglocationb := int64(dataBody["sampling_locationb"].(float64))

	samplerb := int64(dataBody["samplerb"].(float64))

	reportDateb := dataBody["reporting_dateb"].(string)

	location, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDateb+" 00:00:00", loc)
	report_date := location.Unix()

	detectionResultb := dataBody["detection_resultb"].(string)

	detectionUnit := dataBody["detection_unit"].(string)
	sort := dataBody["sort"].(string)
	pass_examination := int64(dataBody["pass_examination"].(float64))
	modifications := int64(dataBody["modifications"].(float64))
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	hadWater := models.XtDeviceWater{
		SamplingDate:      samp_date,
		Specimenb:         specimentb,
		ConcentrateNoc:    concentratec,
		ConcentratebNod:   concentraeb,
		SamplingLocationb: samplinglocationb,
		DetectionUnit:     detectionUnit,
		Samplerb:          samplerb,
		ReportingDateb:    report_date,
		DetectionResultb:  detectionResultb,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}
	err = service.UpdateDeviceWater(id, orgId, &hadWater)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hadWater": hadWater,
	})
}

func (this *MachineApiController) UpdateDevicePh() {
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	id := int64(dataBody["id"].(float64))
	fmt.Println("id", id)
	samplingDate := dataBody["sampling_date"].(string)
	sampdate, _ := time.ParseInLocation(timeLayout+" 15:04:05", samplingDate+" 00:00:00", loc)
	samp_date := sampdate.Unix()

	specimentb := int64(dataBody["specimenb"].(float64))

	concentratec := dataBody["concentrate_noc"].(string)

	concentraeb := dataBody["concentrateb_nod"].(string)

	samplinglocationb := int64(dataBody["sampling_locationb"].(float64))

	samplerb := int64(dataBody["samplerb"].(float64))

	reportDateb := dataBody["reporting_dateb"].(string)

	location, _ := time.ParseInLocation(timeLayout+" 15:04:05", reportDateb+" 00:00:00", loc)
	report_date := location.Unix()

	detectionResultb := dataBody["detection_resultb"].(string)

	detectionUnit := dataBody["detection_unit"].(string)

	sort := dataBody["sort"].(string)
	pass_examination := int64(dataBody["pass_examination"].(float64))
	modifications := int64(dataBody["modifications"].(float64))
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	hadWater := models.XtDevicePh{
		SamplingDate:      samp_date,
		Specimenb:         specimentb,
		ConcentrateNoc:    concentratec,
		ConcentratebNod:   concentraeb,
		SamplingLocationb: samplinglocationb,
		DetectionUnit:     detectionUnit,
		Samplerb:          samplerb,
		ReportingDateb:    report_date,
		DetectionResultb:  detectionResultb,
		Sort:              sort,
		PassExamination:   pass_examination,
		Modifications:     modifications,
	}
	err = service.UpdateDivicePh(id, orgId, &hadWater)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hadWater": hadWater,
	})
}

func (this *MachineApiController) DeleteOxygenates() {

	id, _ := this.GetInt64("id")
	err := service.DeleteOxygenates(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) DeleteHadWater() {

	id, _ := this.GetInt64("id")
	err := service.DeleteHadWater(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) DeleteWater() {
	id, _ := this.GetInt64("id")
	err := service.DeleteWater(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) DeleteDevicePh() {
	id, _ := this.GetInt64("id")
	err := service.DeleteDevicePh(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) SaveWaterList() {

	equitment_id, _ := this.GetInt64("equitment_id")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	record_date := dataBody["record_date"].(string)
	sampdate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := sampdate.Unix()
	fmt.Println("日期", recorddateunix)
	machine_status := int64(dataBody["machine_status"].(float64))
	fmt.Println("machine_status", machine_status)

	fault_description := dataBody["fault_description"].(string)
	water_conductivity := dataBody["water_conductivity"].(float64)
	water_pressure := dataBody["water_pressure"].(float64)
	temperature := dataBody["temperature"].(float64)
	force_pump_status := int64(dataBody["force_pump_status"].(float64))
	first_ro_membrane_water := dataBody["first_ro_membrane_water"].(float64)
	first_ro_film_thick_water := dataBody["first_ro_film_thick_water"].(float64)
	first_ro_membrane_effluent := dataBody["first_ro_membrane_effluent"].(float64)
	first_production_of_water_conductivity := dataBody["first_production_of_water_conductivity"].(float64)
	first_water_yield := dataBody["first_water_yield"].(float64)
	last_ro_membrane_water := dataBody["last_ro_membrane_water"].(float64)
	last_ro_membrane_effluent := dataBody["last_ro_membrane_effluent"].(float64)
	last_ro_film_thick_water := dataBody["last_ro_film_thick_water"].(float64)
	last_production_of_water_conductivity := dataBody["last_production_of_water_conductivity"].(float64)
	last_water_yield := dataBody["last_water_yield"].(float64)
	carbon_tank := dataBody["carbon_tank"].(float64)
	snd_tank := dataBody["snd_tank"].(float64)
	resin_tank := dataBody["resin_tank"].(float64)
	ultrafilter := dataBody["ultrafilter"].(float64)
	hardness_monitoring := dataBody["hardness_monitoring"].(float64)
	total_chlorine_detection := dataBody["total_chlorine_detection"].(float64)
	ph_detection := dataBody["ph_detection"].(float64)
	concentration_of_peroxyacetic_acid := dataBody["concentration_of_peroxyacetic_acid"].(float64)
	reverse_osmosis_membrane_disinfection := int64(dataBody["reverse_osmosis_membrane_disinfection"].(float64))
	first_disinfection_method := int64(dataBody["first_disinfection_method"].(float64))
	last_disinfection_method := int64(dataBody["last_disinfection_method"].(float64))
	first_disinfection_time := dataBody["first_disinfection_time"].(float64)
	last_disinfection_time := dataBody["last_disinfection_time"].(float64)
	remark := dataBody["remark"].(string)
	filter_replacement := int64(dataBody["filter_replacement"].(float64))
	admin_user_id := int64(dataBody["admin_user_id"].(float64))
	disinfection_of_water_pipeline := int64(dataBody["disinfection_of_water_pipeline"].(float64))

	orgId := this.GetAdminUserInfo().CurrentOrgId

	deviceWater := models.XtDialysisDeviceWater{
		UserOrgId:                          orgId,
		EquimentId:                         equitment_id,
		RecordDate:                         recorddateunix,
		MachineStatus:                      machine_status,
		FaultDescription:                   fault_description,
		WaterConductivity:                  water_conductivity,
		WaterPressure:                      water_pressure,
		Temperature:                        temperature,
		ForcePumpStatus:                    force_pump_status,
		FirstRoMembraneWater:               first_ro_membrane_water,
		FirstRoFilmThickWater:              first_ro_film_thick_water,
		FirstRoMembraneEffluent:            first_ro_membrane_effluent,
		FirstProductionOfWaterConductivity: first_production_of_water_conductivity,
		FirstWaterYield:                    first_water_yield,
		LastRoMembraneWater:                last_ro_membrane_water,
		LastRoFilmThickWater:               last_ro_film_thick_water,
		LastRoMembraneEffluent:             last_ro_membrane_effluent,
		LastProductionOfWaterConductivity:  last_production_of_water_conductivity,
		LastWaterYield:                     last_water_yield,
		CarbonTank:                         carbon_tank,
		SndTank:                            snd_tank,
		ResinTank:                          resin_tank,
		Ultrafilter:                        ultrafilter,
		HardnessMonitoring:                 hardness_monitoring,
		TotalChlorineDetection:             total_chlorine_detection,
		ConcentrationOfPeroxyaceticAcid:    concentration_of_peroxyacetic_acid,
		ReverseOsmosisMembraneDisinfection: reverse_osmosis_membrane_disinfection,
		FirstDisinfectionMethod:            first_disinfection_method,
		LastDisinfectionMethod:             last_disinfection_method,
		FirstDisinfectionTime:              first_disinfection_time,
		LastDisinfectionTime:               last_disinfection_time,
		Remark:                             remark,
		FilterReplacement:                  filter_replacement,
		AdminUserId:                        admin_user_id,
		Ctime:                              time.Now().Unix(),
		Mtime:                              time.Now().Unix(),
		Status:                             1,
		PhDetection:                        ph_detection,
		DisinfectionOfWaterPipeline:        disinfection_of_water_pipeline,
	}

	err = service.CretaDeviceWater(deviceWater)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"deviceWater": deviceWater,
	})
}

func (this *MachineApiController) GetWaterFormList() {

	equitment_id, _ := this.GetInt64("equitment_id")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")

	start_time := this.GetString("start_time")
	var theStartTIme int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
		}
		theStartTIme = theTime.Unix()
	}

	end_time := this.GetString("end_time")
	var theEndTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 00:00:00", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
		}
		theEndTime = theTime.Unix()
	}

	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	orgId := this.GetAdminUserInfo().CurrentOrgId

	list, total, err := service.GetWaterFormList(equitment_id, theStartTIme, theEndTime, limit, page, orgId)

	appId := this.GetAdminUserInfo().CurrentAppId
	adminRole, err := service.GetAllDoctorTwo(orgId, appId)
	operators, err := service.GetAdminUserEsOne(orgId)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":      list,
		"total":     total,
		"adminRole": adminRole,
		"operators": operators,
	})
}

func (this *MachineApiController) DeleteDialysisWater() {

	id, _ := this.GetInt64("id")

	err := service.DelelteDialysisWater(id)
	fmt.Println(err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) GetDialysisWaterDetail() {

	id, _ := this.GetInt64("id")

	detail, err := service.GetDialysisWaterDetail(id)
	appId := this.GetAdminUserInfo().CurrentAppId
	orgId := this.GetAdminUserInfo().CurrentOrgId
	adminRole, err := service.GetAllDoctorTwo(orgId, appId)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"detail":    detail,
		"adminRole": adminRole,
	})

}

func (this *MachineApiController) UpdateDialysisWater() {

	equitment_id, _ := this.GetInt64("equitment_id")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	id := int64(dataBody["id"].(float64))
	record_date := dataBody["record_date"].(string)
	sampdate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := sampdate.Unix()
	fmt.Println("日期", recorddateunix)
	machine_status := int64(dataBody["machine_status"].(float64))
	fmt.Println("machine_status", machine_status)

	fault_description := dataBody["fault_description"].(string)
	water_conductivity := dataBody["water_conductivity"].(float64)
	water_pressure := dataBody["water_pressure"].(float64)
	temperature := dataBody["temperature"].(float64)
	force_pump_status := int64(dataBody["force_pump_status"].(float64))
	first_ro_membrane_water := dataBody["first_ro_membrane_water"].(float64)
	first_ro_film_thick_water := dataBody["first_ro_film_thick_water"].(float64)
	first_ro_membrane_effluent := dataBody["first_ro_membrane_effluent"].(float64)
	first_production_of_water_conductivity := dataBody["first_production_of_water_conductivity"].(float64)
	first_water_yield := dataBody["first_water_yield"].(float64)
	last_ro_membrane_water := dataBody["last_ro_membrane_water"].(float64)
	last_ro_membrane_effluent := dataBody["last_ro_membrane_effluent"].(float64)
	last_ro_film_thick_water := dataBody["last_ro_film_thick_water"].(float64)
	last_production_of_water_conductivity := dataBody["last_production_of_water_conductivity"].(float64)
	last_water_yield := dataBody["last_water_yield"].(float64)
	carbon_tank := dataBody["carbon_tank"].(float64)
	snd_tank := dataBody["snd_tank"].(float64)
	resin_tank := dataBody["resin_tank"].(float64)
	ultrafilter := dataBody["ultrafilter"].(float64)
	hardness_monitoring := dataBody["hardness_monitoring"].(float64)
	total_chlorine_detection := dataBody["total_chlorine_detection"].(float64)
	ph_detection := dataBody["ph_detection"].(float64)
	concentration_of_peroxyacetic_acid := dataBody["concentration_of_peroxyacetic_acid"].(float64)
	reverse_osmosis_membrane_disinfection := int64(dataBody["reverse_osmosis_membrane_disinfection"].(float64))
	first_disinfection_method := int64(dataBody["first_disinfection_method"].(float64))
	last_disinfection_method := int64(dataBody["last_disinfection_method"].(float64))
	first_disinfection_time := dataBody["first_disinfection_time"].(float64)
	last_disinfection_time := dataBody["last_disinfection_time"].(float64)
	remark := dataBody["remark"].(string)
	filter_replacement := int64(dataBody["filter_replacement"].(float64))
	admin_user_id := int64(dataBody["admin_user_id"].(float64))
	disinfection_of_water_pipeline := int64(dataBody["disinfection_of_water_pipeline"].(float64))

	orgId := this.GetAdminUserInfo().CurrentOrgId

	deviceWater := models.XtDialysisDeviceWater{
		ID:                                 id,
		UserOrgId:                          orgId,
		EquimentId:                         equitment_id,
		RecordDate:                         recorddateunix,
		MachineStatus:                      machine_status,
		FaultDescription:                   fault_description,
		WaterConductivity:                  water_conductivity,
		WaterPressure:                      water_pressure,
		Temperature:                        temperature,
		ForcePumpStatus:                    force_pump_status,
		FirstRoMembraneWater:               first_ro_membrane_water,
		FirstRoFilmThickWater:              first_ro_film_thick_water,
		FirstRoMembraneEffluent:            first_ro_membrane_effluent,
		FirstProductionOfWaterConductivity: first_production_of_water_conductivity,
		FirstWaterYield:                    first_water_yield,
		LastRoMembraneWater:                last_ro_membrane_water,
		LastRoFilmThickWater:               last_ro_film_thick_water,
		LastRoMembraneEffluent:             last_ro_membrane_effluent,
		LastProductionOfWaterConductivity:  last_production_of_water_conductivity,
		LastWaterYield:                     last_water_yield,
		CarbonTank:                         carbon_tank,
		SndTank:                            snd_tank,
		ResinTank:                          resin_tank,
		Ultrafilter:                        ultrafilter,
		HardnessMonitoring:                 hardness_monitoring,
		TotalChlorineDetection:             total_chlorine_detection,
		ConcentrationOfPeroxyaceticAcid:    concentration_of_peroxyacetic_acid,
		ReverseOsmosisMembraneDisinfection: reverse_osmosis_membrane_disinfection,
		FirstDisinfectionMethod:            first_disinfection_method,
		LastDisinfectionMethod:             last_disinfection_method,
		FirstDisinfectionTime:              first_disinfection_time,
		LastDisinfectionTime:               last_disinfection_time,
		Remark:                             remark,
		FilterReplacement:                  filter_replacement,
		AdminUserId:                        admin_user_id,
		Ctime:                              time.Now().Unix(),
		Mtime:                              time.Now().Unix(),
		Status:                             1,
		PhDetection:                        ph_detection,
		DisinfectionOfWaterPipeline:        disinfection_of_water_pipeline,
	}

	err = service.SaveDeviceWater(deviceWater)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"deviceWater": deviceWater,
	})
}

func (this *MachineApiController) DeleteBatchDialysisWater() {

	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	idsInters := dataBody["ids"].([]interface{})
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除失败")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	fmt.Println("ids", ids)
	err = service.DeleteBatchDialysisWater(OrgID, ids)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) SaveNewAirDisInfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	record_date := dataBody["record_date"].(string)
	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()

	first_disinfection_water := dataBody["first_disinfection_water"].(string)
	first_disinfection_methods := dataBody["first_disinfection_methods"].(string)
	first_disinfection_time := dataBody["first_disinfection_time"].(string)

	first_start_time := dataBody["first_start_time"].(string)

	if len(first_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	firstStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_start_time)

	first_end_time := dataBody["first_end_time"].(string)

	if len(first_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	firstEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_end_time)

	first_total_time := dataBody["first_total_time"].(string)

	first_is_check := int64(dataBody["first_is_check"].(float64))

	first_modifications := int64(dataBody["first_modifications"].(float64))

	first_creator := int64(dataBody["first_creator"].(float64))

	sencond_disinfection_water := dataBody["sencond_disinfection_water"].(string)
	sencond_disinfection_methods := dataBody["sencond_disinfection_methods"].(string)
	sencond_disinfection_time := dataBody["sencond_disinfection_time"].(string)

	sencond_start_time := dataBody["sencond_start_time"].(string)

	if len(sencond_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	sencondStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", sencond_start_time)

	sencond_end_time := dataBody["sencond_end_time"].(string)

	if len(sencond_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	sencondEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", sencond_end_time)

	sencond_total_time := dataBody["sencond_total_time"].(string)

	sencond_is_check := int64(dataBody["sencond_is_check"].(float64))

	sencond_modifications := int64(dataBody["sencond_modifications"].(float64))

	sencond_creator := int64(dataBody["sencond_creator"].(float64))

	third_disinfection_water := dataBody["third_disinfection_water"].(string)
	third_disinfection_methods := dataBody["third_disinfection_methods"].(string)
	third_disinfection_time := dataBody["third_disinfection_time"].(string)

	third_start_time := dataBody["third_start_time"].(string)

	if len(third_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	thirdStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", third_start_time)

	third_end_time := dataBody["third_end_time"].(string)

	if len(third_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	thirdEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", third_end_time)

	third_total_time := dataBody["third_total_time"].(string)

	third_is_check := int64(dataBody["third_is_check"].(float64))

	third_modifications := int64(dataBody["third_modifications"].(float64))

	third_creator := int64(dataBody["third_creator"].(float64))

	last_start_time := dataBody["last_start_time"].(string)

	if len(last_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	lastStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_start_time)

	last_end_time := dataBody["last_end_time"].(string)

	if len(last_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	lastEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_end_time)

	last_total_time := dataBody["last_total_time"].(string)

	last_is_check := int64(dataBody["last_is_check"].(float64))

	last_modifications := int64(dataBody["last_modifications"].(float64))

	last_creator := int64(dataBody["last_creator"].(float64))

	storey := dataBody["storey"].(string)

	orgId := this.GetAdminUserInfo().CurrentOrgId
	disinfect := models.XtNewAriDisinfect{
		UserOrgId:                  orgId,
		RecordDate:                 recorddateunix,
		FirstDisinfectionWater:     first_disinfection_water,
		FirstDisinfectionMethods:   first_disinfection_methods,
		FirstDisinfectionTime:      first_disinfection_time,
		FirstStartTime:             firstStartTime.Unix(),
		FirstEndTime:               firstEndTime.Unix(),
		FirstTotalTime:             first_total_time,
		FirstIsCheck:               first_is_check,
		FirstModifications:         first_modifications,
		FirstCreator:               first_creator,
		SencondDisinfectionWater:   sencond_disinfection_water,
		SencondDisinfectionMethods: sencond_disinfection_methods,
		SencondDisinfectionTime:    sencond_disinfection_time,
		SencondStartTime:           sencondStartTime.Unix(),
		SencondEndTime:             sencondEndTime.Unix(),
		SencondTotalTime:           sencond_total_time,
		SencondIsCheck:             sencond_is_check,
		SencondModifications:       sencond_modifications,
		SencondCreator:             sencond_creator,
		ThirdDisinfectionWater:     third_disinfection_water,
		ThirdDisinfectionMethods:   third_disinfection_methods,
		ThirdDisinfectionTime:      third_disinfection_time,
		ThirdStartTime:             thirdStartTime.Unix(),
		ThirdEndTime:               thirdEndTime.Unix(),
		ThirdTotalTime:             third_total_time,
		ThirdIsCheck:               third_is_check,
		ThirdModifications:         third_modifications,
		ThirdCreator:               third_creator,
		LastStartTime:              lastStartTime.Unix(),
		LastEndTime:                lastEndTime.Unix(),
		LastTotalTime:              last_total_time,
		LastIsCheck:                last_is_check,
		LastModifications:          last_modifications,
		LastCreator:                last_creator,
		Ctime:                      time.Now().Unix(),
		Mtime:                      time.Now().Unix(),
		Status:                     1,
		Storey:                     storey,
	}

	err = service.CreateNewAirDisinfect(disinfect)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"disinfect": disinfect,
	})
}

func (this *MachineApiController) GetNewAirDisinfectList() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	storey := this.GetString("storey")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetNewAirDisinfectList(limit, page, startTime, endTime, orgId, storey)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":  list,
		"total": total,
	})
}

func (this *MachineApiController) GetNewAirDisinfectByIdList() {

	id, _ := this.GetInt64("id")

	list, err := service.GetNewAirDisinfectByIdList(id)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *MachineApiController) UpdateNewAirDisInfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)

	id := int64(dataBody["id"].(float64))
	record_date := dataBody["record_date"].(string)
	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()

	first_disinfection_water := dataBody["first_disinfection_water"].(string)
	first_disinfection_methods := dataBody["first_disinfection_methods"].(string)
	first_disinfection_time := dataBody["first_disinfection_time"].(string)

	first_start_time := dataBody["first_start_time"].(string)

	if len(first_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	firstStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_start_time)

	first_end_time := dataBody["first_end_time"].(string)

	if len(first_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	firstEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_end_time)

	first_total_time := dataBody["first_total_time"].(string)

	first_is_check := int64(dataBody["first_is_check"].(float64))

	first_modifications := int64(dataBody["first_modifications"].(float64))

	first_creator := int64(dataBody["first_creator"].(float64))

	sencond_disinfection_water := dataBody["sencond_disinfection_water"].(string)
	sencond_disinfection_methods := dataBody["sencond_disinfection_methods"].(string)
	sencond_disinfection_time := dataBody["sencond_disinfection_time"].(string)

	sencond_start_time := dataBody["sencond_start_time"].(string)

	if len(sencond_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	sencondStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", sencond_start_time)

	sencond_end_time := dataBody["sencond_end_time"].(string)

	if len(sencond_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	sencondEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", sencond_end_time)

	sencond_total_time := dataBody["sencond_total_time"].(string)

	sencond_is_check := int64(dataBody["sencond_is_check"].(float64))

	sencond_modifications := int64(dataBody["sencond_modifications"].(float64))

	sencond_creator := int64(dataBody["sencond_creator"].(float64))

	third_disinfection_water := dataBody["third_disinfection_water"].(string)
	third_disinfection_methods := dataBody["third_disinfection_methods"].(string)
	third_disinfection_time := dataBody["third_disinfection_time"].(string)

	third_start_time := dataBody["third_start_time"].(string)

	if len(third_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	thirdStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", third_start_time)

	third_end_time := dataBody["third_end_time"].(string)

	if len(third_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	thirdEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", third_end_time)

	third_total_time := dataBody["third_total_time"].(string)

	third_is_check := int64(dataBody["third_is_check"].(float64))

	third_modifications := int64(dataBody["third_modifications"].(float64))

	third_creator := int64(dataBody["third_creator"].(float64))

	last_start_time := dataBody["last_start_time"].(string)

	if len(last_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	lastStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_start_time)

	last_end_time := dataBody["last_end_time"].(string)

	if len(last_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	lastEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_end_time)

	last_total_time := dataBody["last_total_time"].(string)

	last_is_check := int64(dataBody["last_is_check"].(float64))

	last_modifications := int64(dataBody["last_modifications"].(float64))

	last_creator := int64(dataBody["last_creator"].(float64))

	storey := dataBody["storey"].(string)

	orgId := this.GetAdminUserInfo().CurrentOrgId
	disinfect := models.XtNewAriDisinfect{
		ID:                         id,
		UserOrgId:                  orgId,
		RecordDate:                 recorddateunix,
		FirstDisinfectionWater:     first_disinfection_water,
		FirstDisinfectionMethods:   first_disinfection_methods,
		FirstDisinfectionTime:      first_disinfection_time,
		FirstStartTime:             firstStartTime.Unix(),
		FirstEndTime:               firstEndTime.Unix(),
		FirstTotalTime:             first_total_time,
		FirstIsCheck:               first_is_check,
		FirstModifications:         first_modifications,
		FirstCreator:               first_creator,
		SencondDisinfectionWater:   sencond_disinfection_water,
		SencondDisinfectionMethods: sencond_disinfection_methods,
		SencondDisinfectionTime:    sencond_disinfection_time,
		SencondStartTime:           sencondStartTime.Unix(),
		SencondEndTime:             sencondEndTime.Unix(),
		SencondTotalTime:           sencond_total_time,
		SencondIsCheck:             sencond_is_check,
		SencondModifications:       sencond_modifications,
		SencondCreator:             sencond_creator,
		ThirdDisinfectionWater:     third_disinfection_water,
		ThirdDisinfectionMethods:   third_disinfection_methods,
		ThirdDisinfectionTime:      third_disinfection_time,
		ThirdStartTime:             thirdStartTime.Unix(),
		ThirdEndTime:               thirdEndTime.Unix(),
		ThirdTotalTime:             third_total_time,
		ThirdIsCheck:               third_is_check,
		ThirdModifications:         third_modifications,
		ThirdCreator:               third_creator,
		LastStartTime:              lastStartTime.Unix(),
		LastEndTime:                lastEndTime.Unix(),
		LastTotalTime:              last_total_time,
		LastIsCheck:                last_is_check,
		LastModifications:          last_modifications,
		LastCreator:                last_creator,
		Ctime:                      time.Now().Unix(),
		Mtime:                      time.Now().Unix(),
		Status:                     1,
		Storey:                     storey,
	}

	err = service.SaveNewAriDisinfect(disinfect)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"disinfect": disinfect,
	})

}

func (this *MachineApiController) DeleteNewAirDisinfect() {

	id, _ := this.GetInt64("id")

	err := service.DeleteNewAirDisInfect(id)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) SaveObjTableDisInfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	record_date := dataBody["record_date"].(string)
	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()

	first_disinfection_water := dataBody["first_disinfection_water"].(string)
	first_disinfection_methods := dataBody["first_disinfection_methods"].(string)
	first_disinfection_time := dataBody["first_disinfection_time"].(string)

	first_start_time := dataBody["first_start_time"].(string)

	var firstStartTimeUnix int64
	if len(first_start_time) > 0 {
		firstStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_start_time)
		firstStartTimeUnix = firstStartTime.Unix()
	}

	var firstEndTimeUnix int64
	first_end_time := dataBody["first_end_time"].(string)

	if len(first_end_time) > 0 {
		firstEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_end_time)
		firstEndTimeUnix = firstEndTime.Unix()
	}

	first_total_time := dataBody["first_total_time"].(string)

	first_is_check := int64(dataBody["first_is_check"].(float64))

	first_modifications := int64(dataBody["first_modifications"].(float64))

	first_creator := int64(dataBody["first_creator"].(float64))

	sencond_disinfection_water := dataBody["sencond_disinfection_water"].(string)
	sencond_disinfection_methods := dataBody["sencond_disinfection_methods"].(string)
	sencond_disinfection_time := dataBody["sencond_disinfection_time"].(string)

	sencond_start_time := dataBody["sencond_start_time"].(string)
	var sencondStartTimeUnixt int64
	if len(sencond_start_time) > 0 {
		sencondStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", sencond_start_time)
		sencondStartTimeUnixt = sencondStartTime.Unix()
	}

	sencond_end_time := dataBody["sencond_end_time"].(string)
	var sencondEndTimeUnixt int64
	if len(sencond_end_time) > 0 {
		sencondEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", sencond_end_time)
		sencondEndTimeUnixt = sencondEndTime.Unix()
	}

	sencond_total_time := dataBody["sencond_total_time"].(string)

	sencond_is_check := int64(dataBody["sencond_is_check"].(float64))

	sencond_modifications := int64(dataBody["sencond_modifications"].(float64))

	sencond_creator := int64(dataBody["sencond_creator"].(float64))

	third_disinfection_water := dataBody["third_disinfection_water"].(string)
	third_disinfection_methods := dataBody["third_disinfection_methods"].(string)
	third_disinfection_time := dataBody["third_disinfection_time"].(string)

	third_start_time := dataBody["third_start_time"].(string)
	var thirdStartTimeUnix int64
	if len(third_start_time) > 0 {
		thirdStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", third_start_time)
		thirdStartTimeUnix = thirdStartTime.Unix()
	}

	third_end_time := dataBody["third_end_time"].(string)
	var thirdEndTimeUnix int64
	if len(third_end_time) > 0 {
		thirdEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", third_end_time)
		thirdEndTimeUnix = thirdEndTime.Unix()
	}

	third_total_time := dataBody["third_total_time"].(string)

	third_is_check := int64(dataBody["third_is_check"].(float64))

	third_modifications := int64(dataBody["third_modifications"].(float64))

	third_creator := int64(dataBody["third_creator"].(float64))

	fourth_disinfection_water := dataBody["fourth_disinfection_water"].(string)
	fourth_disinfection_methods := dataBody["fourth_disinfection_methods"].(string)
	fourth_disinfection_time := dataBody["fourth_disinfection_time"].(string)

	fourth_start_time := dataBody["fourth_start_time"].(string)
	var fourthiStartTimeUnitx int64
	if len(fourth_start_time) > 0 {
		fourthStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", fourth_start_time)
		fourthiStartTimeUnitx = fourthStartTime.Unix()
	}

	fourth_end_time := dataBody["fourth_end_time"].(string)
	var fourthEndTimeUnix int64
	if len(fourth_end_time) > 0 {
		fourthEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", fourth_end_time)
		fourthEndTimeUnix = fourthEndTime.Unix()
	}

	fourth_total_time := dataBody["fourth_total_time"].(string)

	fourth_is_check := int64(dataBody["fourth_is_check"].(float64))

	fourth_modifications := int64(dataBody["fourth_modifications"].(float64))

	fourth_creator := int64(dataBody["fourth_creator"].(float64))

	last_disinfection_water := dataBody["last_disinfection_water"].(string)
	last_disinfection_methods := dataBody["last_disinfection_methods"].(string)
	last_disinfection_time := dataBody["last_disinfection_time"].(string)
	last_start_time := dataBody["last_start_time"].(string)
	var lastStartTimeUnix int64
	if len(last_start_time) > 0 {
		lastStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_start_time)
		lastStartTimeUnix = lastStartTime.Unix()
	}

	last_end_time := dataBody["last_end_time"].(string)

	var lastEndTimeUnix int64
	if len(last_end_time) > 0 {
		lastEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_end_time)
		lastEndTimeUnix = lastEndTime.Unix()
	}

	last_total_time := dataBody["last_total_time"].(string)

	last_is_check := int64(dataBody["last_is_check"].(float64))

	last_modifications := int64(dataBody["last_modifications"].(float64))

	last_creator := int64(dataBody["last_creator"].(float64))

	storey := dataBody["storey"].(string)

	orgId := this.GetAdminUserInfo().CurrentOrgId

	objectDisinfect := models.XtNewObjectDisinfect{
		UserOrgId:                  orgId,
		RecordDate:                 recorddateunix,
		FirstDisinfectionWater:     first_disinfection_water,
		FirstDisinfectionMethods:   first_disinfection_methods,
		FirstDisinfectionTime:      first_disinfection_time,
		FirstStartTime:             firstStartTimeUnix,
		FirstEndTime:               firstEndTimeUnix,
		FirstTotalTime:             first_total_time,
		FirstIsCheck:               first_is_check,
		FirstModifications:         first_modifications,
		FirstCreator:               first_creator,
		SencondDisinfectionWater:   sencond_disinfection_water,
		SencondDisinfectionMethods: sencond_disinfection_methods,
		SencondDisinfectionTime:    sencond_disinfection_time,
		SencondStartTime:           sencondStartTimeUnixt,
		SencondEndTime:             sencondEndTimeUnixt,
		SencondTotalTime:           sencond_total_time,
		SencondIsCheck:             sencond_is_check,
		SencondModifications:       sencond_modifications,
		SencondCreator:             sencond_creator,
		ThirdDisinfectionWater:     third_disinfection_water,
		ThirdDisinfectionMethods:   third_disinfection_methods,
		ThirdDisinfectionTime:      third_disinfection_time,
		ThirdStartTime:             thirdStartTimeUnix,
		ThirdEndTime:               thirdEndTimeUnix,
		ThirdTotalTime:             third_total_time,
		ThirdIsCheck:               third_is_check,
		ThirdModifications:         third_modifications,
		ThirdCreator:               third_creator,
		LastStartTime:              lastStartTimeUnix,
		LastEndTime:                lastEndTimeUnix,
		LastTotalTime:              last_total_time,
		LastIsCheck:                last_is_check,
		LastModifications:          last_modifications,
		LastCreator:                last_creator,
		Ctime:                      time.Now().Unix(),
		Mtime:                      0,
		Status:                     1,
		FourthDisinfectionWater:    fourth_disinfection_water,
		FourthDisinfectionMethods:  fourth_disinfection_methods,
		FourthDisinfectionTime:     fourth_disinfection_time,
		FourthStartTime:            fourthiStartTimeUnitx,
		FourthEndTime:              fourthEndTimeUnix,
		FourthTotalTime:            fourth_total_time,
		FourthIsCheck:              fourth_is_check,
		FourthModifications:        fourth_modifications,
		FourthCreator:              fourth_creator,
		LastDisinfectionWater:      last_disinfection_water,
		LastDisinfectionMethods:    last_disinfection_methods,
		LastDisinfectionTime:       last_disinfection_time,
		Storey:                     storey,
	}

	err = service.CreateObjectDisInfect(objectDisinfect)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"objectDisinfect": objectDisinfect,
	})
}

func (this *MachineApiController) GetObjectTableDisinfectList() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	storey := this.GetString("storey")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetObjectTableDisinfectList(limit, page, startTime, endTime, orgId, storey)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":  list,
		"total": total,
	})
}

func (this *MachineApiController) GetObjectTableDisinfectByList() {

	id, _ := this.GetInt64("id")
	list, err := service.GetObjectTableDisinfectByList(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *MachineApiController) UpdateObjectTableDisinfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	record_date := dataBody["record_date"].(string)

	id := int64(dataBody["id"].(float64))
	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()

	first_disinfection_water := dataBody["first_disinfection_water"].(string)
	first_disinfection_methods := dataBody["first_disinfection_methods"].(string)
	first_disinfection_time := dataBody["first_disinfection_time"].(string)

	first_start_time := dataBody["first_start_time"].(string)

	var firstStartTimeUnix int64
	if len(first_start_time) > 0 {
		firstStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_start_time)
		firstStartTimeUnix = firstStartTime.Unix()
	}

	var firstEndTimeUnix int64
	first_end_time := dataBody["first_end_time"].(string)

	if len(first_end_time) > 0 {
		firstEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_end_time)
		firstEndTimeUnix = firstEndTime.Unix()
	}

	first_total_time := dataBody["first_total_time"].(string)

	first_is_check := int64(dataBody["first_is_check"].(float64))

	first_modifications := int64(dataBody["first_modifications"].(float64))

	first_creator := int64(dataBody["first_creator"].(float64))

	sencond_disinfection_water := dataBody["sencond_disinfection_water"].(string)
	sencond_disinfection_methods := dataBody["sencond_disinfection_methods"].(string)
	sencond_disinfection_time := dataBody["sencond_disinfection_time"].(string)

	sencond_start_time := dataBody["sencond_start_time"].(string)
	var sencondStartTimeUnixt int64
	if len(sencond_start_time) > 0 {
		sencondStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", sencond_start_time)
		sencondStartTimeUnixt = sencondStartTime.Unix()
	}

	sencond_end_time := dataBody["sencond_end_time"].(string)
	var sencondEndTimeUnixt int64
	if len(sencond_end_time) > 0 {
		sencondEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", sencond_end_time)
		sencondEndTimeUnixt = sencondEndTime.Unix()
	}

	sencond_total_time := dataBody["sencond_total_time"].(string)

	sencond_is_check := int64(dataBody["sencond_is_check"].(float64))

	sencond_modifications := int64(dataBody["sencond_modifications"].(float64))

	sencond_creator := int64(dataBody["sencond_creator"].(float64))

	third_disinfection_water := dataBody["third_disinfection_water"].(string)
	third_disinfection_methods := dataBody["third_disinfection_methods"].(string)
	third_disinfection_time := dataBody["third_disinfection_time"].(string)

	third_start_time := dataBody["third_start_time"].(string)
	var thirdStartTimeUnix int64
	if len(third_start_time) > 0 {
		thirdStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", third_start_time)
		thirdStartTimeUnix = thirdStartTime.Unix()
	}

	third_end_time := dataBody["third_end_time"].(string)
	var thirdEndTimeUnix int64
	if len(third_end_time) > 0 {
		thirdEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", third_end_time)
		thirdEndTimeUnix = thirdEndTime.Unix()
	}

	third_total_time := dataBody["third_total_time"].(string)

	third_is_check := int64(dataBody["third_is_check"].(float64))

	third_modifications := int64(dataBody["third_modifications"].(float64))

	third_creator := int64(dataBody["third_creator"].(float64))

	fourth_disinfection_water := dataBody["fourth_disinfection_water"].(string)
	fourth_disinfection_methods := dataBody["fourth_disinfection_methods"].(string)
	fourth_disinfection_time := dataBody["fourth_disinfection_time"].(string)

	fourth_start_time := dataBody["fourth_start_time"].(string)
	var fourthiStartTimeUnitx int64
	if len(fourth_start_time) > 0 {
		fourthStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", fourth_start_time)
		fourthiStartTimeUnitx = fourthStartTime.Unix()
	}

	fourth_end_time := dataBody["fourth_end_time"].(string)
	var fourthEndTimeUnix int64
	if len(fourth_end_time) > 0 {
		fourthEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", fourth_end_time)
		fourthEndTimeUnix = fourthEndTime.Unix()
	}

	fourth_total_time := dataBody["fourth_total_time"].(string)

	fourth_is_check := int64(dataBody["fourth_is_check"].(float64))

	fourth_modifications := int64(dataBody["fourth_modifications"].(float64))

	fourth_creator := int64(dataBody["fourth_creator"].(float64))

	last_disinfection_water := dataBody["last_disinfection_water"].(string)
	last_disinfection_methods := dataBody["last_disinfection_methods"].(string)
	last_disinfection_time := dataBody["last_disinfection_time"].(string)
	last_start_time := dataBody["last_start_time"].(string)
	var lastStartTimeUnix int64
	if len(last_start_time) > 0 {
		lastStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_start_time)
		lastStartTimeUnix = lastStartTime.Unix()
	}

	last_end_time := dataBody["last_end_time"].(string)

	var lastEndTimeUnix int64
	if len(last_end_time) > 0 {
		lastEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_end_time)
		lastEndTimeUnix = lastEndTime.Unix()
	}

	last_total_time := dataBody["last_total_time"].(string)

	last_is_check := int64(dataBody["last_is_check"].(float64))

	last_modifications := int64(dataBody["last_modifications"].(float64))

	last_creator := int64(dataBody["last_creator"].(float64))

	storey := dataBody["storey"].(string)

	orgId := this.GetAdminUserInfo().CurrentOrgId

	objectDisinfect := models.XtNewObjectDisinfect{
		ID:                         id,
		UserOrgId:                  orgId,
		RecordDate:                 recorddateunix,
		FirstDisinfectionWater:     first_disinfection_water,
		FirstDisinfectionMethods:   first_disinfection_methods,
		FirstDisinfectionTime:      first_disinfection_time,
		FirstStartTime:             firstStartTimeUnix,
		FirstEndTime:               firstEndTimeUnix,
		FirstTotalTime:             first_total_time,
		FirstIsCheck:               first_is_check,
		FirstModifications:         first_modifications,
		FirstCreator:               first_creator,
		SencondDisinfectionWater:   sencond_disinfection_water,
		SencondDisinfectionMethods: sencond_disinfection_methods,
		SencondDisinfectionTime:    sencond_disinfection_time,
		SencondStartTime:           sencondStartTimeUnixt,
		SencondEndTime:             sencondEndTimeUnixt,
		SencondTotalTime:           sencond_total_time,
		SencondIsCheck:             sencond_is_check,
		SencondModifications:       sencond_modifications,
		SencondCreator:             sencond_creator,
		ThirdDisinfectionWater:     third_disinfection_water,
		ThirdDisinfectionMethods:   third_disinfection_methods,
		ThirdDisinfectionTime:      third_disinfection_time,
		ThirdStartTime:             thirdStartTimeUnix,
		ThirdEndTime:               thirdEndTimeUnix,
		ThirdTotalTime:             third_total_time,
		ThirdIsCheck:               third_is_check,
		ThirdModifications:         third_modifications,
		ThirdCreator:               third_creator,
		LastStartTime:              lastStartTimeUnix,
		LastEndTime:                lastEndTimeUnix,
		LastTotalTime:              last_total_time,
		LastIsCheck:                last_is_check,
		LastModifications:          last_modifications,
		LastCreator:                last_creator,
		Ctime:                      time.Now().Unix(),
		Mtime:                      0,
		Status:                     1,
		FourthDisinfectionWater:    fourth_disinfection_water,
		FourthDisinfectionMethods:  fourth_disinfection_methods,
		FourthDisinfectionTime:     fourth_disinfection_time,
		FourthStartTime:            fourthiStartTimeUnitx,
		FourthEndTime:              fourthEndTimeUnix,
		FourthTotalTime:            fourth_total_time,
		FourthIsCheck:              fourth_is_check,
		FourthModifications:        fourth_modifications,
		FourthCreator:              fourth_creator,
		LastDisinfectionWater:      last_disinfection_water,
		LastDisinfectionMethods:    last_disinfection_methods,
		LastDisinfectionTime:       last_disinfection_time,
		Storey:                     storey,
	}
	err = service.UpdateObjectTableDisinfect(objectDisinfect)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"objectDisinfect": objectDisinfect,
	})
}

func (this *MachineApiController) DeleteObjectTableDisinfect() {

	id, _ := this.GetInt64("id")
	err := service.DeleteObjectTableDisinfect(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *MachineApiController) GetAirDisinfectionLongTime() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	storey := this.GetString("storey")
	list, err := service.GetAirDisInfectionLongTime(orgId, storey)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *MachineApiController) GetObjectDisInfectionLongTime() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	list, err := service.GetObjectDisInfectionLongTime(orgId)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *MachineApiController) GetInformationmanalist() {

	//获取2022年8月1日到10月16日的上机患者

	list, _ := service.GetDialysisOrderPatient(10101)

	for _, dialysisOrder := range list {

		//根据床位号获取设备型号
		unitType, _ := service.GetUnitType(dialysisOrder.BedId, dialysisOrder.UserOrgId)
		//查询使用消毒最后一条消毒记录
		_, err := service.GetLaseDeviceInfomation(dialysisOrder.UserOrgId, dialysisOrder.BedId, dialysisOrder.DialysisDate, dialysisOrder.SchedualType)
		fmt.Println("err", err)
		if err == gorm.ErrRecordNotFound {
			//查找排班
			scheduleByPatient, _ := service.GetScheduleByPatient(dialysisOrder.PatientId, dialysisOrder.DialysisDate, dialysisOrder.UserOrgId)
			//查询改设备是否有消毒计划
			plan, errcode := service.GetDisInfectionTime(dialysisOrder.UserOrgId, unitType.UnitType, dialysisOrder.SchedualType, scheduleByPatient.ScheduleWeek)

			//根据床位号获取设备id
			addmacher, _ := service.GetEquimentIDTwo(dialysisOrder.BedId, dialysisOrder.UserOrgId)

			//查询病人信息
			patients, _ := service.GetPatientInfoMation(dialysisOrder.PatientId)
			var con = ""
			if patients.IsInfectious == 0 {
				con = ""
			}
			if patients.IsInfectious == 1 {
				con = "无"
			}
			if patients.IsInfectious == 2 {
				con = "有"
			}

			if errcode == nil {
				var end_time int64
				end_time = dialysisOrder.EndTime + plan.DisinfecTime*60
				//新增消毒
				information := models.DeviceInformation{
					Date:                  dialysisOrder.DialysisDate,
					Zone:                  dialysisOrder.ZoneId,
					Class:                 dialysisOrder.SchedualType,
					BedNumber:             dialysisOrder.BedId,
					PatientId:             dialysisOrder.PatientId,
					DialysisMode:          scheduleByPatient.ModeId,
					LongTime:              strconv.FormatInt(plan.DisinfecTime, 10),
					Disinfection:          1,
					DialysisConcentration: 1,
					DisinfectionStatus:    1,
					Move:                  1,
					UserOrgId:             dialysisOrder.UserOrgId,
					DisinfectType:         plan.Way,
					DisinfectantType:      plan.MachineDisinfectant,
					FluidPath:             plan.DisinfectanWay, //液路消毒方式
					Disinfectant:          plan.Disinfectant,
					Ctime:                 time.Now().Unix(),
					Status:                1,
					SignName:              dialysisOrder.FinishNurse,
					EquimentId:            addmacher.ID,
					DisinfectionResidue:   2,
					Bed:                   addmacher.BedNumber,
					StartTime:             dialysisOrder.StartTime,
					EndTime:               dialysisOrder.EndTime,
					Contagion:             con,
					WeightLoss:            0,
					Hyperfiltratio:        0,
					DialysisHour:          "",
					MachineRun:            1,
					DisinfecStartime:      dialysisOrder.EndTime,
					DisinfecEndtime:       end_time,
				}
				err := service.CreateInformationTwo(&information)
				fmt.Println("报错", err)
			}
		}
	}

	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *MachineApiController) SaveObjectRegistration() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)
	record_date := dataBody["record_date"].(string)

	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()

	model_number := dataBody["model_number"].(string)
	user_count := dataBody["user_count"].(string)

	product_date := dataBody["product_date"].(string)

	productdate, _ := time.ParseInLocation(timeLayout+" 15:04:05", product_date+" 00:00:00", loc)
	productdateunix := productdate.Unix()

	expiry_date := dataBody["expiry_date"].(string)

	expirydate, _ := time.ParseInLocation(timeLayout+" 15:04:05", expiry_date+" 00:00:00", loc)
	expirydateunix := expirydate.Unix()

	packaging_identification := int64(dataBody["packaging_identification"].(float64))

	destroy_people := int64(dataBody["destroy_people"].(float64))

	destroy_nubmer := dataBody["destroy_nubmer"].(string)

	destroy_way := int64(dataBody["destroy_way"].(float64))

	leader := int64(dataBody["leader"].(float64))

	orgId := this.GetAdminUserInfo().CurrentOrgId
	registration := models.XtDialysisRegistration{
		RecordDate:              recorddateunix,
		ModelNumber:             model_number,
		UserCount:               user_count,
		ProductDate:             productdateunix,
		ExpiryDate:              expirydateunix,
		PackagingIdentification: packaging_identification,
		DestroyPeople:           destroy_people,
		DestroyNubmer:           destroy_nubmer,
		DestroyWay:              destroy_way,
		Leader:                  leader,
		UserOrgId:               orgId,
		Status:                  1,
		Ctime:                   time.Now().Unix(),
		Mtime:                   0,
	}

	err = service.CreateObjectRegistration(registration)

	this.ServeSuccessJSON(map[string]interface{}{
		"registration": registration,
	})

}

func (this *MachineApiController) GetRegistrationDisinfectList() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetRegistrationDisinfectList(limit, page, startTime, endTime, orgId)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":  list,
		"total": total,
	})
}

func (this *MachineApiController) GetObjectRegistrationByIdList() {

	id, _ := this.GetInt64("id")

	list, err := service.GetObjectRegistrationByIdList(id)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *MachineApiController) UpdateObjectRegistration() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)
	record_date := dataBody["record_date"].(string)

	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()

	model_number := dataBody["model_number"].(string)
	user_count := dataBody["user_count"].(string)

	product_date := dataBody["product_date"].(string)

	productdate, _ := time.ParseInLocation(timeLayout+" 15:04:05", product_date+" 00:00:00", loc)
	productdateunix := productdate.Unix()

	expiry_date := dataBody["expiry_date"].(string)

	expirydate, _ := time.ParseInLocation(timeLayout+" 15:04:05", expiry_date+" 00:00:00", loc)
	expirydateunix := expirydate.Unix()

	packaging_identification := int64(dataBody["packaging_identification"].(float64))

	destroy_people := int64(dataBody["destroy_people"].(float64))

	destroy_nubmer := dataBody["destroy_nubmer"].(string)

	destroy_way := int64(dataBody["destroy_way"].(float64))

	leader := int64(dataBody["leader"].(float64))

	id := int64(dataBody["id"].(float64))
	orgId := this.GetAdminUserInfo().CurrentOrgId
	registration := models.XtDialysisRegistration{
		ID:                      id,
		RecordDate:              recorddateunix,
		ModelNumber:             model_number,
		UserCount:               user_count,
		ProductDate:             productdateunix,
		ExpiryDate:              expirydateunix,
		PackagingIdentification: packaging_identification,
		DestroyPeople:           destroy_people,
		DestroyNubmer:           destroy_nubmer,
		DestroyWay:              destroy_way,
		Leader:                  leader,
		UserOrgId:               orgId,
		Status:                  1,
		Ctime:                   time.Now().Unix(),
		Mtime:                   0,
	}

	service.UpdateObjectRegistration(registration)

	this.ServeSuccessJSON(map[string]interface{}{
		"registration": registration,
	})
}

func (this *MachineApiController) DeleteObjectTregistration() {

	id, _ := this.GetInt64("id")
	err := service.DeleteObjectTregistration(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"msg": "ok",
	})
	return
}

func (this *MachineApiController) GetRegistGoodInforList() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	list, err := service.GetRegistGoodInforList(orgId)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
	return
}

func (this *MachineApiController) GetRegistNumber() {

	id, _ := this.GetInt64("id")
	record_date := this.GetString("record_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)
	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()
	orgId := this.GetAdminUserInfo().CurrentOrgId
	infor, err := service.GetRegistNumber(recorddateunix, id, orgId)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": infor,
	})
	return
}

func (this *MachineApiController) SaveSetAirDisInfect() {

	air_way, _ := this.GetInt64("air_way")
	orgId := this.GetAdminUserInfo().CurrentOrgId

	airdisinfect, _ := service.GetAirDisInfectSetting(orgId)

	airSetting := models.XtDeviceAirSetting{
		ID:        airdisinfect.ID,
		AirWay:    air_way,
		UserOrgId: orgId,
		Ctime:     time.Now().Unix(),
		Status:    1,
		Mtime:     time.Now().Unix(),
	}

	err := service.SaveSetAirDisInfect(airSetting)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"airSetting": airSetting,
	})
	return

}

func (this *MachineApiController) GetSetAirInfectById() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	airset, _ := service.GetAirDisInfectSetting(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"airset": airset,
	})
	return

}

func (this *MachineApiController) SaveNewAirWayDisinfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	record_date := dataBody["record_date"].(string)
	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()

	first_disinfection_water := dataBody["first_disinfection_water"].(string)
	first_disinfection_methods := dataBody["first_disinfection_methods"].(string)
	first_disinfection_time := dataBody["first_disinfection_time"].(string)

	first_start_time := dataBody["first_start_time"].(string)

	if len(first_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	firstStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_start_time)

	first_end_time := dataBody["first_end_time"].(string)

	if len(first_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	firstEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_end_time)

	first_total_time := dataBody["first_total_time"].(string)

	first_is_check := int64(dataBody["first_is_check"].(float64))

	first_modifications := int64(dataBody["first_modifications"].(float64))

	first_creator := int64(dataBody["first_creator"].(float64))

	last_start_time := dataBody["last_start_time"].(string)

	if len(last_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	lastStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_start_time)

	last_end_time := dataBody["last_end_time"].(string)

	if len(last_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	lastEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_end_time)

	last_total_time := dataBody["last_total_time"].(string)

	last_is_check := int64(dataBody["last_is_check"].(float64))

	last_modifications := int64(dataBody["last_modifications"].(float64))

	last_creator := int64(dataBody["last_creator"].(float64))

	department := dataBody["department"].(string)

	orgId := this.GetAdminUserInfo().CurrentOrgId
	disinfect := models.XtNewAriDisinfectWay{
		UserOrgId:                orgId,
		RecordDate:               recorddateunix,
		FirstDisinfectionWater:   first_disinfection_water,
		FirstDisinfectionMethods: first_disinfection_methods,
		FirstDisinfectionTime:    first_disinfection_time,
		FirstStartTime:           firstStartTime.Unix(),
		FirstEndTime:             firstEndTime.Unix(),
		FirstTotalTime:           first_total_time,
		FirstIsCheck:             first_is_check,
		FirstModifications:       first_modifications,
		FirstCreator:             first_creator,
		LastStartTime:            lastStartTime.Unix(),
		LastEndTime:              lastEndTime.Unix(),
		LastTotalTime:            last_total_time,
		LastIsCheck:              last_is_check,
		LastModifications:        last_modifications,
		LastCreator:              last_creator,
		Ctime:                    time.Now().Unix(),
		Mtime:                    time.Now().Unix(),
		Status:                   1,
		Department:               department,
	}

	err = service.CreateNewAirWayDisinfectOne(disinfect)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"disinfect": disinfect,
	})
}

func (this *MachineApiController) GetNewAirWayDisinfectList() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetNewAirWayDisinfectList(limit, page, startTime, endTime, orgId)
	fmt.Println("lisitwoowowow", list)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":  list,
		"total": total,
	})
}

func (this *MachineApiController) GetAirDisinfectWayLongTime() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	department := this.GetString("department")
	list, err := service.GetAirDisinfectWayLongTime(orgId, department)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *MachineApiController) GetNewAirWayDisinfectByIdList() {

	id, _ := this.GetInt64("id")
	list, err := service.GetNewAirWayDisinfectByIdList(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *MachineApiController) UpdateNewAirWayDisInfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)

	id := int64(dataBody["id"].(float64))
	record_date := dataBody["record_date"].(string)
	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()

	first_disinfection_water := dataBody["first_disinfection_water"].(string)
	first_disinfection_methods := dataBody["first_disinfection_methods"].(string)
	first_disinfection_time := dataBody["first_disinfection_time"].(string)

	first_start_time := dataBody["first_start_time"].(string)

	if len(first_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	firstStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_start_time)

	first_end_time := dataBody["first_end_time"].(string)

	if len(first_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	firstEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_end_time)

	first_total_time := dataBody["first_total_time"].(string)

	first_is_check := int64(dataBody["first_is_check"].(float64))

	first_modifications := int64(dataBody["first_modifications"].(float64))

	first_creator := int64(dataBody["first_creator"].(float64))

	last_start_time := dataBody["last_start_time"].(string)

	if len(last_start_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	lastStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_start_time)

	last_end_time := dataBody["last_end_time"].(string)

	if len(last_end_time) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	lastEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_end_time)

	last_total_time := dataBody["last_total_time"].(string)

	last_is_check := int64(dataBody["last_is_check"].(float64))

	last_modifications := int64(dataBody["last_modifications"].(float64))

	last_creator := int64(dataBody["last_creator"].(float64))

	department := dataBody["department"].(string)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	disinfect := models.XtNewAriDisinfectWay{
		ID:                       id,
		UserOrgId:                orgId,
		RecordDate:               recorddateunix,
		FirstDisinfectionWater:   first_disinfection_water,
		FirstDisinfectionMethods: first_disinfection_methods,
		FirstDisinfectionTime:    first_disinfection_time,
		FirstStartTime:           firstStartTime.Unix(),
		FirstEndTime:             firstEndTime.Unix(),
		FirstTotalTime:           first_total_time,
		FirstIsCheck:             first_is_check,
		FirstModifications:       first_modifications,
		FirstCreator:             first_creator,
		LastStartTime:            lastStartTime.Unix(),
		LastEndTime:              lastEndTime.Unix(),
		LastTotalTime:            last_total_time,
		LastIsCheck:              last_is_check,
		LastModifications:        last_modifications,
		LastCreator:              last_creator,
		Ctime:                    time.Now().Unix(),
		Mtime:                    time.Now().Unix(),
		Status:                   1,
		Department:               department,
	}

	err = service.CreateNewAirWayDisinfect(disinfect)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"disinfect": disinfect,
	})
}

func (this *MachineApiController) DeleteNewAirWayDisinfect() {

	id, _ := this.GetInt64("id")
	err := service.DeleteNewAirWayDisinfect(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"msg": "ok",
	})
	return
}

func (this *MachineApiController) SaveSetObjectDisinfect() {

	air_way, _ := this.GetInt64("air_way")

	orgId := this.GetAdminUserInfo().CurrentOrgId

	disinfect, _ := service.GetObjectTableDisinfect(orgId)

	objctSet := models.XtDeviceObjctSet{
		ID:        disinfect.ID,
		UserOrgId: orgId,
		Status:    1,
		AirWay:    air_way,
		Ctime:     time.Now().Unix(),
		Mtime:     time.Now().Unix(),
	}

	err := service.SaveSetObjectDisinfect(objctSet)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"objctSet": objctSet,
	})
	return
}

func (this *MachineApiController) GetObjectWayDisinect() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	disinfect, _ := service.GetObjectTableDisinfect(orgId)

	this.ServeSuccessJSON(map[string]interface{}{
		"disinfect": disinfect,
	})
	return
}

func (this *MachineApiController) SaveObjectWayTableDisinfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	record_date := dataBody["record_date"].(string)
	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()

	first_disinfection_water := dataBody["first_disinfection_water"].(string)
	first_disinfection_methods := dataBody["first_disinfection_methods"].(string)
	first_disinfection_time := dataBody["first_disinfection_time"].(string)

	first_start_time := dataBody["first_start_time"].(string)

	var firstStartTimeUnix int64
	if len(first_start_time) > 0 {
		firstStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_start_time)
		firstStartTimeUnix = firstStartTime.Unix()
	}

	var firstEndTimeUnix int64
	first_end_time := dataBody["first_end_time"].(string)

	if len(first_end_time) > 0 {
		firstEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_end_time)
		firstEndTimeUnix = firstEndTime.Unix()
	}

	first_total_time := dataBody["first_total_time"].(string)

	first_is_check := int64(dataBody["first_is_check"].(float64))

	first_modifications := int64(dataBody["first_modifications"].(float64))

	first_creator := int64(dataBody["first_creator"].(float64))

	last_disinfection_water := dataBody["last_disinfection_water"].(string)
	last_disinfection_methods := dataBody["last_disinfection_methods"].(string)
	last_disinfection_time := dataBody["last_disinfection_time"].(string)
	last_start_time := dataBody["last_start_time"].(string)
	var lastStartTimeUnix int64
	if len(last_start_time) > 0 {
		lastStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_start_time)
		lastStartTimeUnix = lastStartTime.Unix()
	}

	last_end_time := dataBody["last_end_time"].(string)

	var lastEndTimeUnix int64
	if len(last_end_time) > 0 {
		lastEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_end_time)
		lastEndTimeUnix = lastEndTime.Unix()
	}

	last_total_time := dataBody["last_total_time"].(string)

	last_is_check := int64(dataBody["last_is_check"].(float64))

	last_modifications := int64(dataBody["last_modifications"].(float64))

	last_creator := int64(dataBody["last_creator"].(float64))

	orgId := this.GetAdminUserInfo().CurrentOrgId

	department := dataBody["department"].(string)
	objectDisinfect := models.XtNewObjectDisinfectWay{
		UserOrgId:                orgId,
		RecordDate:               recorddateunix,
		FirstDisinfectionWater:   first_disinfection_water,
		FirstDisinfectionMethods: first_disinfection_methods,
		FirstDisinfectionTime:    first_disinfection_time,
		FirstStartTime:           firstStartTimeUnix,
		FirstEndTime:             firstEndTimeUnix,
		FirstTotalTime:           first_total_time,
		FirstIsCheck:             first_is_check,
		FirstModifications:       first_modifications,
		FirstCreator:             first_creator,
		LastStartTime:            lastStartTimeUnix,
		LastEndTime:              lastEndTimeUnix,
		LastTotalTime:            last_total_time,
		LastIsCheck:              last_is_check,
		LastModifications:        last_modifications,
		LastCreator:              last_creator,
		Ctime:                    time.Now().Unix(),
		Mtime:                    0,
		Status:                   1,
		LastDisinfectionWater:    last_disinfection_water,
		LastDisinfectionMethods:  last_disinfection_methods,
		LastDisinfectionTime:     last_disinfection_time,
		Department:               department,
	}

	err = service.CreateNewObjectWayDisInfect(objectDisinfect)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"objectDisinfect": objectDisinfect,
	})
}

func (this *MachineApiController) GetObjectAbleDisInfectWayList() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	var endTime int64
	if len(end_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		endTime = theTime.Unix()
	}
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetObjectAbleDisInfectWayList(limit, page, startTime, endTime, orgId)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":  list,
		"total": total,
	})
}

func (this *MachineApiController) GetObjectAbledDisInfectWayById() {

	id, _ := this.GetInt64("id")
	list, err := service.GetObjectAbledDisInfectWayById(id)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *MachineApiController) UpdateObjectWayAbleDisinfect() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err", err)
	record_date := dataBody["record_date"].(string)
	recorddate, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
	recorddateunix := recorddate.Unix()

	first_disinfection_water := dataBody["first_disinfection_water"].(string)
	first_disinfection_methods := dataBody["first_disinfection_methods"].(string)
	first_disinfection_time := dataBody["first_disinfection_time"].(string)

	first_start_time := dataBody["first_start_time"].(string)

	var firstStartTimeUnix int64
	if len(first_start_time) > 0 {
		firstStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_start_time)
		firstStartTimeUnix = firstStartTime.Unix()
	}

	var firstEndTimeUnix int64
	first_end_time := dataBody["first_end_time"].(string)

	if len(first_end_time) > 0 {
		firstEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", first_end_time)
		firstEndTimeUnix = firstEndTime.Unix()
	}

	first_total_time := dataBody["first_total_time"].(string)

	first_is_check := int64(dataBody["first_is_check"].(float64))

	first_modifications := int64(dataBody["first_modifications"].(float64))

	first_creator := int64(dataBody["first_creator"].(float64))

	last_disinfection_water := dataBody["last_disinfection_water"].(string)
	last_disinfection_methods := dataBody["last_disinfection_methods"].(string)
	last_disinfection_time := dataBody["last_disinfection_time"].(string)
	last_start_time := dataBody["last_start_time"].(string)
	var lastStartTimeUnix int64
	if len(last_start_time) > 0 {
		lastStartTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_start_time)
		lastStartTimeUnix = lastStartTime.Unix()
	}

	last_end_time := dataBody["last_end_time"].(string)

	var lastEndTimeUnix int64
	if len(last_end_time) > 0 {
		lastEndTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", last_end_time)
		lastEndTimeUnix = lastEndTime.Unix()
	}

	last_total_time := dataBody["last_total_time"].(string)

	last_is_check := int64(dataBody["last_is_check"].(float64))

	last_modifications := int64(dataBody["last_modifications"].(float64))

	last_creator := int64(dataBody["last_creator"].(float64))

	id := int64(dataBody["id"].(float64))

	orgId := this.GetAdminUserInfo().CurrentOrgId

	department := dataBody["department"].(string)
	objectDisinfect := models.XtNewObjectDisinfectWay{
		ID:                       id,
		UserOrgId:                orgId,
		RecordDate:               recorddateunix,
		FirstDisinfectionWater:   first_disinfection_water,
		FirstDisinfectionMethods: first_disinfection_methods,
		FirstDisinfectionTime:    first_disinfection_time,
		FirstStartTime:           firstStartTimeUnix,
		FirstEndTime:             firstEndTimeUnix,
		FirstTotalTime:           first_total_time,
		FirstIsCheck:             first_is_check,
		FirstModifications:       first_modifications,
		FirstCreator:             first_creator,
		LastStartTime:            lastStartTimeUnix,
		LastEndTime:              lastEndTimeUnix,
		LastTotalTime:            last_total_time,
		LastIsCheck:              last_is_check,
		LastModifications:        last_modifications,
		LastCreator:              last_creator,
		Ctime:                    time.Now().Unix(),
		Mtime:                    0,
		Status:                   1,
		LastDisinfectionWater:    last_disinfection_water,
		LastDisinfectionMethods:  last_disinfection_methods,
		LastDisinfectionTime:     last_disinfection_time,
		Department:               department,
	}
	err = service.SaveobjectDisinfect(objectDisinfect)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"objectDisinfect": objectDisinfect,
	})
}

func (this *MachineApiController) DeleteObjectAbleWayDisinfect() {

	id, _ := this.GetInt64("id")
	err := service.DeleteObjectAbleWayDisinfect(id)

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"msg": "ok",
	})
	return
}