XT_New/controllers/self_drug_api_congtroller.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"
	"reflect"
	"strconv"
	"strings"
	"time"
)

type SelfDrugApiController struct {
	BaseAuthAPIController
}

func SelfDrugRouters() {

	beego.Router("/api/drug/getcurrentpatient", &SelfDrugApiController{}, "Get:GetCurrentPatient")
	beego.Router("/api/drug/getalldrugname", &SelfDrugApiController{}, "Get:GetAllDrugName")
	beego.Router("/api/drug/savedrugname", &SelfDrugApiController{}, "Get:SaveDrugName")
	beego.Router("/api/drug/getdrugnamelist", &SelfDrugApiController{}, "Get:GetDrugNameList")
	beego.Router("/api/drug/getrullename", &SelfDrugApiController{}, "Get:GetRulleName")
	beego.Router("/api/drug/getunitbybaseid", &SelfDrugApiController{}, "Get:GetUnitByBaseId")
	beego.Router("/api/drug/saverullename", &SelfDrugApiController{}, "Get:SaveRulleName")
	beego.Router("/api/drug/editrullername", &SelfDrugApiController{}, "Get:EditRullerName")
	beego.Router("/api/drug/updatedrullername", &SelfDrugApiController{}, "Get:UpdatedRullerName")
	beego.Router("/api/drug/getalldrugnamelist", &SelfDrugApiController{}, "Get:GetAllDrugNameList")
	beego.Router("/api/drug/getrulllistbydrugname", &SelfDrugApiController{}, "Get:GetRullerListByDrugName")
	beego.Router("/api/drug/saveselfmedicines", &SelfDrugApiController{}, "Post:SaveSelfMedicines")
	beego.Router("/api/drug/getcurrentorgallstaff", &SelfDrugApiController{}, "Get:GetCurrentOrgAllStaff")
	beego.Router("/api/drug/savestock", &SelfDrugApiController{}, "Post:SaveStock")
	beego.Router("/api/drug/saveoutstock", &SelfDrugApiController{}, "Post:SaveOutStock")
	beego.Router("/api/drug/deletedrugbyid", &SelfDrugApiController{}, "Get:DeleteDrugById")
	beego.Router("/api/drug/saveradio", &SelfDrugApiController{}, "Get:SaveRadio")
	beego.Router("/api/drug/deletedrugstand", &SelfDrugApiController{}, "Get:DeleteDrugStand")
	beego.Router("/api/drug/getstocklist", &SelfDrugApiController{}, "Get:GetStockList")
	beego.Router("/api/drug/deletedrugname", &SelfDrugApiController{}, "Get:DeleteDrugName")
	beego.Router("/api/drug/getdrugdetail", &SelfDrugApiController{}, "Get:GetDrugDetail")
	beego.Router("/api/drug/getallpatientstocklist", &SelfDrugApiController{}, "Get:GetAllPatientStockList")
	beego.Router("/api/drug/getdrugdatabypatientid", &SelfDrugApiController{}, "Get:GetDrugDataByPatientId")
	beego.Router("/api/drug/getselfmedicallist", &SelfDrugApiController{}, "Get:GetSelfMedicalList")
	beego.Router("/api/drug/getdrugdescbydrugname", &SelfDrugApiController{}, "Get:GetDrugDescByDrugName")
	beego.Router("/api/drug/getdrugset", &SelfDrugApiController{}, "Get:GetDrugSet")
	beego.Router("/api/drug/getallmedicallist", &SelfDrugApiController{}, "Get:GetAllMedicalList")
	beego.Router("/api/drug/getstandname", &SelfDrugApiController{}, "Get:GetStandName")
	beego.Router("/api/drug/getrullerlist", &SelfDrugApiController{}, "Get:GetRullerList")
	beego.Router("/api/drug/deleteDrugNamebyid", &SelfDrugApiController{}, "Get:DeleteDrugNameById")
	beego.Router("/api/drug/getpatientdetail", &SelfDrugApiController{}, "Get:GetPatientDetail")
	//beego.Router("/api/drug/getpatientdetail",&SelfDrugApiController{},"Get:ToPatientDetail")
	beego.Router("/api/drug/getselfstockquery", &SelfDrugApiController{}, "Get:GetSelfStockQuery")
	beego.Router("/api/drug/postsearchdrugwarehouselist", &SelfDrugApiController{}, "Get:PostSearchDrugWarehouseList")
	beego.Router("/api/drug/savedrugpriceone", &SelfDrugApiController{}, "Post:SaveDrugPrice")
	beego.Router("/api/drug/drugpricelist", &SelfDrugApiController{}, "Get:GetDrugPriceList")
	beego.Router("/api/drug/savecheckdrugprice", &SelfDrugApiController{}, "Get:SaveCheckDrugPrice")
	beego.Router("/api/drug/savedrugdamageone", &SelfDrugApiController{}, "Post:SaveDrugDamage")
	beego.Router("/api/drug/getdrugdamagelist", &SelfDrugApiController{}, "Get:GetDrugDamageList")
	beego.Router("/api/drug/savedrugdamageprice", &SelfDrugApiController{}, "Get:SaveDrugDamagePrice")
	beego.Router("/api/drug/getdrugmodifyprice", &SelfDrugApiController{}, "Get:GetDrugModifyPrice")
	beego.Router("/api/drug/modifydrugprice", &SelfDrugApiController{}, "Get:ModifyDrugPrice")
	beego.Router("/api/drug/getmodifypriceprint", &SelfDrugApiController{}, "Get:GetModifyPricePrint")
	beego.Router("/api/drug/getdrugdamagedetail", &SelfDrugApiController{}, "Get:GetDrugDamageDetail")
	beego.Router("/api/drug/modifydrugdamage", &SelfDrugApiController{}, "Get:ModifyDrugDamage")
	beego.Router("/api/drug/deletedrugdamage", &SelfDrugApiController{}, "Get:DeleteDrugDamage")
	beego.Router("/api/drug/getdrugdamageprint", &SelfDrugApiController{}, "Get:GetDrugDamagePrint")
	beego.Router("/api/drug/warehouseinfobyid", &SelfDrugApiController{}, "Get:GetWarehoseInfoById")
	beego.Router("/api/drug/savedruginventory", &SelfDrugApiController{}, "Post:SaveDrugInventory")
	beego.Router("/api/drug/getdruginventorylist", &SelfDrugApiController{}, "Get:GetDrugInventoryList")
	beego.Router("/api/drug/savedrugcheckinventory", &SelfDrugApiController{}, "Get:SaveDrugCheckInventory")
	beego.Router("/api/drug/getdruginventorydetail", &SelfDrugApiController{}, "Get:GetDrugInventoryDetail")
	beego.Router("/api/drug/modifyinventory", &SelfDrugApiController{}, "Get:ModifyInventory")
	beego.Router("/api/drug/deletedruginventory", &SelfDrugApiController{}, "Get:DeleteDrugInventory")
	beego.Router("/api/drug/getdruginventoryprintlist", &SelfDrugApiController{}, "Get:GetDrugInventoryPrintList")
	beego.Router("/api/drug/getinventorydetaillist", &SelfDrugApiController{}, "Get:GetDrugInventoryDetailList")
	beego.Router("/api/drug/savedrugproofinventory", &SelfDrugApiController{}, "Get:SaveDrugProofInventory")
	beego.Router("/api/drug/getdrugwarehouseinfototal", &StockManagerApiController{}, "Get:GetDrugWarehouseInfoTotal")

	beego.Router("/api/drug/saveinentorylist", &SelfDrugApiController{}, "Post:SaveInventoryList")

	beego.Router("/api/drug/getdamagebydrugid", &SelfDrugApiController{}, "Get:GetDamageByDrugId")
}

func (this *SelfDrugApiController) GetCurrentPatient() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	patient, err := service.GetCurrentPatient(orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patient": patient,
	})
}

func (this *SelfDrugApiController) GetAllDrugName() {

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

	//查询药品库是否开启
	//configStock, _ := service.GetDrugStockConfig(orgId)
	//if configStock.IsOpen == 1 {
	//
	//}

	drugName, err := service.GetAllDrugName(orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "查寻成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"drugName": drugName,
	})

}

func (this *SelfDrugApiController) SaveDrugName() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	drug_name := this.GetString("drug_name")
	id, _ := this.GetInt64("id")
	//fmt.Println("drug_name", drug_name)
	drugName := models.XtDrugName{
		UserOrgId:   orgId,
		DrugName:    drug_name,
		Status:      1,
		CreatedTime: time.Now().Unix(),
		DrugId:      id,
	}
	_, errcode := service.GetDrugName(drug_name, orgId)
	if errcode == gorm.ErrRecordNotFound {
		err := service.SaveDrugName(&drugName)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"drugName": drugName,
		})
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}
}

func (this *SelfDrugApiController) GetDrugNameList() {

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

func (this *SelfDrugApiController) GetRulleName() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	id, _ := this.GetInt64("id")
	drugId, _ := service.GetDrugId(id)
	rullerList, err := service.GetRulleList(orgId, drugId.DrugId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"rullerList": rullerList,
	})
}

func (this *SelfDrugApiController) GetUnitByBaseId() {

	id, _ := this.GetInt64("id")
	baseList, err := service.GetUnitByBaseId(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"baseList": baseList,
	})
}

func (this *SelfDrugApiController) SaveRulleName() {
	drug_name := this.GetString("drug_name")
	drug_spec := this.GetString("drug_spec")
	drug_stock_limit := this.GetString("drug_stock_limit")
	drug_name_id, _ := this.GetInt64("drug_name_id")
	drug_id, _ := this.GetInt64("drug_id")
	price, _ := this.GetInt64("price")
	prices := strconv.FormatInt(price, 10)
	durg_price, _ := strconv.ParseFloat(prices, 64)
	unit := this.GetString("unit")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	fmt.Println(drug_name, drug_stock_limit, unit, price, drug_spec, orgId)
	drugSpecName := models.XtStandName{
		DrugName:       drug_name,
		DrugSpec:       drug_spec,
		DrugStockLimit: drug_stock_limit,
		DrugNameId:     drug_name_id,
		Price:          durg_price,
		MinUnit:        unit,
		UserOrgId:      orgId,
		Status:         1,
		CreatedTime:    time.Now().Unix(),
		DrugId:         drug_id,
	}

	//查询该机构下药品规格名称是否存在
	_, errcode := service.IsExistStandName(drug_name, drug_spec, adminUserInfo.CurrentOrgId)

	if errcode == gorm.ErrRecordNotFound {
		err := service.SaveRulleName(&drugSpecName)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "创建规格失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"RullerName": drugSpecName,
		})
	} else if errcode == nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "规格已存在")
		return
	}

}

func (this *SelfDrugApiController) EditRullerName() {

	id, _ := this.GetInt64("id")
	rullerDetail, err := service.GetRullerNameDetail(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"rullerDetail": rullerDetail,
	})
}

func (this *SelfDrugApiController) UpdatedRullerName() {

	id, _ := this.GetInt64("id")
	drug_name := this.GetString("drug_name")
	drug_stock_limit := this.GetString("drug_stock_limit")
	price, _ := this.GetInt64("price")
	prices := strconv.FormatInt(price, 10)
	durg_price, _ := strconv.ParseFloat(prices, 64)

	drug_spec := this.GetString("drug_spec")
	unit := this.GetString("unit")
	drug_name_id, _ := this.GetInt64("drug_name_id")
	drug_id, _ := this.GetInt64("drug_id")

	RullerName := models.XtStandName{
		DrugName:       drug_name,
		DrugStockLimit: drug_stock_limit,
		Price:          durg_price,
		DrugSpec:       drug_spec,
		MinUnit:        unit,
		DrugNameId:     drug_name_id,
		DrugId:         drug_id,
	}
	_, errcode := service.GetIsExit(drug_name, drug_spec, id)
	if errcode == gorm.ErrRecordNotFound {
		err := service.UpdatedRullerName(id, &RullerName)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"RullerName": RullerName,
		})
	} else if errcode == nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}

}

func (this *SelfDrugApiController) GetAllDrugNameList() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	rullerName, err := service.GetAllDrugNameList(orgId)

	list, err := service.GetMedicalDrugNameList(orgId)

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

func (this *SelfDrugApiController) GetRullerListByDrugName() {

	id := this.GetString("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	fmt.Println("orgid", orgId)
	drugName, err := service.GetRullerListByDrugName(id, orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"drugName": drugName,
	})
}

func (this *SelfDrugApiController) SaveSelfMedicines() {

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)
	patient_id := int64(dataBody["patient_id"].(float64))
	medicineData, _ := dataBody["medicineData"].([]interface{})
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	for _, item := range medicineData {
		items := item.(map[string]interface{})
		drug_name := items["drug_name"].(string)
		drug_name_id := int64(items["drug_name_id"].(float64))
		drug_spec := items["drug_spec"].(string)
		min_unit := items["min_unit"].(string)
		drug_id := int64(items["drug_id"].(float64))
		//根据drug_id
		drugMedical, _ := service.GetBaseDrugMedical(drug_name_id)
		medical := models.XtSelfMedical{
			DrugName:           drug_name,
			DrugNameId:         drug_name_id,
			DrugSpec:           drug_spec,
			CreatedTime:        time.Now().Unix(),
			Status:             1,
			UserOrgId:          orgId,
			PatientId:          patient_id,
			MinUnit:            min_unit,
			ExecutionFrequency: drugMedical.ExecutionFrequency,
			PrescribingNumber:  drugMedical.PrescribingNumber,
			DeliveryWay:        drugMedical.DeliveryWay,
			SingleDose:         drugMedical.SingleDose,
			DrugId:             drug_id,
		}
		//查询同个病人同个药品同个规格是否已存在
		_, errcode := service.GetSelfMedicalByDrugName(drug_name, drug_spec, patient_id)

		if errcode == gorm.ErrRecordNotFound {
			err := service.CreateSelfMedical(&medical)
			fmt.Println(err)
		} else if errcode == nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
			return
		}

	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *SelfDrugApiController) GetCurrentOrgAllStaff() {

	adminUserInfo := this.GetAdminUserInfo()
	orgid := adminUserInfo.CurrentOrgId
	//fmt.Println(orgid)
	appId := adminUserInfo.CurrentAppId
	staff, err := service.GetCurrentOrgAllStaff(orgid, appId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"staff": staff,
	})
}

func (this *SelfDrugApiController) SaveStock() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	fmt.Println("start_time", start_time)
	admin_user_id, _ := this.GetInt64("admin_user_id")
	fmt.Println("admin_user_id", admin_user_id)
	patient_id, _ := this.GetInt64("patient_id")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)
	stocks, _ := dataBody["stocks"].([]interface{})
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	for _, item := range stocks {
		items := item.(map[string]interface{})
		drug_name := items["drug_name"].(string)
		fmt.Println("drug_name", drug_name)
		drug_name_id := int64(items["drug_name_id"].(float64))
		fmt.Println("parient_id", drug_name_id)
		drug_spec := items["drug_spec"].(string)
		store_number := items["store_number"].(string)
		fmt.Println("store_number", store_number)
		storeNumber, _ := strconv.ParseInt(store_number, 10, 64)
		remarks := items["remarks"].(string)
		min_unit := items["min_unit"].(string)
		medic_id := int64(items["id"].(float64))
		timeStr := time.Now().Format("2006-01-02")
		timeArr := strings.Split(timeStr, "-")
		total, _ := service.FindAllWarehouseOut(adminUserInfo.CurrentOrgId)

		total = total + 1
		warehousing_in_order := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
		number, _ := strconv.ParseInt(warehousing_in_order, 10, 64)
		number = number + total
		warehousing_in_order = "RKD" + strconv.FormatInt(number, 10)

		theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		stock := models.XtSelfStock{
			DrugName:      drug_name,
			DrugNameId:    drug_name_id,
			DrugSpec:      drug_spec,
			StoreNumber:   storeNumber,
			Remarks:       remarks,
			AdminUserId:   admin_user_id,
			StorckTime:    theTime.Unix(),
			CreatedTime:   time.Now().Unix(),
			Status:        1,
			UserOrgId:     orgId,
			StockInNumber: warehousing_in_order,
			PatientId:     patient_id,
			MinUnit:       min_unit,
			StorageMode:   1,
			MedicId:       medic_id,
		}
		err := service.CreateStock(&stock)
		fmt.Println("err", err)
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *SelfDrugApiController) SaveOutStock() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	admin_user_id, _ := this.GetInt64("admin_user_id")
	patient_id, _ := this.GetInt64("patient_id")
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println(err)
	outStocks, _ := dataBody["outStocks"].([]interface{})
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId

	for _, item := range outStocks {
		items := item.(map[string]interface{})
		drug_name := items["drug_name"].(string)
		drug_name_id := int64(items["drug_name_id"].(float64))
		drug_spec := items["drug_spec"].(string)
		outstore_number := items["outstore_number"].(string)
		outStoreNumber, _ := strconv.ParseInt(outstore_number, 10, 64)
		remarks := items["remarks"].(string)
		medic_id := int64(items["id"].(float64))
		timeStr := time.Now().Format("2006-01-02")
		timeArr := strings.Split(timeStr, "-")
		total, _ := service.FindAllWarehouseOut(adminUserInfo.CurrentOrgId)

		total = total + 1
		warehousing_out_order := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
		number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
		number = number + total
		warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
		fmt.Println(remarks)
		fmt.Println(items)
		theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		stock := models.XtSelfOutStock{
			DrugName:       drug_name,
			DrugNameId:     drug_name_id,
			DrugSpec:       drug_spec,
			OutstoreNumber: outStoreNumber,
			Remarks:        remarks,
			AdminUserId:    admin_user_id,
			StorckTime:     theTime.Unix(),
			CreatedTime:    time.Now().Unix(),
			Status:         1,
			UserOrgId:      orgId,
			StockOutNumber: warehousing_out_order,
			PatientId:      patient_id,
			ExitMode:       1,
			MedicId:        medic_id,
		}
		err := service.CreateOutStock(&stock)
		fmt.Println("err", err)
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *SelfDrugApiController) DeleteDrugById() {
	id, _ := this.GetInt64("id")
	drug_name := this.GetString("drug_name")

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

	_, errcode := service.GetStandDrugByDrugName(drug_name, orgId)

	if errcode == gorm.ErrRecordNotFound {
		service.DeleteDrugName(id)
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
	} else if errcode == nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}
}

func (this *SelfDrugApiController) SaveRadio() {

	radio, _ := this.GetInt64("radio")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	drugSet := models.XtDrugSet{
		DrugStart:   radio,
		UserOrgId:   orgId,
		Status:      1,
		CreatedTime: time.Now().Unix(),
	}
	_, errcode := service.GetDrugSetByUserOrgId(orgId)
	if errcode == gorm.ErrRecordNotFound {
		err := service.SaveRadio(&drugSet)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"drugSet": drugSet,
		})
	} else if errcode == nil {
		err := service.UpdateDrugSet(&drugSet, orgId)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"drugSet": drugSet,
		})
	}

}

func (this *SelfDrugApiController) DeleteDrugStand() {

	id, _ := this.GetInt64("id")
	name := this.GetString("name")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId

	_, errcode := service.GetMedicalsByName(orgId, name)
	if errcode == gorm.ErrRecordNotFound {
		err := service.DeleteDrugStand(id)
		fmt.Println(err)
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
	} else if errcode == nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}

}

func (this *SelfDrugApiController) GetStockList() {

	patientid, _ := this.GetInt64("id")
	start_time := this.GetString("start_time")
	fmt.Println("开始时间", start_time)
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	startimeUnix := theTime.Unix()
	keyword := this.GetString("keyword")
	fmt.Println("keyword", keyword)
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	//获取
	medicalList, _ := service.GetMedicalList(patientid, orgId, keyword)
	//统计总数量
	stocklist, err := service.GetStockList(patientid, startimeUnix, keyword, orgId)
	//统计出库数量
	outStocklist, err := service.GetOutStockList(patientid, startimeUnix, keyword, orgId)

	//统计该病人时间段内出库条数
	outList, err := service.GetTotalOutStockList(patientid, startimeUnix, keyword, orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"medicalList":  medicalList,
		"stocklist":    stocklist,
		"outStocklist": outStocklist,
		"outList":      outList,
	})
}

func (this *SelfDrugApiController) DeleteDrugName() {

	drug_name := this.GetString("drugname")
	patient_id, _ := this.GetInt64("patientid")

	//查询该药品是否出库
	stocklist, _ := service.GetStockOutDetail(drug_name, patient_id)
	if len(stocklist) == 0 {
		//删除该药品
		service.DeleteDrugStockNumber(drug_name, patient_id)
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}
}

func (this *SelfDrugApiController) GetDrugDetail() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	drug_name := this.GetString("drug_name")
	drug_spec := this.GetString("drug_spec")
	start_time := this.GetString("start_time")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	end_time := this.GetString("end_time")
	endTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 00:00:00", loc)
	patient_id, _ := this.GetInt64("patient_id")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	//查询入库明细
	stockDetail, err := service.GetStockDetail(drug_name, drug_spec, startTime.Unix(), endTime.Unix(), patient_id, orgId)

	//查询出库明细
	outStockDetail, err := service.GetOutStockDetail(drug_name, drug_spec, startTime.Unix(), endTime.Unix(), patient_id, orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"stockDetail":    stockDetail,
		"outStockDetail": outStockDetail,
	})
}

func (this *SelfDrugApiController) GetAllPatientStockList() {

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	drug_name := this.GetString("drug_name")
	drug_spec := this.GetString("drug_spec")
	start_time := this.GetString("start_time")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	startUnix := theTime.Unix()
	end_time := this.GetString("end_time")
	endTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
	endTimeUnix := endTimes.Unix()
	keywords := this.GetString("search_input")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId

	//入库
	stocklist, err := service.GetAllPatientStockList(drug_name, drug_spec, startUnix, endTimeUnix, keywords, orgId)

	//出库
	outStockList, err := service.GetAllPatientOutStockList(drug_name, drug_spec, startUnix, endTimeUnix, keywords, orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"stocklist":    stocklist,
		"outStockList": outStockList,
	})
}

func (this *SelfDrugApiController) GetDrugDataByPatientId() {

	patient_id, _ := this.GetInt64("patient_id")
	fmt.Println("patient_id", patient_id)
	medicalList, err := service.GetDrugDataByPatientId(patient_id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"medicalList": medicalList,
	})
}

func (this *SelfDrugApiController) GetSelfMedicalList() {

	patient_id, _ := this.GetInt64("patient_id")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	_, drugStockConfig := service.FindDrugStockAutomaticReduceRecordByOrgId(orgId)
	privateDrugConfig, _ := service.GetDrugSetByUserOrgId(orgId)
	drugList, _ := service.GetAllBaseDrugLibList(orgId)
	privateDrugList, _ := service.GetPrivateDrugList(patient_id, orgId)

	this.ServeSuccessJSON(map[string]interface{}{
		"base_drug_config":    drugStockConfig,
		"private_drug_config": privateDrugConfig,
		"base_drug_list":      drugList,
		"private_drug_list":   privateDrugList,
	})
	////查询是否开启药品库
	//config, _ := service.GetDruckStockConfig(orgId)
	//
	//fmt.Println("--------------------------",config.IsOpen)
	////开启
	//if config.IsOpen == 1 {
	//  //查询该机构下的药品库
	//  drugName, _ := service.GetAllDrugName(orgId)
	//
	//  //查询该机构是否开启自备药
	//  medical, _ := service.GetSetSelfMedical(orgId)
	//  fmt.Println("medical+++++++++++++++++",medical.DrugStart)
	//  //开启
	//  if medical.DrugStart == 1 {
	//    list, err := service.GetSelfMedicalList(patient_id)
	//    if err != nil {
	//      this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
	//      return
	//    }
	//    this.ServeSuccessJSON(map[string]interface{}{
	//      "medicalList": list,
	//      "drugName":    drugName,
	//    })
	//  } else {
	//    this.ServeSuccessJSON(map[string]interface{}{
	//      "drugName": drugName,
	//    })
	//  }
	//}
}

func (this *SelfDrugApiController) GetDrugDescByDrugName() {

	drug_name := this.GetString("drug_name")
	patient_id, _ := this.GetInt64("patient_id")
	way, _ := this.GetInt64("way")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	drug_id, _ := this.GetInt64("id")
	//从基础库查询
	if way == 1 {
		//查询基础库数据
		medcal, err := service.GetBaseMedcal(drug_name, orgId)
		//统计入库数量
		countInfo, err := service.GetTotalBaseMedicalCount(drug_id, orgId)

		//统计出库数量
		countout, err := service.GetTotalBaseMedicalCountOut(drug_id, orgId)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"drugspec":  medcal,
			"countInfo": countInfo,
			"countout":  countout,
		})
	}
	//从自备药库查询
	if way == 2 {
		drugspec, err := service.GetDrugDescByDrugName(drug_name, patient_id, orgId)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"drugspec": drugspec,
		})
	}

}

func (this *SelfDrugApiController) GetDrugSet() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	drugSet, err := service.GetDrugSet(orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"drugSet": drugSet,
	})

}

func (this *SelfDrugApiController) GetAllMedicalList() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	list, err := service.GetAllMedicalList(orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"drugName": list,
	})
}

func (this *SelfDrugApiController) GetStandName() {

	name := this.GetString("name")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	rullerlist, err := service.GetRulleName(orgId, name)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"rullerlist": rullerlist,
	})
}

func (this *SelfDrugApiController) GetRullerList() {
	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	rullerList, err := service.GetRulleList(orgId, id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"rullerlist": rullerList,
	})
}

func (this *SelfDrugApiController) DeleteDrugNameById() {

	id, _ := this.GetInt64("id")
	drug_name := this.GetString("drug_name")
	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId

	_, errcode := service.GetStandDrugByDrugName(drug_name, orgId)

	if errcode == gorm.ErrRecordNotFound {
		service.DeleteDrugNameById(id)
		returnData := make(map[string]interface{}, 0)
		returnData["msg"] = "ok"
		this.ServeSuccessJSON(returnData)
	} else if errcode == nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}
}

func (this *SelfDrugApiController) GetPatientDetail() {

	id, _ := this.GetInt64("id")
	adminUserInfo := this.GetAdminUserInfo()
	patientDetail, err := service.GetPatientDetail(id, adminUserInfo.CurrentOrgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patientDetail": patientDetail,
	})
}

//func (this *SelfDrugApiController) ToPatientDetail()  {
//
//  keyword := this.GetString("keyword")
//  adminUser := this.GetAdminUserInfo()
//  orgId := adminUser.CurrentOrgId
//  patient, err := service.ToSeachPatient(keyword, orgId)
//  if err != nil {
//    this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
//    return
//  }
//  this.ServeSuccessJSON(map[string]interface{}{
//    "patient": patient,
//  })
//}

func (this *SelfDrugApiController) GetSelfStockQuery() {

	adminUserInfo := this.GetAdminUserInfo()
	orgId := adminUserInfo.CurrentOrgId
	type_name, _ := this.GetInt64("type_name")
	keywords := this.GetString("keywords")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	start_time := this.GetString("start_time")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
	startUnix := theTime.Unix()
	end_time := this.GetString("end_time")
	endTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
	endTimeUnix := endTimes.Unix()
	page, _ := this.GetInt64("page")
	limit, _ := this.GetInt64("limit")
	//统计入库数量
	stockQuery, total, err := service.GetSelfStockQuery(type_name, keywords, startUnix, endTimeUnix, orgId, limit, page)
	//统计出库数量
	stockOutQuery, err := service.GetSelfOutStockQuery(startUnix, endTimeUnix, orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"stockQuery":    stockQuery,
		"total":         total,
		"stockOutQuery": stockOutQuery,
	})
}

func (this *SelfDrugApiController) PostSearchDrugWarehouseList() {

	keyword := this.GetString("keyword")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, err := service.PostSearchDrugWarehouseList(keyword, orgId)
	manufacturerList, err := service.GetAllManufacturerList(orgId)
	dealerList, err := service.GetAllDealerList(orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list":             list,
		"manufacturerList": manufacturerList,
		"dealerList":       dealerList,
	})
}

func (this *SelfDrugApiController) SaveDrugPrice() {

	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)

	tableData, _ := dataBody["tableData"].([]interface{})
	fmt.Println("999939433443", tableData)
	if len(tableData) > 0 {
		for _, item := range tableData {
			items := item.(map[string]interface{})

			if items["drug_name"] == nil || reflect.TypeOf(items["drug_name"]).String() != "string" {
				utils.ErrorLog("drug_name")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			drug_name := items["drug_name"].(string)
			fmt.Println("drug_aname23232323232", drug_name)
			if items["drug_name"] == nil || reflect.TypeOf(items["drug_name"]).String() != "string" {
				utils.ErrorLog("drug_name")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}

			if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
				utils.ErrorLog("retail_price")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)

			if items["warehousing_order"] == nil || reflect.TypeOf(items["warehousing_order"]).String() != "string" {
				utils.ErrorLog("warehousing_order")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			warehousing_order := items["warehousing_order"].(string)

			if items["number"] == nil || reflect.TypeOf(items["number"]).String() != "string" {
				utils.ErrorLog("number")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			number := items["number"].(string)

			if items["dealer"] == nil || reflect.TypeOf(items["dealer"]).String() != "string" {
				utils.ErrorLog("dealer")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			dealer := items["dealer"].(string)

			if items["manufacturer"] == nil || reflect.TypeOf(items["manufacturer"]).String() != "string" {
				utils.ErrorLog("manufacturer")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			manufacturer := items["manufacturer"].(string)

			if items["specification_name"] == nil || reflect.TypeOf(items["specification_name"]).String() != "string" {
				utils.ErrorLog("specification_name")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			specification_name := items["specification_name"].(string)

			if items["remark"] == nil || reflect.TypeOf(items["remark"]).String() != "string" {
				utils.ErrorLog("remark")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			remark := items["remark"].(string)

			if items["warehousing_unit"] == nil || reflect.TypeOf(items["warehousing_unit"]).String() != "string" {
				utils.ErrorLog("warehousing_unit")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			warehousing_unit := items["warehousing_unit"].(string)

			if items["last_price"] == nil || reflect.TypeOf(items["last_price"]).String() != "string" {
				utils.ErrorLog("last_price")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			last_price, _ := strconv.ParseFloat(items["last_price"].(string), 64)

			if items["new_price"] == nil || reflect.TypeOf(items["new_price"]).String() != "string" {
				utils.ErrorLog("new_price")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			new_price, _ := strconv.ParseFloat(items["new_price"].(string), 64)

			if items["drug_id"] == nil || reflect.TypeOf(items["drug_id"]).String() != "float64" {
				utils.ErrorLog("drug_id")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			drug_id := int64(items["drug_id"].(float64))

			if items["start_time"] == nil || reflect.TypeOf(items["start_time"]).String() != "string" {
				utils.ErrorLog("start_time")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			var startTime int64
			start_time := items["start_time"].(string)
			if len(start_time) > 0 {
				theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
				if err != nil {
					fmt.Println(err)
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				startTime = theTime.Unix()
			}
			orgId := this.GetAdminUserInfo().CurrentOrgId
			Creater := this.GetAdminUserInfo().AdminUser.Id

			drugAdjust := models.XtDrugAdjustPrice{
				DrugName:          drug_name,
				SpecificationName: specification_name,
				WarehousingUnit:   warehousing_unit,
				LastPrice:         last_price,
				RetailPrice:       retail_price,
				NewPrice:          new_price,
				Manufacturer:      manufacturer,
				Dealer:            dealer,
				Remark:            remark,
				DrugId:            drug_id,
				UserOrgId:         orgId,
				Ctime:             time.Now().Unix(),
				Mtime:             0,
				Status:            1,
				WarehousingOrder:  warehousing_order,
				Number:            number,
				StartTime:         startTime,
				Creater:           Creater,
				Checker:           0,
				CheckerStatus:     2,
				CheckerTime:       0,
			}

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

func (this *SelfDrugApiController) GetDrugPriceList() {

	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)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	keyword := this.GetString("keyword")

	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	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()
	}
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	list, total, err := service.GetDrugPriceList(startTime, endTime, orgId, keyword, limit, page)
	doctorList, err := service.GetAllDoctorThree(orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}

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

func (this *SelfDrugApiController) SaveCheckDrugPrice() {
	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)
	idstr := this.GetString("ids")
	ids := strings.Split(idstr, ",")
	check_time := this.GetString("check_time")
	var checkTime int64
	if len(check_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", check_time+" 00:00:00", loc)
		if err != nil {
			fmt.Println(err)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		checkTime = theTime.Unix()
	}
	checker, _ := this.GetInt64("checker")
	adjustPrice := models.XtDrugAdjustPrice{
		Checker:       checker,
		CheckerStatus: 1,
		CheckerTime:   checkTime,
	}
	err = service.UpdateDrugAdjuestPrice(ids, adjustPrice)
	fmt.Println("err", err)
	list, _ := service.GetDrugAdjuestPrice(ids)
	for _, item := range list {
		drug := models.BaseDrugLib{
			RetailPrice: item.NewPrice,
			LastPrice:   item.NewPrice,
		}
		service.UpdateBaseDrugOne(drug, item.DrugId)
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"adjustPrice": adjustPrice,
	})
}

func (this *SelfDrugApiController) SaveDrugDamage() {
	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)

	tableData, _ := dataBody["tableData"].([]interface{})
	fmt.Println("999939433443", tableData)
	if len(tableData) > 0 {
		for _, item := range tableData {
			items := item.(map[string]interface{})
			drug_name := items["drug_name"].(string)
			if items["drug_name"] == nil || reflect.TypeOf(items["drug_name"]).String() != "string" {
				utils.ErrorLog("drug_name")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}

			if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
				utils.ErrorLog("retail_price")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)

			if items["warehousing_order"] == nil || reflect.TypeOf(items["warehousing_order"]).String() != "string" {
				utils.ErrorLog("warehousing_order")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			warehousing_order := items["warehousing_order"].(string)

			if items["number"] == nil || reflect.TypeOf(items["number"]).String() != "string" {
				utils.ErrorLog("number")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			number := items["number"].(string)

			if items["dealer"] == nil || reflect.TypeOf(items["dealer"]).String() != "string" {
				utils.ErrorLog("dealer")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			dealer := items["dealer"].(string)

			if items["manufacturer"] == nil || reflect.TypeOf(items["manufacturer"]).String() != "string" {
				utils.ErrorLog("manufacturer")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			manufacturer := items["manufacturer"].(string)

			if items["specification_name"] == nil || reflect.TypeOf(items["specification_name"]).String() != "string" {
				utils.ErrorLog("specification_name")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			specification_name := items["specification_name"].(string)

			if items["remark"] == nil || reflect.TypeOf(items["remark"]).String() != "string" {
				utils.ErrorLog("remark")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			remark := items["remark"].(string)

			if items["warehousing_unit"] == nil || reflect.TypeOf(items["warehousing_unit"]).String() != "string" {
				utils.ErrorLog("warehousing_unit")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			warehousing_unit := items["warehousing_unit"].(string)

			if items["last_price"] == nil || reflect.TypeOf(items["last_price"]).String() != "string" {
				utils.ErrorLog("last_price")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			last_price, _ := strconv.ParseFloat(items["last_price"].(string), 64)

			if items["count"] == nil || reflect.TypeOf(items["count"]).String() != "float64" {
				utils.ErrorLog("count")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			count := int64(items["count"].(float64))

			if items["new_price"] == nil || reflect.TypeOf(items["new_price"]).String() != "string" {
				utils.ErrorLog("new_price")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			new_price, _ := strconv.ParseFloat(items["new_price"].(string), 64)

			if items["drug_id"] == nil || reflect.TypeOf(items["drug_id"]).String() != "float64" {
				utils.ErrorLog("drug_id")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			drug_id := int64(items["drug_id"].(float64))

			if items["start_time"] == nil || reflect.TypeOf(items["start_time"]).String() != "string" {
				utils.ErrorLog("start_time")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			var startTime int64
			start_time := items["start_time"].(string)
			if len(start_time) > 0 {
				theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
				if err != nil {
					fmt.Println(err)
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				startTime = theTime.Unix()
			}

			if items["warehousing_info_id"] == nil || reflect.TypeOf(items["warehousing_info_id"]).String() != "float64" {
				utils.ErrorLog("warehousing_info_id")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			warehousing_info_id := int64(items["warehousing_info_id"].(float64))

			if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "float64" {
				utils.ErrorLog("expiry_date")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			expiry_date := int64(items["expiry_date"].(float64))

			if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "float64" {
				utils.ErrorLog("product_date")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			product_date := int64(items["product_date"].(float64))

			if items["drug_origin_place"] == nil || reflect.TypeOf(items["drug_origin_place"]).String() != "string" {
				utils.ErrorLog("drug_origin_place")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			drug_origin_place := items["drug_origin_place"].(string)

			orgId := this.GetAdminUserInfo().CurrentOrgId
			Creater := this.GetAdminUserInfo().AdminUser.Id

			if items["stock_max_number"] == nil || reflect.TypeOf(items["stock_max_number"]).String() != "float64" {
				utils.ErrorLog("stock_max_number")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			stock_max_number := int64(items["stock_max_number"].(float64))

			if items["stock_min_number"] == nil || reflect.TypeOf(items["stock_min_number"]).String() != "float64" {
				utils.ErrorLog("stock_min_number")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			stock_min_number := int64(items["stock_min_number"].(float64))

			if items["total"] == nil || reflect.TypeOf(items["total"]).String() != "string" {
				utils.ErrorLog("total")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			total := items["total"].(string)
			drugDamage := models.XtDrugDamage{
				DrugName:          drug_name,
				SpecificationName: specification_name,
				WarehousingUnit:   warehousing_unit,
				Count:             count,
				LastPrice:         last_price,
				RetailPrice:       retail_price,
				NewPrice:          new_price,
				Manufacturer:      manufacturer,
				Dealer:            dealer,
				Remark:            remark,
				DrugId:            drug_id,
				UserOrgId:         orgId,
				Ctime:             time.Now().Unix(),
				Mtime:             0,
				Status:            1,
				WarehousingOrder:  warehousing_order,
				Number:            number,
				StartTime:         startTime,
				Creater:           Creater,
				Checker:           0,
				CheckerStatus:     2,
				CheckerTime:       0,
				ExpiryDate:        expiry_date,
				ProductDate:       product_date,
				WarehousingInfoId: warehousing_info_id,
				DrugOriginPlace:   drug_origin_place,
				StockMaxNumber:    stock_max_number,
				StockMinNumber:    stock_min_number,
				Total:             total,
			}

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

func (this *SelfDrugApiController) GetDrugDamageList() {

	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)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	keyword := this.GetString("keyword")

	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	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()
	}

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

	list, total, err := service.GetDrugDamageList(startTime, endTime, orgId, keyword, limit, page)

	damagelist, _ := service.GetDrugDamageByOrgId(orgId)
	doctorList, err := service.GetAllDoctorThree(orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}

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

func (this *SelfDrugApiController) SaveDrugDamagePrice() {

	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)
	idstr := this.GetString("ids")
	ids := strings.Split(idstr, ",")
	check_time := this.GetString("check_time")
	var checkTime int64
	if len(check_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", check_time+" 00:00:00", loc)
		if err != nil {
			fmt.Println(err)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		checkTime = theTime.Unix()
	}
	checker, _ := this.GetInt64("checker")
	damage := models.XtDrugDamage{
		Checker:       checker,
		CheckerStatus: 1,
		CheckerTime:   checkTime,
	}
	err = service.UpdateDrugDamage(ids, damage)
	fmt.Println(err)
	list, _ := service.GetDrugDamage(ids)
	ctime := time.Now().Unix()
	adminUserInfo := this.GetAdminUserInfo()
	manufacturerList, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)
	dealerList, _ := service.GetAllDealerList(adminUserInfo.CurrentOrgId)
	var manufacturer_id int64
	var dealer_id int64
	timeStr := time.Now().Format("2006-01-02")
	timeArr := strings.Split(timeStr, "-")
	total, _ := service.FindAllDrugWarehouseOut(adminUserInfo.CurrentOrgId)

	total = total + 1
	warehousing_out_order := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
	number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
	number = number + total
	warehousing_out_order = "YPCKD" + strconv.FormatInt(number, 10)
	operation_time := time.Now().Unix()
	creater := adminUserInfo.AdminUser.Id

	warehouseOut := models.DrugWarehouseOut{
		WarehouseOutOrderNumber: warehousing_out_order,
		OperationTime:           operation_time,
		OrgId:                   adminUserInfo.CurrentOrgId,
		Creater:                 creater,
		Ctime:                   ctime,
		Status:                  1,
		WarehouseOutTime:        time.Now().Unix(),
		Type:                    1,
	}
	service.AddSigleDrugWarehouseOut(&warehouseOut)
	for _, item := range list {
		for _, it := range manufacturerList {
			if item.Manufacturer == it.ManufacturerName {
				manufacturer_id = it.ID
			}
		}

		for _, its := range dealerList {
			if its.DealerName == item.Dealer {
				dealer_id = its.ID
			}
		}

		warehouseOutInfo := models.XtDrugWarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseOut.ID,
			DrugId:                  item.DrugId,
			Count:                   item.Count,
			Price:                   item.RetailPrice,
			Status:                  1,
			Ctime:                   ctime,
			Remark:                  item.Remark,
			OrgId:                   adminUserInfo.CurrentOrgId,
			Type:                    1,
			Manufacturer:            manufacturer_id,
			Dealer:                  dealer_id,
			RetailPrice:             item.RetailPrice,
			CountUnit:               item.WarehousingUnit,
			ExpiryDate:              item.ExpiryDate,
			ProductDate:             item.ProductDate,
			Number:                  item.Number,
			BatchNumber:             item.BatchNumber,
			IsSys:                   0,
			WarehouseInfoId:         item.WarehousingInfoId,
		}

		drugflow := models.DrugFlow{
			WarehouseOutId:          warehouseOut.ID,
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			DrugId:                  item.DrugId,
			Number:                  item.Number,
			ProductDate:             item.ProductDate,
			ExpireDate:              item.ExpiryDate,
			Count:                   item.Count,
			Price:                   item.RetailPrice,
			Status:                  1,
			Ctime:                   ctime,
			UserOrgId:               adminUserInfo.CurrentOrgId,
			Manufacturer:            manufacturer_id,
			Dealer:                  dealer_id,
			BatchNumber:             item.BatchNumber,
			MaxUnit:                 item.WarehousingUnit,
			ConsumableType:          5,
			IsEdit:                  1,
			Creator:                 adminUserInfo.AdminUser.Id,
			IsSys:                   0,
		}
		service.CreateWareHouseOutInfo(&warehouseOutInfo)
		service.CreateDrugFlowOne(drugflow)

		info, _ := service.GetDrugByWarehouseInfo(item.WarehousingInfoId)
		//扣减库存
		warehouseInfo := models.XtDrugWarehouseInfo{
			StockMaxNumber: info.StockMaxNumber - info.StockMaxNumber,
		}
		service.UpdateDrugWarehouseingInfo(item.WarehousingInfoId, warehouseInfo)
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"damage": damage,
	})
}

func (this *SelfDrugApiController) GetDrugModifyPrice() {

	id, _ := this.GetInt64("id")
	detail, err := service.GetDrugModifyPrice(id)
	fmt.Println(err)
	this.ServeSuccessJSON(map[string]interface{}{
		"detail": detail,
	})
}

func (this *SelfDrugApiController) ModifyDrugPrice() {

	drug_name := this.GetString("drug_name")
	specification_name := this.GetString("specification_name")
	warehousing_unit := this.GetString("warehousing_unit")
	manufacturer := this.GetString("manufacturer")
	number := this.GetString("number")
	retailPrice := this.GetString("retail_price")
	retail_price, _ := strconv.ParseFloat(retailPrice, 64)
	newPrice := this.GetString("new_price")
	new_price, _ := strconv.ParseFloat(newPrice, 64)
	count, _ := this.GetInt64("count")
	remark := this.GetString("remark")
	id, _ := this.GetInt64("id")
	drug_id, _ := this.GetInt64("drug_id")
	adjustPrice := models.XtDrugAdjustPrice{
		DrugName:          drug_name,
		Count:             count,
		RetailPrice:       retail_price,
		NewPrice:          new_price,
		Remark:            remark,
		SpecificationName: specification_name,
		WarehousingUnit:   warehousing_unit,
		Manufacturer:      manufacturer,
		Number:            number,
		DrugId:            drug_id,
	}
	err := service.ModifyDrugPrice(id, adjustPrice)
	fmt.Println(err)
	this.ServeSuccessJSON(map[string]interface{}{
		"adjustPrice": adjustPrice,
	})
}

func (this *SelfDrugApiController) GetModifyPricePrint() {

	ids := this.GetString("ids")
	idsSplit := strings.Split(ids, ",")
	list, err := service.GetModifyPricePrint(idsSplit)
	fmt.Println(err)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *SelfDrugApiController) GetDrugDamageDetail() {

	id, _ := this.GetInt64("id")
	detail, _ := service.GetDrugDamageDetail(id)
	this.ServeSuccessJSON(map[string]interface{}{
		"detail": detail,
	})
}

func (this *SelfDrugApiController) ModifyDrugDamage() {

	id, _ := this.GetInt64("id")
	drug_id, _ := this.GetInt64("drug_id")
	drug_name := this.GetString("drug_name")
	drug_origin_place := this.GetString("drug_origin_place")
	lastPrice := this.GetString("last_price")
	last_price, _ := strconv.ParseFloat(lastPrice, 64)
	newPrice := this.GetString("new_price")
	new_price, _ := strconv.ParseFloat(newPrice, 64)
	manufacturer := this.GetString("manufacturer")
	number := this.GetString("number")
	retailPrice := this.GetString("retail_price")
	retail_price, _ := strconv.ParseFloat(retailPrice, 64)
	remark := this.GetString("remark")
	count, _ := this.GetInt64("count")
	warehousing_unit := this.GetString("warehousing_unit")
	stock_max_number, _ := this.GetInt64("stock_max_number")
	stock_min_number, _ := this.GetInt64("stock_min_number")
	warehousing_info_id, _ := this.GetInt64("warehousing_info_id")
	damage := models.XtDrugDamage{
		DrugName:          drug_name,
		SpecificationName: "",
		WarehousingUnit:   warehousing_unit,
		Count:             count,
		LastPrice:         last_price,
		RetailPrice:       retail_price,
		NewPrice:          new_price,
		Manufacturer:      manufacturer,
		Dealer:            "",
		Remark:            remark,
		DrugId:            drug_id,
		Number:            number,
		StockMaxNumber:    stock_max_number,
		StockMinNumber:    stock_min_number,
		WarehousingInfoId: warehousing_info_id,
		DrugOriginPlace:   drug_origin_place,
	}
	err := service.ModifyDrugDamage(id, damage)
	fmt.Println(err)
	this.ServeSuccessJSON(map[string]interface{}{
		"damage": damage,
	})
}

func (this *SelfDrugApiController) DeleteDrugDamage() {

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

func (this *SelfDrugApiController) GetDrugDamagePrint() {

	idsSplit := this.GetString("ids")
	ids := strings.Split(idsSplit, ",")
	list, _ := service.GetDrugDamagePrint(ids)
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})
}

func (this *SelfDrugApiController) GetWarehoseInfoById() {

	id, _ := this.GetInt64("id")
	list, _ := service.GetWarehoseInfoById(id)

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

func (this *SelfDrugApiController) SaveDrugInventory() {

	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)

	tableData, _ := dataBody["tableData"].([]interface{})
	fmt.Println("999939433443", tableData)
	if len(tableData) > 0 {
		for _, item := range tableData {
			items := item.(map[string]interface{})
			drug_name := items["drug_name"].(string)

			if items["drug_name"] == nil || reflect.TypeOf(items["drug_name"]).String() != "string" {
				utils.ErrorLog("drug_name")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}

			if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
				utils.ErrorLog("retail_price")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)

			if items["warehousing_order"] == nil || reflect.TypeOf(items["warehousing_order"]).String() != "string" {
				utils.ErrorLog("warehousing_order")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			warehousing_order := items["warehousing_order"].(string)

			if items["dealer"] == nil || reflect.TypeOf(items["dealer"]).String() != "string" {
				utils.ErrorLog("dealer")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			dealer := items["dealer"].(string)

			if items["manufacturer"] == nil || reflect.TypeOf(items["manufacturer"]).String() != "string" {
				utils.ErrorLog("manufacturer")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			manufacturer := items["manufacturer"].(string)

			if items["specification_name"] == nil || reflect.TypeOf(items["specification_name"]).String() != "string" {
				utils.ErrorLog("specification_name")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			specification_name := items["specification_name"].(string)

			if items["remark"] == nil || reflect.TypeOf(items["remark"]).String() != "string" {
				utils.ErrorLog("remark")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			remark := items["remark"].(string)

			if items["warehousing_unit"] == nil || reflect.TypeOf(items["warehousing_unit"]).String() != "string" {
				utils.ErrorLog("warehousing_unit")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			warehousing_unit := items["warehousing_unit"].(string)

			if items["last_price"] == nil || reflect.TypeOf(items["last_price"]).String() != "string" {
				utils.ErrorLog("last_price")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			last_price, _ := strconv.ParseFloat(items["last_price"].(string), 64)

			if items["count"] == nil || reflect.TypeOf(items["count"]).String() != "float64" {
				utils.ErrorLog("count")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			count := int64(items["count"].(float64))

			if items["new_price"] == nil || reflect.TypeOf(items["new_price"]).String() != "string" {
				utils.ErrorLog("new_price")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			new_price, _ := strconv.ParseFloat(items["new_price"].(string), 64)

			if items["drug_id"] == nil || reflect.TypeOf(items["drug_id"]).String() != "float64" {
				utils.ErrorLog("drug_id")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			drug_id := int64(items["drug_id"].(float64))

			if items["start_time"] == nil || reflect.TypeOf(items["start_time"]).String() != "string" {
				utils.ErrorLog("start_time")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			var startTime int64
			start_time := items["start_time"].(string)
			if len(start_time) > 0 {
				theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
				if err != nil {
					fmt.Println(err)
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
				startTime = theTime.Unix()
			}

			if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "float64" {
				utils.ErrorLog("product_date")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			product_date := int64(items["product_date"].(float64))
			if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "float64" {
				utils.ErrorLog("expiry_date")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			expiry_date := int64(items["expiry_date"].(float64))
			orgId := this.GetAdminUserInfo().CurrentOrgId
			Creater := this.GetAdminUserInfo().AdminUser.Id

			if items["number"] == nil || reflect.TypeOf(items["number"]).String() != "string" {
				utils.ErrorLog("number")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}

			numbers := items["number"].(string)

			if items["warehouse_info_id"] == nil || reflect.TypeOf(items["warehouse_info_id"]).String() != "float64" {
				utils.ErrorLog("warehouse_info_id")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			warehouse_info_id := int64(items["warehouse_info_id"].(float64))

			if items["total"] == nil || reflect.TypeOf(items["total"]).String() != "string" {
				utils.ErrorLog("total")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}

			total := items["total"].(string)

			drug_origin_place := items["drug_origin_place"].(string)

			min_count := int64(items["min_count"].(float64))
			min_unit := items["min_unit"].(string)
			inventory := models.XtDrugInventory{

				DrugName:          drug_name,
				SpecificationName: specification_name,
				WarehousingUnit:   warehousing_unit,
				Count:             count,
				LastPrice:         last_price,
				RetailPrice:       retail_price,
				NewPrice:          new_price,
				Manufacturer:      manufacturer,
				Dealer:            dealer,
				Remark:            remark,
				DrugId:            drug_id,
				UserOrgId:         orgId,
				Ctime:             time.Now().Unix(),
				Mtime:             0,
				Status:            1,
				WarehousingOrder:  warehousing_order,
				LicenseNumber:     "",
				StartTime:         startTime,
				Creater:           Creater,
				Checker:           0,
				CheckerStatus:     2,
				CheckerTime:       0,
				ExpiryDate:        expiry_date,
				ProductDate:       product_date,
				Number:            numbers,
				//BatchNumber:       batch_number,
				Total:           total,
				WarehouseInfoId: warehouse_info_id,
				DrugOriginPlace: drug_origin_place,
				MinUnit:         min_unit,
				MinCount:        min_count,
			}
			err = service.CreateDrugInventory(inventory)
			fmt.Println(err)
		}
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"msg": "msg",
	})
}

func (this *SelfDrugApiController) GetDrugInventoryList() {
	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)
	orgId := this.GetAdminUserInfo().CurrentOrgId
	keyword := this.GetString("keyword")
	start_time := this.GetString("start_time")
	end_time := this.GetString("end_time")
	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()
	}

	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	list, total, err := service.GetDrugInventoryList(keyword, page, limit, orgId, startTime, endTime)
	fmt.Println("list23232323223", list)
	doctorList, _ := service.GetAllDoctorThree(orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}

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

func (this *SelfDrugApiController) SaveDrugCheckInventory() {

	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)
	idstr := this.GetString("ids")
	ids := strings.Split(idstr, ",")
	check_time := this.GetString("check_time")
	var checkTime int64
	if len(check_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", check_time+" 00:00:00", loc)
		if err != nil {
			fmt.Println(err)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		checkTime = theTime.Unix()
	}
	checker, _ := this.GetInt64("checker")
	inventory := models.XtDrugInventory{
		Checker:       checker,
		CheckerStatus: 1,
		CheckerTime:   checkTime,
	}
	err = service.UpdateDrugInventory(ids, inventory)
	fmt.Println(err)

	list, _ := service.GetDrugInventoryListByIds(ids)

	adminUserInfo := this.GetAdminUserInfo()
	var stock_total int64
	var proof_count int64
	var maxNumber int64
	var minNumber int64
	for _, item := range list {

		//查询药品信息
		drug, _ := service.GetDrugDetailByDrugId(item.DrugId)

		//查询库存
		info, _ := service.GetDrugWareInfoByIdTwo(item.WarehouseInfoId)
		var max_count int64
		var min_count int64
		for _, it := range info {
			max_count += it.StockMaxNumber
			min_count += it.StockMinNumber
		}

		//获取最晚的库存数量
		lastInfo, _ := service.GetLastDrugWarehouseInfo(item.DrugId)
		firstInfo, _ := service.GetFirstDrugWarehouseInfo(item.DrugId)
		stock_total = max_count*drug.MinNumber + min_count
		proof_count = item.Count*drug.MinNumber + item.MinCount
		fmt.Println("stock_total", stock_total)
		fmt.Println("proof_count", proof_count)
		//判断 如果库存数量 大于盘点库存，则出库
		if stock_total > proof_count {
			minNumber = (stock_total - proof_count) % drug.MinNumber
			maxNumber = (stock_total - proof_count) / drug.MinNumber

			ctime := time.Now().Unix()

			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := service.FindAllDrugWarehouseOut(adminUserInfo.CurrentOrgId)

			total = total + 1
			warehousing_out_order := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
			number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
			number = number + total
			warehousing_out_order = "YPCKD" + strconv.FormatInt(number, 10)
			operation_time := time.Now().Unix()
			creater := adminUserInfo.AdminUser.Id

			warehouseOut := models.DrugWarehouseOut{
				WarehouseOutOrderNumber: warehousing_out_order,
				OperationTime:           operation_time,
				OrgId:                   adminUserInfo.CurrentOrgId,
				Creater:                 creater,
				Ctime:                   ctime,
				Status:                  1,
				WarehouseOutTime:        ctime,
				Type:                    1,
			}
			service.AddSigleDrugWarehouseOut(&warehouseOut)
			warehouse, _ := service.GetLastDrugWarehouseOut(adminUserInfo.CurrentOrgId)
			warehouseOutInfo := models.DrugWarehouseOutInfo{
				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
				WarehouseOutId:          warehouse.ID,
				DrugId:                  item.DrugId,
				Count:                   maxNumber,
				Price:                   firstInfo.Price,
				TotalPrice:              firstInfo.TotalPrice,
				Status:                  1,
				Ctime:                   ctime,
				Remark:                  item.Remark,
				OrgId:                   adminUserInfo.CurrentOrgId,
				Type:                    1,
				Manufacturer:            firstInfo.Manufacturer,
				Dealer:                  firstInfo.Dealer,
				RetailPrice:             firstInfo.RetailPrice,
				RetailTotalPrice:        firstInfo.RetailTotalPrice,
				CountUnit:               drug.MaxUnit,
				ExpiryDate:              firstInfo.ExpiryDate,
				ProductDate:             firstInfo.ProductDate,
				Number:                  firstInfo.Number,
				BatchNumber:             firstInfo.BatchNumber,
				IsSys:                   0,
				WarehouseInfoId:         firstInfo.ID,
			}

			drugflow := models.DrugFlow{
				WarehouseOutId:          warehouseOut.ID,
				WarehouseOutOrderNumber: warehousing_out_order,
				DrugId:                  item.DrugId,
				Number:                  firstInfo.Number,
				ProductDate:             firstInfo.ProductDate,
				ExpireDate:              firstInfo.ExpiryDate,
				Count:                   maxNumber,
				Price:                   firstInfo.Price,
				Status:                  1,
				Ctime:                   ctime,
				UserOrgId:               adminUserInfo.CurrentOrgId,
				Manufacturer:            firstInfo.Manufacturer,
				Dealer:                  firstInfo.Dealer,
				BatchNumber:             firstInfo.BatchNumber,
				MaxUnit:                 drug.MaxUnit,
				ConsumableType:          2,
				IsEdit:                  1,
				Creator:                 adminUserInfo.AdminUser.Id,
				IsSys:                   0,
			}
			service.CreateDrugWarehouseOutInfo(warehouseOutInfo)
			service.CreateDrugFlowOne(drugflow)

			//扣减当前批次号的库存
			var total_count int64

			//查询当前批次库存的数量
			warehosueInfoList, _ := service.GetCurrentWarehosueInfo(item.WarehouseInfoId)
			fmt.Println(warehosueInfoList)
			for _, item := range warehosueInfoList {
				total_count += item.StockMaxNumber*drug.MinNumber + item.StockMinNumber
			}
			//判断当前批次库存 和 需要出库的数据
			//出库
			if proof_count <= total_count {

				//var total_count_one int64
				//获取当前批次号的库存
				//warehouseinfoOne, _ := service.GetCurrentWarehosueInfoOne(item.WarehouseInfoId)
				//total_count_one = warehouseinfoOne.StockMaxNumber * drug.MinNumber + warehouseinfoOne.StockMinNumber

			}
			//报错提示
			if proof_count > total_count {
				this.ServeSuccessJSON(map[string]interface{}{
					"msg": "1",
				})
			}
		}

		//判断 如果库存数量 小于于盘点库存，则入库
		fmt.Println("stock_total2332322323223", stock_total, proof_count)
		if stock_total < proof_count {

			maxNumber = (proof_count - stock_total) / drug.MinNumber
			minNumber = (proof_count - stock_total) % drug.MinNumber
			fmt.Println("min_number23233232323223322323", minNumber)
			ctime := time.Now().Unix()

			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := service.FindAllWarehouseTotalOne(adminUserInfo.CurrentOrgId)
			total = total + 1
			fmt.Println("total2323232323232", total)
			warehousing_order := "YPRKD" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)

			operation_time := time.Now().Unix()
			creater := adminUserInfo.AdminUser.Id
			warehousing := models.DrugWarehouse{
				WarehousingOrder: warehousing_order,
				OperationTime:    operation_time,
				OrgId:            adminUserInfo.CurrentOrgId,
				Creater:          creater,
				Ctime:            ctime,
				Status:           1,
				WarehousingTime:  ctime,
				Type:             1,
			}
			service.AddSigleDrugWarehouse(&warehousing)
			warehouse, _ := service.GetLastDrugWarehouse(adminUserInfo.CurrentOrgId)
			warehouseInfo := models.DrugWarehouseInfo{
				WarehousingOrder:  warehousing.WarehousingOrder,
				WarehousingId:     warehouse.ID,
				DrugId:            item.DrugId,
				Number:            lastInfo.Number,
				ProductDate:       lastInfo.ProductDate,
				ExpiryDate:        lastInfo.ExpiryDate,
				WarehousingCount:  maxNumber,
				Price:             lastInfo.Price,
				TotalPrice:        lastInfo.TotalPrice,
				Status:            1,
				Ctime:             ctime,
				Remark:            item.Remark,
				OrgId:             adminUserInfo.CurrentOrgId,
				Type:              1,
				Manufacturer:      lastInfo.Manufacturer,
				Dealer:            lastInfo.Dealer,
				StockMaxNumber:    maxNumber,
				StockMinNumber:    minNumber,
				RetailTotalPrice:  lastInfo.RetailTotalPrice,
				BatchNumber:       lastInfo.BatchNumber,
				MaxUnit:           drug.MaxUnit,
				MinUnit:           drug.MinUnit,
				WarehousingInfoId: item.WarehouseInfoId,
			}

			drugflow := models.DrugFlow{
				WarehousingOrder: warehousing.WarehousingOrder,
				WarehousingId:    warehouse.ID,
				DrugId:           item.DrugId,
				Number:           lastInfo.Number,
				ProductDate:      lastInfo.ProductDate,
				ExpireDate:       lastInfo.ExpiryDate,
				Count:            maxNumber,
				Price:            lastInfo.Price,
				Status:           1,
				Ctime:            ctime,
				UserOrgId:        adminUserInfo.CurrentOrgId,
				Manufacturer:     lastInfo.Manufacturer,
				Dealer:           lastInfo.Dealer,
				BatchNumber:      lastInfo.BatchNumber,
				MaxUnit:          drug.MaxUnit,
				MinUnit:          drug.MinUnit,
				ConsumableType:   1,
				IsEdit:           1,
				Creator:          adminUserInfo.AdminUser.Id,
				IsSys:            0,
			}

			service.CreateDrugWarehouseInfo(warehouseInfo)
			service.CreateDrugFlowOne(drugflow)

		}
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
}

func (this *SelfDrugApiController) GetDrugInventoryDetail() {

	id, _ := this.GetInt64("id")
	detail, err := service.GetDrugInventoryDetail(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}

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

func (this *SelfDrugApiController) ModifyInventory() {

	id, _ := this.GetInt64("id")
	drug_id, _ := this.GetInt64("drug_id")
	drug_name := this.GetString("drug_name")
	specification_name := this.GetString("specification_name")
	retailPrice := this.GetString("retail_price")
	retail_price, _ := strconv.ParseFloat(retailPrice, 64)
	warehousing_order := this.GetString("warehousing_order")
	number := this.GetString("number")
	manufacturer := this.GetString("manufacturer")
	remark := this.GetString("remark")
	warehousing_unit := this.GetString("warehousing_unit")
	total := this.GetString("total")
	lastPrice := this.GetString("last_price")
	last_price, _ := strconv.ParseFloat(lastPrice, 64)
	count, _ := this.GetInt64("count")
	drug_origin_place := this.GetString("drug_origin_place")

	stock_max_number, _ := this.GetInt64("stock_max_number")
	stock_min_number, _ := this.GetInt64("stock_min_number")
	warehouse_info_id, _ := this.GetInt64("warehouse_info_id")
	min_count, _ := this.GetInt64("min_count")
	min_unit := this.GetString("min_unit")
	inventory := models.XtDrugInventory{
		DrugName:          drug_name,
		SpecificationName: specification_name,
		WarehousingUnit:   warehousing_unit,
		Count:             count,
		LastPrice:         last_price,
		RetailPrice:       retail_price,
		Manufacturer:      manufacturer,
		Remark:            remark,
		DrugId:            drug_id,
		WarehousingOrder:  warehousing_order,
		Number:            number,
		Total:             total,
		DrugOriginPlace:   drug_origin_place,
		StockMaxNumber:    stock_max_number,
		StockMinNumber:    stock_min_number,
		WarehouseInfoId:   warehouse_info_id,
		MinCount:          min_count,
		MinUnit:           min_unit,
	}
	err := service.ModifyDrugInventory(id, inventory)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}

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

func (this *SelfDrugApiController) DeleteDrugInventory() {

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

func (this *SelfDrugApiController) GetDrugInventoryPrintList() {

	ids := this.GetString("ids")

	idssplit := strings.Split(ids, ",")
	list, err := service.GetDrugInventoryPrintList(idssplit)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}

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

func (this *SelfDrugApiController) GetDrugInventoryDetailList() {

	keyword := this.GetString("keyword")
	limit, _ := this.GetInt64("limit")
	page, _ := this.GetInt64("page")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetDrugInventoryDetailList(keyword, page, limit, orgId)
	fmt.Println("list23232323223", list)
	doctorList, _ := service.GetAllDoctorThree(orgId)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}

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

func (this *SelfDrugApiController) SaveDrugProofInventory() {

	id, _ := this.GetInt64("id")
	warehouse_info_id, _ := this.GetInt64("warehouse_info_id")
	warehousing_unit := this.GetString("warehousing_unit")
	remark := this.GetString("remark")
	proof_count, _ := this.GetInt64("proof_count")

	inventory := models.XtDrugInventory{
		WarehouseInfoId: warehouse_info_id,
		ProofCount:      proof_count,
		WarehousingUnit: warehousing_unit,
		Remark:          remark,
	}
	err := service.UpdateDrugProofInventory(id, &inventory)
	info := models.XtDrugWarehouseInfo{
		StockMaxNumber: proof_count,
	}
	service.UpdateDrugWarehouseInfoById(warehouse_info_id, &info)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}

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

func (this *StockManagerApiController) GetDrugWarehouseInfoTotal() {

	id, _ := this.GetInt64("id")
	list, _ := service.GetDrugWarehouseInfoTotal(id)

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

//新改造

func (this *SelfDrugApiController) SaveInventoryList() {

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

	tableData, _ := dataBody["tableData"].([]interface{})
	fmt.Println("999939433443", tableData)
	if len(tableData) > 0 {
		for _, item := range tableData {
			items := item.(map[string]interface{})
			drug_name := items["drug_name"].(string)
			if items["drug_name"] == nil || reflect.TypeOf(items["drug_name"]).String() != "string" {
				utils.ErrorLog("drug_name")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			fmt.Println("drug_name", drug_name)
			specification_name := items["specification_name"].(string)
			if items["specification_name"] == nil || reflect.TypeOf(items["specification_name"]).String() != "string" {
				utils.ErrorLog("specification_name")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}

			max_unit := items["max_unit"].(string)
			if items["max_unit"] == nil || reflect.TypeOf(items["max_unit"]).String() != "string" {
				utils.ErrorLog("max_unit")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}

			min_unit := items["min_unit"].(string)
			if items["min_unit"] == nil || reflect.TypeOf(items["min_unit"]).String() != "string" {
				utils.ErrorLog("min_unit")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}

			drug_id := int64(items["drug_id"].(float64))

			min_number := int64(items["min_number"].(float64))

			stock_max_number := int64(items["stock_max_number"].(float64))

			stock_min_number := int64(items["stock_min_number"].(float64))

			last_stock_max_number := int64(items["last_stock_max_number"].(float64))

			last_stock_min_number := int64(items["last_stock_min_number"].(float64))

			warehousing_order := items["warehousing_order"].(string)

			price := items["price"].(float64)

			manufacturer_name := items["manufacturer_name"].(string)

			batch_number := items["batch_number"].(string)

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

			orgId := this.GetAdminUserInfo().CurrentOrgId

			type_id := int64(items["type"].(float64))

			if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "float64" {
				utils.ErrorLog("expiry_date")
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
			expiry_date := int64(items["expiry_date"].(float64))

			manufacturer := int64(items["manufacturer"].(float64))
			timeLayout := "2006-01-02"
			loc, _ := time.LoadLocation("Local")
			timeNow := time.Now().Format("2006-01-02")
			locationTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", timeNow+" 00:00:00", loc)
			var consumable_type int64
			var consumable_count int64
			var ord_total int64
			var new_total int64
			ord_total = stock_max_number*min_number + stock_min_number
			new_total = last_stock_max_number*min_number + last_stock_min_number

			if ord_total > new_total {
				consumable_type = 11
				consumable_count = ord_total - new_total
			}
			if ord_total < new_total {
				consumable_type = 10
				consumable_count = new_total - ord_total
			}

			//改变库存
			info := models.DrugWarehouseInfo{
				DrugId:         drug_id,
				StockMaxNumber: last_stock_max_number,
				StockMinNumber: last_stock_min_number,
			}

			err = service.ModifyDrugWarehouseInfo(&info, id)
			inventory := models.XtDrugInventory{
				DrugName:           drug_name,
				SpecificationName:  specification_name,
				WarehousingUnit:    max_unit,
				Count:              consumable_count,
				LastPrice:          price,
				RetailPrice:        0,
				NewPrice:           0,
				Manufacturer:       manufacturer_name,
				Dealer:             "",
				Remark:             "",
				DrugId:             drug_id,
				UserOrgId:          orgId,
				Ctime:              time.Now().Unix(),
				Mtime:              0,
				Status:             1,
				WarehousingOrder:   warehousing_order,
				LicenseNumber:      "",
				StartTime:          locationTime.Unix(),
				Creater:            this.GetAdminUserInfo().AdminUser.Id,
				Checker:            0,
				CheckerStatus:      0,
				CheckerTime:        0,
				ExpiryDate:         expiry_date,
				ProductDate:        0,
				Number:             "",
				BatchNumber:        batch_number,
				Total:              "",
				DrugOriginPlace:    "",
				WarehouseInfoId:    id,
				ProofCount:         0,
				StockMaxNumber:     stock_max_number,
				StockMinNumber:     stock_min_number,
				MinCount:           0,
				MinUnit:            min_unit,
				LastStockMaxNumber: last_stock_max_number,
				LastStockMinNumber: last_stock_min_number,
				InventoryType:      consumable_type,
				Type:               type_id,
			}

			err = service.CreateDrugInventory(inventory)

			flow := models.DrugFlow{
				WarehousingId:           id,
				DrugId:                  drug_id,
				Number:                  "",
				BatchNumber:             batch_number,
				Count:                   consumable_count,
				UserOrgId:               orgId,
				PatientId:               0,
				SystemTime:              locationTime.Unix(),
				ConsumableType:          consumable_type,
				IsSys:                   1,
				WarehousingOrder:        warehousing_order,
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: "",
				IsEdit:                  0,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            manufacturer,
				Dealer:                  0,
				Creator:                 this.GetAdminUserInfo().AdminUser.Id,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   price,
				WarehousingDetailId:     id,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ExpireDate:              expiry_date,
				ProductDate:             0,
				MaxUnit:                 max_unit,
				MinUnit:                 min_unit,
			}

			service.CreateDrugFlowOne(flow)

			if err != nil {
				this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
				return
			}

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

func (this *SelfDrugApiController) GetDamageByDrugId() {

	drug_id, _ := this.GetInt64("drug_id")
	warehousing_order := this.GetString("warehousing_order")
	drug_type, _ := this.GetInt64("type")
	list, err := service.GetDamageByDrugId(drug_id, warehousing_order, drug_type)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
		return
	}

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