耗材参数

conf/app.conf

 appname = 血透
-httpport = 9531
+httpport = 9529
 runmode = dev
 
 #

controllers/drug_stock_api_contorller.go

 	beego.Router("/api/drug/drugcancelexportlist", &StockDrugApiController{}, "get:GetDrugCancelExportList")
 	beego.Router("/api/drug/getdrugwarehouseinfoprint", &StockDrugApiController{}, "get:GetDrugWarehouseInfoPrint")
 	beego.Router("/api/drug/getdrugoutorderprint", &StockDrugApiController{}, "get:GetDrugOutOrderPrint")
+
 }
 
 func (c *StockDrugApiController) CreateDrugWarehouse() {

controllers/self_drug_api_congtroller.go

 	beego.Router("/api/drug/deletedruginventory", &SelfDrugApiController{}, "Delete: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")
 }
 
 func (this *SelfDrugApiController) GetCurrentPatient() {
 	}
 	err = service.UpdateDrugAdjuestPrice(ids, adjustPrice)
 	fmt.Println("err", err)
+	list, _ := service.GetDrugAdjuestPrice(ids)
+	for _, item := range list {
+		drug := models.BaseDrugLib{
+			RetailPrice: item.RetailPrice,
+		}
+		service.UpdateBaseDrugOne(drug, item.DrugId)
+	}
 	this.ServeSuccessJSON(map[string]interface{}{
 		"adjustPrice": adjustPrice,
 	})
 }
 
 func (this *SelfDrugApiController) SaveDrugDamage() {
-	fmt.Println("999999999999999999999")
 	timeLayout := "2006-01-02"
 	loc, _ := time.LoadLocation("Local")
 	dataBody := make(map[string]interface{}, 0)
 			}
 			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["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")
 			}
 			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["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")
 				}
 				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
 
 			drugDamage := models.XtDrugDamage{
 				DrugName:          drug_name,
-				SpecificationName: "",
+				SpecificationName: specification_name,
 				WarehousingUnit:   warehousing_unit,
 				Count:             count,
 				LastPrice:         last_price,
 				RetailPrice:       retail_price,
 				NewPrice:          new_price,
 				Manufacturer:      manufacturer,
-				Dealer:            "",
+				Dealer:            dealer,
 				Remark:            remark,
 				DrugId:            drug_id,
 				UserOrgId:         orgId,
 				Checker:           0,
 				CheckerStatus:     2,
 				CheckerTime:       0,
+				ExpiryDate:        expiry_date,
+				ProductDate:       product_date,
+				WarehousingInfoId: warehousing_info_id,
+				DrugOriginPlace:   drug_origin_place,
 			}
 
 			err := service.CreateDrugDamage(drugDamage)
 	}
 	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
+	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
+			}
+		}
+
+		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,
+		}
+
+		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.AddSigleDrugWarehouseOut(&warehouseOut)
+		service.CreateDrugFlowOne(drugflow)
+
+	}
 	this.ServeSuccessJSON(map[string]interface{}{
 		"damage": damage,
 	})
 		for _, item := range tableData {
 			items := item.(map[string]interface{})
 			drug_name := items["drug_name"].(string)
-			fmt.Println("durg_nae232333223332232323323223232323", drug_name)
+
 			if items["drug_name"] == nil || reflect.TypeOf(items["drug_name"]).String() != "string" {
 				utils.ErrorLog("drug_name")
 				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 
 			numbers := items["number"].(string)
 
-			if items["batch_number"] == nil || reflect.TypeOf(items["batch_number"]).String() != "string" {
-				utils.ErrorLog("batch_number")
+			//if items["batch_number"] == nil || reflect.TypeOf(items["batch_number"]).String() != "string" {
+			//	utils.ErrorLog("batch_number")
+			//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			//	return
+			//}
+			//
+			//batch_number := items["batch_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
 			}
-
-			batch_number := items["batch_number"].(string)
-
+			warehouse_info_id := int64(items["warehouse_info_id"].(float64))
 			inventory := models.XtDrugInventory{
 
 				DrugName:          drug_name,
 				ExpiryDate:        expiry_date,
 				ProductDate:       product_date,
 				Number:            numbers,
-				BatchNumber:       batch_number,
+				//BatchNumber:       batch_number,
+				WarehouseInfoId: warehouse_info_id,
 			}
 			err = service.CreateDrugInventory(inventory)
 			fmt.Println(err)
 	manufacturer := this.GetString("manufacturer")
 	remark := this.GetString("remark")
 	warehousing_unit := this.GetString("warehousing_unit")
-	total, _ := this.GetInt64("total")
+	total := this.GetString("total")
 	lastPrice := this.GetString("last_price")
 	last_price, _ := strconv.ParseFloat(lastPrice, 64)
 	count, _ := this.GetInt64("count")
 		"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")
+	//total := this.GetString("total")
+	prof_count, _ := this.GetInt64("prof_count")
+
+	inventory := models.XtDrugInventory{
+		WarehouseInfoId: warehouse_info_id,
+		ProofCount:      prof_count,
+		WarehousingUnit: warehousing_unit,
+		Remark:          remark,
+	}
+	err := service.UpdateDrugProofInventory(warehouse_info_id, &inventory)
+	info := models.XtDrugWarehouseInfo{
+		StockMaxNumber: prof_count,
+	}
+	service.UpdateDrugWarehouseInfoById(id, &info)
+	if err != nil {
+		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
+		return
+	}
+
+	this.ServeSuccessJSON(map[string]interface{}{
+		"inventory": inventory,
+	})
+}

models/self_drug_models.go

 	return "xt_drug_adjust_price"
 }
 
+type VmDrugAdjustPrice struct {
+	ID                int64   `gorm:"column:id" json:"id" form:"id"`
+	DrugName          string  `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
+	SpecificationName string  `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
+	WarehousingUnit   string  `gorm:"column:warehousing_unit" json:"warehousing_unit" form:"warehousing_unit"`
+	Count             int64   `gorm:"column:count" json:"count" form:"count"`
+	LastPrice         float64 `gorm:"column:last_price" json:"last_price" form:"last_price"`
+	RetailPrice       float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	NewPrice          float64 `gorm:"column:new_price" json:"new_price" form:"new_price"`
+	Manufacturer      string  `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	Dealer            string  `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	Remark            string  `gorm:"column:remark" json:"remark" form:"remark"`
+	DrugId            int64   `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
+	UserOrgId         int64   `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	Ctime             int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime             int64   `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Status            int64   `gorm:"column:status" json:"status" form:"status"`
+	WarehousingOrder  string  `gorm:"column:warehousing_order" json:"warehousing_order" form:"warehousing_order"`
+	Number            string  `gorm:"column:number" json:"number" form:"number"`
+	StartTime         int64   `gorm:"column:start_time" json:"start_time" form:"start_time"`
+	Creater           int64   `gorm:"column:creater" json:"creater" form:"creater"`
+	Checker           int64   `gorm:"column:checker" json:"checker" form:"checker"`
+	CheckerStatus     int64   `gorm:"column:checker_status" json:"checker_status" form:"checker_status"`
+	CheckerTime       int64   `gorm:"column:checker_time" json:"checker_time" form:"checker_time"`
+	UserName          string  `gorm:"column:user_name" json:"user_name" form:"user_name"`
+}
+
 type XtDrugDamage struct {
 	ID                int64   `gorm:"column:id" json:"id" form:"id"`
 	DrugName          string  `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
 	Checker           int64   `gorm:"column:checker" json:"checker" form:"checker"`
 	CheckerStatus     int64   `gorm:"column:checker_status" json:"checker_status" form:"checker_status"`
 	CheckerTime       int64   `gorm:"column:checker_time" json:"checker_time" form:"checker_time"`
+	ExpiryDate        int64   `gorm:"column:expiry_date" json:"expiry_date" form:"expiry_date"`
+	ProductDate       int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
+	DrugOriginPlace   string  `gorm:"column:drug_origin_place" json:"drug_origin_place" form:"drug_origin_place"`
+	WarehousingInfoId int64   `gorm:"column:warehousing_info_id" json:"warehousing_info_id" form:"warehousing_info_id"`
+	BatchNumber       string  `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
 }
 
 func (XtDrugDamage) TableName() string {
 	ProductDate       int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
 	Number            string  `gorm:"column:number" json:"number" form:"number"`
 	BatchNumber       string  `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
-	UserName          string  `gorm:"column:user_name" json:"user_name" form:"user_name"`
-	Total             int64   `gorm:"column:total" json:"total" form:"total"`
+	Total             string  `gorm:"column:total" json:"total" form:"total"`
 	DrugOriginPlace   string  `gorm:"column:drug_origin_place" json:"drug_origin_place" form:"drug_origin_place"`
+	WarehouseInfoId   int64   `gorm:"column:warehouse_info_id" json:"warehouse_info_id" form:"warehouse_info_id"`
+	ProofCount        int64   `gorm:"column:proof_count" json:"proof_count" form:"proof_count"`
 }
 
 func (XtDrugInventory) TableName() string {

service/self_drug_service.go

 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	}
-	err = db.Select("x.id,x.warehousing_id,x.drug_id,x.number,x.product_date,x.expiry_date,x.warehousing_count,x.price,x.total_price,x.dealer,x.remark,x.warehousing_order,x.warehouseing_unit,x.stock_max_number,x.stock_min_number,x.batch_number,t.drug_origin_place,t.drug_name,t.min_unit,x.manufacturer,t.retail_price,t.max_unit,t.min_number,t.dose,t.dose_unit,t.last_price").Joins("left join xt_base_drug as t on t.id = x.drug_id").Where("t.drug_name like ? and t.org_id = ?", likeKey, orgid).Order("x.ctime desc").Scan(&info).Error
+	err = db.Select("x.id,x.warehousing_id,x.drug_id,x.number,x.product_date,x.expiry_date,x.warehousing_count,x.price,x.total_price,x.dealer,x.remark,x.warehousing_order,x.warehouseing_unit,x.stock_max_number,x.stock_min_number,x.batch_number,t.drug_origin_place,t.drug_name,t.min_unit,x.manufacturer,t.retail_price,t.max_unit,t.min_number,t.dose,t.dose_unit,t.last_price,t.drug_origin_place").Joins("left join xt_base_drug as t on t.id = x.drug_id").Where("t.drug_name like ? and t.org_id = ?", likeKey, orgid).Order("x.ctime desc").Scan(&info).Error
 	return info, err
 
 }
 	return err
 }
 
-func GetDrugPriceList(startime int64, endtime int64, orgId int64, keyword string, limit int64, page int64) (adjust []*models.XtDrugAdjustPrice, total int64, err error) {
+func GetDrugPriceList(startime int64, endtime int64, orgId int64, keyword string, limit int64, page int64) (adjust []*models.VmDrugAdjustPrice, total int64, err error) {
+	//likeKey := "%" + keyword + "%"
+	//offset := (page - 1) * limit
+	//db := XTReadDB().Model(&adjust).Where("status = 1")
+	//if startime > 0 {
+	//	db = db.Where("ctime >=?", startime)
+	//}
+	//if endtime > 0 {
+	//	db = db.Where("ctime<=?", endtime)
+	//}
+	//if orgId > 0 {
+	//	db = db.Where("user_org_id = ?", orgId)
+	//}
+	//if len(keyword) > 0 {
+	//	db = db.Where("warehousing_order like ?", likeKey)
+	//}
+	//err = db.Count(&total).Offset(offset).Limit(limit).Find(&adjust).Error
+	//return adjust, total, err
 	likeKey := "%" + keyword + "%"
 	offset := (page - 1) * limit
-	db := XTReadDB().Model(&adjust).Where("status = 1")
-	if startime > 0 {
-		db = db.Where("ctime >=?", startime)
-	}
-	if endtime > 0 {
-		db = db.Where("ctime<=?", endtime)
+	db := XTReadDB().Table("xt_drug_adjust_price as x").Where("x.status = 1")
+	table := XTReadDB().Table("xt_base_drug as t").Where("t.status = 1")
+	tab := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
+	fmt.Println(table, tab)
+	if len(keyword) > 0 {
+		db = db.Where("x.warehousing_order = ? or r.user_name like ?", keyword, likeKey)
 	}
 	if orgId > 0 {
-		db = db.Where("user_org_id = ?", orgId)
-	}
-	if len(keyword) > 0 {
-		db = db.Where("warehousing_order like ?", likeKey)
+		db = db.Where("x.user_org_id = ?", orgId)
 	}
-	err = db.Count(&total).Offset(offset).Limit(limit).Find(&adjust).Error
+	err = db.Group("x.id").Select("x.id,x.drug_name,x.specification_name,x.warehousing_unit,x.count,x.last_price,x.retail_price,x.new_price,x.manufacturer,x.dealer,x.remark,x.drug_id,x.warehousing_order,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.number").Joins("left join sgj_users.sgj_user_admin_role as r on r.admin_user_id = x.creater").Joins("left join xt_base_drug as t on t.id =x.drug_id").Count(&total).Offset(offset).Limit(limit).Scan(&adjust).Error
 	return adjust, total, err
+
 }
 
 func UpdateDrugAdjuestPrice(ids []string, info models.XtDrugAdjustPrice) error {
 	return err
 }
 
+func GetDrugAdjuestPrice(ids []string) (info []*models.XtDrugAdjustPrice, err error) {
+
+	err = XTReadDB().Model(&info).Where("id in(?) and status = 1", ids).Find(&info).Error
+	return info, err
+}
+
+func GetDrugDamage(ids []string) (info []*models.XtDrugDamage, err error) {
+
+	err = XTReadDB().Model(&info).Where("id in(?) and status = 1", ids).Find(&info).Error
+	return info, err
+}
+
 func CreateDrugDamage(damage models.XtDrugDamage) error {
 
 	err := XTWriteDB().Create(&damage).Error
 	err = db.Select("x.id,x.drug_name,x.specification_name,x.warehousing_unit,x.count,x.last_price,x.retail_price,x.manufacturer,x.dealer,x.remark,x.drug_id,x.warehousing_order,x.number,x.batch_number,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.total,x.drug_origin_place,t.dose,t.dose_unit,t.max_unit,t.min_unit").Joins("left join sgj_users.sgj_user_admin_role as r on r.id = x.creater").Joins("left join xt_base_drug as t on t.id =x.drug_id").Count(&total).Offset(offset).Limit(limit).Scan(&list).Error
 	return list, total, err
 }
+
+func UpdateDrugProofInventory(id int64, inventory *models.XtDrugInventory) error {
+
+	err := XTWriteDB().Model(&inventory).Where("id=? and status = 1", id).Updates(map[string]interface{}{"warehouse_info_id": inventory.WarehouseInfoId, "proof_count": inventory.ProofCount, "warehousing_unit": inventory.WarehousingUnit, "remark": inventory.Remark}).Error
+	return err
+}
+
+func UpdateDrugWarehouseInfoById(id int64, inventory *models.XtDrugWarehouseInfo) error {
+
+	err := XTWriteDB().Model(&inventory).Where("id = ?", id).Updates(map[string]interface{}{"stock_max_number": inventory.StockMaxNumber}).Error
+	return err
+}

service/stock_service.go

 	err := XTWriteDB().Model(&lib).Where("id = ?", id).Updates(map[string]interface{}{"total": lib.Total}).Error
 	return err
 }
+
+func UpdateBaseDrugOne(lib models.BaseDrugLib, id int64) error {
+
+	err := XTWriteDB().Model(&lib).Where("id = ?", id).Updates(map[string]interface{}{"retail_price": lib.RetailPrice}).Error
+	return err
+}
 func FindeLastWarehouseInfo(id int64) (models.DrugWarehouseInfo, error) {
 	info := models.DrugWarehouseInfo{}
 	err := XTReadDB().Model(&info).Where("id=? and status = 1", id).Find(&info).Error