耗材参数

conf/app.conf

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

controllers/drug_stock_api_contorller.go

 func (c *StockDrugApiController) CreateDrugWarehouse() {
 
 	warehousing_time := c.GetString("warehousing_time")
-	dealer_id, _ := c.GetInt64("dealer_id", 0)
-	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
 
 	types, _ := c.GetInt64("type", 0)
 
 		Ctime:            ctime,
 		Status:           1,
 		WarehousingTime:  warehousingDate.Unix(),
-		Dealer:           dealer_id,
-		Manufacturer:     manufacturer_id,
 		Type:             types,
 	}
 	service.AddSigleDrugWarehouse(&warehousing)
 				last_price, _ := strconv.ParseFloat(items["last_price"].(string), 64)
 				total := float64(warehousing_count) * last_price
 
-				//if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
-				//	utils.ErrorLog("retail_price")
-				//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-				//	return
-				//}
-				//retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)
 				retail_price_total := float64(warehousing_count) * last_price
 
 				var productDates int64
 
 				}
 
-				lot_number, _ := items["lot_number"].(string)
+				number, _ := items["number"].(string)
 
 				batch_number, _ := items["batch_number"].(string)
 
 					return
 				}
 				max_unit, _ := items["max_unit"].(string)
-				fmt.Println("最大单位00000000000000000000000000000000", max_unit)
+
 				if items["min_unit"] == nil || reflect.TypeOf(items["min_unit"]).String() != "string" {
 					utils.ErrorLog("min_unit")
 					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 					return
 				}
 				min_unit, _ := items["min_unit"].(string)
-				fmt.Println("最下单位0090000000000000000000", min_unit)
+
 				var remark string
 				if items["remark"] == nil || reflect.TypeOf(items["remark"]).String() != "string" {
 					remark = ""
 					remark = items["remark"].(string)
 				}
 
+				manufacturer := int64(items["manufacturer"].(float64))
+
+				dealer := int64(items["dealer"].(float64))
+
 				warehouseInfo := &models.DrugWarehouseInfo{
 					WarehousingOrder: warehousing.WarehousingOrder,
 					WarehousingId:    warehousing.ID,
 					DrugId:           drug_id,
-					Number:           lot_number,
+					Number:           number,
 					ProductDate:      productDates,
 					ExpiryDate:       expiryDates,
 					WarehousingCount: warehousing_count,
 					Remark:           remark,
 					OrgId:            adminUserInfo.CurrentOrgId,
 					Type:             types,
-					Manufacturer:     manufacturer_id,
-					Dealer:           dealer_id,
-					//RetailPrice:      retail_price,
+					Manufacturer:     manufacturer,
+					Dealer:           dealer,
 					StockMaxNumber:   warehousing_count,
 					RetailTotalPrice: retail_price_total,
 					BatchNumber:      batch_number,
 	types, _ := c.GetInt64("type", 0)
 	keywords := c.GetString("keywords")
 
-	fmt.Println(start_time)
-	fmt.Println(end_time)
-
 	timeLayout := "2006-01-02"
 	loc, _ := time.LoadLocation("Local")
 	var startTime int64
 	}
 
 	adminUserInfo := c.GetAdminUserInfo()
-	warehouseList, total, err := service.FindAllDrugWarehousingList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords)
+	fmt.Println("hhh2h3h23h2h32h3h2h32h32h3h2h3", keywords)
+	//按药品名称搜索
+	var ids []int64
+	var idArray []int64
+	list, _ := service.GetDrugNameByKeyword(keywords, adminUserInfo.CurrentOrgId)
+	for _, item := range list {
+		ids = append(ids, item.ID)
+	}
+
+	//查找入库单详情
+	if len(ids) > 0 {
+		info, _ := service.GetDrugWarehouseOrderDetailTwo(ids, adminUserInfo.CurrentOrgId, startTime, endTime)
+		for _, it := range info {
+			idArray = append(idArray, it.WarehousingId)
+		}
+	}
+
+	warehouseList, total, err := service.FindAllDrugWarehousingListOne(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords, idArray)
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{
 			"list":  warehouseList,
 	warehousing, err := service.FindDrugWarehousingById(id, admin.CurrentOrgId)
 
 	manufacturerList, _ := service.GetAllManufacturerList(admin.CurrentOrgId)
+	dealerList, _ := service.GetAllDealerList(admin.CurrentOrgId)
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 		return
 			"info":             warehousingInfo,
 			"warehousing":      warehousing,
 			"manufacturerList": manufacturerList,
+			"dealerList":       dealerList,
 		})
 	} else {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 	warehousing_time := c.GetString("warehousing_time")
 	id, _ := c.GetInt64("id", 0)
 	types, _ := c.GetInt64("type", 0)
-	//manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
-	//dealer_id, _ := c.GetInt64("dealer_id", 0)
 
 	if id == 0 {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		Status:           1,
 		WarehousingTime:  warehousingDate.Unix(),
 		Type:             warehouse.Type,
-		//Dealer:           dealer_id,
-		//Manufacturer:     manufacturer_id,
 	}
 
 	service.EditDrugWarehousingOne(warehousing, id)
 				price, _ := strconv.ParseFloat(items["price"].(string), 64)
 				total := float64(warehousing_count) * price
 
-				//if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
-				//	utils.ErrorLog("retail_price")
-				//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-				//	return
-				//}
-				//retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)
-				//retail_price_total := float64(warehousing_count) * last_price
-
 				if items["last_price"] == nil || reflect.TypeOf(items["last_price"]).String() != "string" {
 					utils.ErrorLog("last_price")
 					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 
 				}
 
-				if items["lot_number"] == nil || reflect.TypeOf(items["lot_number"]).String() != "string" {
-					utils.ErrorLog("lot_number")
-					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-					return
-				}
-				number, _ := items["lot_number"].(string)
+				number, _ := items["number"].(string)
 
 				batch_number, _ := items["batch_number"].(string)
 
 				}
 				id := int64(items["id"].(float64))
 
-				//if items["dealer"] == nil || reflect.TypeOf(items["dealer"]).String() != "float64" {
-				//	utils.ErrorLog("dealer")
-				//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-				//	return
-				//}
-				//dealer := int64(items["dealer"].(float64))
-				//
-				if items["manufacturer"] == nil || reflect.TypeOf(items["manufacturer"]).String() != "float64" {
-					utils.ErrorLog("manufacturer")
-					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-					return
-				}
 				manufacturer := int64(items["manufacturer"].(float64))
+
+				dealer := int64(items["dealer"].(float64))
 				if id == 0 {
 					warehouseInfo := &models.DrugWarehouseInfo{
 						WarehousingOrder: warehouse.WarehousingOrder,
 						OrgId:            adminUserInfo.CurrentOrgId,
 						Type:             types,
 						Manufacturer:     manufacturer,
-						//Dealer:           dealer,
+						Dealer:           dealer,
 						RetailPrice:      last_price,
 						RetailTotalPrice: retail_price_total,
 						BatchNumber:      batch_number,
 						OrgId:            adminUserInfo.CurrentOrgId,
 						Type:             types,
 						Manufacturer:     manufacturer,
-						//Dealer:           dealer,
+						Dealer:           dealer,
 						RetailPrice:      last_price,
 						RetailTotalPrice: retail_price_total,
 						StockMaxNumber:   warehousing_count,
 						MaxUnit:          max_unit,
 						MinUnit:          min_unit,
+						BatchNumber:      batch_number,
 					}
 					upDateWarehousingInfo = append(upDateWarehousingInfo, warehouseInfo)
 				}
 }
 
 func (c *StockDrugApiController) CreateDrugWarehouseOut() {
-	dealer_id, _ := c.GetInt64("dealer_id", 0)
-	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
+
 	types, _ := c.GetInt64("type", 0)
 
 	ctime := time.Now().Unix()
 		Ctime:                   ctime,
 		Status:                  1,
 		WarehouseOutTime:        warehousingOutDate.Unix(),
-		Dealer:                  dealer_id,
-		Manufacturer:            manufacturer_id,
 		Type:                    types,
 	}
-	service.AddSigleDrugWarehouseOut(&warehouseOut)
+
 	dataBody := make(map[string]interface{}, 0)
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
 	if err != nil {
 				retail_price_total := float64(count) * last_price
 				remark := items["remark"].(string)
 				max_unit := items["max_unit"].(string)
+				var productDates int64
+				var expiryDates int64
+				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
+					expiryDates = 0
+				} else {
+					if len(items["expiry_date"].(string)) == 0 {
+						expiryDates = 0
+
+					} else {
+						expiryDate, _ := items["expiry_date"].(string)
+						expiry_date, _ := utils.ParseTimeStringToTime("2006-01-02", expiryDate)
+						expiryDates = expiry_date.Unix()
+
+					}
+
+				}
+				if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "string" {
+					productDates = 0
+				} else {
+					if len(items["product_date"].(string)) == 0 {
+						productDates = 0
+
+					} else {
+						productDate, _ := items["product_date"].(string)
+						product_date, _ := utils.ParseTimeStringToTime("2006-01-02", productDate)
+						productDates = product_date.Unix()
+					}
+
+				}
+
+				dealer := int64(items["dealer"].(float64))
+
+				manufacturer := int64(items["manufacturer"].(float64))
+
+				number := items["number"].(string)
+				batch_number := items["batch_number"].(string)
 
 				warehouseOutInfo := &models.DrugWarehouseOutInfo{
 					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 					Remark:                  remark,
 					OrgId:                   adminUserInfo.CurrentOrgId,
 					Type:                    types,
-					Manufacturer:            manufacturer_id,
-					Dealer:                  dealer_id,
+					Manufacturer:            manufacturer,
+					Dealer:                  dealer,
 					RetailPrice:             last_price,
 					RetailTotalPrice:        retail_price_total,
 					CountUnit:               max_unit,
+					ExpiryDate:              expiryDates,
+					ProductDate:             productDates,
+					Number:                  number,
+					BatchNumber:             batch_number,
 				}
 				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 	}
 
 	//调用出库逻辑
-	//for _, item := range warehousingOutInfo {
-	//
-	//	// 出库流程
-	//	// 1.查询改药品在药品库的规格信息，并将处方里的规格进行换算（尽量将拆零单位转换成包装单位）
-	//	drup, _ := service.FindBaseDrugLibRecord(item.OrgId, item.DrugId)
-	//	if drup.ID > 0 {
-	//		prescribingNumber := item.Count
-	//
-	//		service.AutoDrugDeliverInfo(item.OrgId, prescribingNumber, &warehouseOut, &drup, item)
-	//
-	//	}
-	//
-	//}
+	for _, item := range warehousingOutInfo {
+		//获取药品库存
+		info, _ := service.GetDrugTotalCount(item.DrugId, item.OrgId)
+		if item.Count > info.Count {
+
+			goodObj, _ := service.GetDrugByGoodId(item.DrugId)
+			c.ServeSuccessJSON(map[string]interface{}{
+				"msg":        "1",
+				"drug_name":  goodObj.DrugName,
+				"dose":       goodObj.Dose,
+				"dose_unit":  goodObj.DoseUnit,
+				"min_number": goodObj.MinNumber,
+				"min_unit":   goodObj.MinUnit,
+				"max_unit":   goodObj.MaxUnit,
+			})
+			return
+		} else {
+			service.AddSigleDrugWarehouseOut(&warehouseOut)
+			// 出库流程
+			// 1.查询改药品在药品库的规格信息，并将处方里的规格进行换算（尽量将拆零单位转换成包装单位）
+			drup, _ := service.FindBaseDrugLibRecord(item.OrgId, item.DrugId)
+			if drup.ID > 0 {
+				prescribingNumber := item.Count
+				service.AutoDrugDeliverInfo(item.OrgId, prescribingNumber, &warehouseOut, &drup, item)
+			}
+		}
 
-	errs := service.CreateDrugWarehousingOutInfo(warehousingOutInfo)
-	info, _ := service.FindLastDrugWarehousingOutInfo(warehouseOut.WarehouseOutOrderNumber)
-	if errs != nil {
-		utils.ErrorLog(errs.Error())
-		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
-		return
 	}
 
+	//errs := service.CreateDrugWarehousingOutInfo(warehousingOutInfo)
+	//info, _ := service.FindLastDrugWarehousingOutInfo(warehouseOut.WarehouseOutOrderNumber)
+	//if errs != nil {
+	//	utils.ErrorLog(errs.Error())
+	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
+	//	return
+	//}
+
 	c.ServeSuccessJSON(map[string]interface{}{
-		"info":                  info,
-		"msg":                   "出库成功",
-		"warehousing_out_order": warehousing_out_order,
+		"msg":        "2",
+		"drug_name":  "",
+		"dose":       "",
+		"dose_unit":  "",
+		"min_number": "",
+		"min_unit":   "",
+		"max_unit":   "",
 	})
 
 }
 	}
 
 	adminUserInfo := c.GetAdminUserInfo()
-	warehouseOutList, total, err := service.FindAllDrugWarehouseOutList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords)
+
+	var ids []int64
+	var goodids []int64
+	if len(keywords) > 0 {
+		//查询商品名称
+		list, _ := service.GetDrugNameByKeyword(keywords, adminUserInfo.CurrentOrgId)
+		for _, item := range list {
+			goodids = append(goodids, item.ID)
+		}
+
+		if len(goodids) > 0 {
+			//出库详情但里面查询
+			info, _ := service.GetDrugWarehouseOrderDetail(goodids, adminUserInfo.CurrentOrgId, startTime, endTime)
+			for _, it := range info {
+				ids = append(ids, it.WarehouseOutId)
+			}
+		}
+
+	}
+
+	warehouseOutList, total, err := service.FindAllDrugWarehouseOutListOne(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords, ids)
 	fmt.Println(err)
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{
 	warehouseOutInfo, _ := service.FindDrugWarehouseOutInfoById(id, adminInfo.CurrentOrgId)
 	warehouseOut, _ := service.FindDrugWareHouseOutById(id, adminInfo.CurrentOrgId)
 	manulist, _ := service.GetAllManufacturerList(adminInfo.CurrentOrgId)
+	dealerList, _ := service.GetAllDealerList(adminInfo.CurrentOrgId)
 	c.ServeSuccessJSON(map[string]interface{}{
-		"list":     warehouseOutInfo,
-		"info":     warehouseOut,
-		"manulist": manulist,
+		"list":       warehouseOutInfo,
+		"info":       warehouseOut,
+		"manulist":   manulist,
+		"dealerList": dealerList,
 	})
 
 }
 	warehouse_out_time := c.GetString("warehouse_out_time")
 	id, _ := c.GetInt64("id", 0)
 	types, _ := c.GetInt64("type", 0)
-	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
-	dealer_id, _ := c.GetInt64("dealer_id", 0)
 
 	if id == 0 {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		ID:               warehouseOut.ID,
 		Mtime:            mtime,
 		WarehouseOutTime: warehouseOutDate.Unix(),
-		Manufacturer:     manufacturer_id,
-		Dealer:           dealer_id,
 	}
 
 	service.EditDrugWarehouseOut(tempWarehouseOut)
 				}
 				id := int64(items["id"].(float64))
 
+				dealer := int64(items["dealer"].(float64))
+				manufacturer := int64(items["manufacturer"].(float64))
+
+				batch_number := items["batch_number"].(string)
+				number := items["number"].(string)
+
+				var productDates int64
+				var expiryDates int64
+				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
+					expiryDates = 0
+				} else {
+					if len(items["expiry_date"].(string)) == 0 {
+						expiryDates = 0
+
+					} else {
+						expiryDate, _ := items["expiry_date"].(string)
+						expiry_date, _ := utils.ParseTimeStringToTime("2006-01-02", expiryDate)
+						expiryDates = expiry_date.Unix()
+
+					}
+
+				}
+				if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "string" {
+					productDates = 0
+				} else {
+					if len(items["product_date"].(string)) == 0 {
+						productDates = 0
+
+					} else {
+						productDate, _ := items["product_date"].(string)
+						product_date, _ := utils.ParseTimeStringToTime("2006-01-02", productDate)
+						productDates = product_date.Unix()
+					}
+
+				}
 				if id == 0 {
 					warehouseOutInfo := &models.DrugWarehouseOutInfo{
 						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 						Remark:                  remark,
 						OrgId:                   adminUserInfo.CurrentOrgId,
 						Type:                    types,
-						Manufacturer:            manufacturer_id,
-						Dealer:                  dealer_id,
+						Manufacturer:            manufacturer,
+						Dealer:                  dealer,
 						IsSys:                   0,
 						SysRecordTime:           0,
 						RetailPrice:             retail_price,
 						RetailTotalPrice:        retail_price_total,
+						BatchNumber:             batch_number,
+						Number:                  number,
+						ProductDate:             productDates,
+						ExpiryDate:              expiryDates,
 					}
 					warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 						OrgId:                   adminUserInfo.CurrentOrgId,
 						Mtime:                   time.Now().Unix(),
 						Type:                    types,
-						Manufacturer:            manufacturer_id,
-						Dealer:                  dealer_id,
+						Manufacturer:            manufacturer,
+						Dealer:                  dealer,
 						IsSys:                   is_sys,
 						SysRecordTime:           sys_record_time,
 						RetailPrice:             retail_price,
 						RetailTotalPrice:        retail_price_total,
+						BatchNumber:             batch_number,
+						Number:                  number,
+						ProductDate:             productDates,
+						ExpiryDate:              expiryDates,
 					}
 					upDateWarehouseOutInfos = append(upDateWarehouseOutInfos, warehouseOutInfo)
 				}

controllers/gobal_config_api_controller.go

 	id, _ := c.GetInt64("id")
 	orgId := c.GetAdminUserInfo().CurrentOrgId
 	list, err := service.GetSingleOrderDetail(id, orgId)
+	dealerList, err := service.GetAllDealerList(orgId)
+	manufacturerList, err := service.GetAllManufacturerList(orgId)
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
 		return
 	}
 	c.ServeSuccessJSON(map[string]interface{}{
-		"list": list,
+		"list":             list,
+		"dealerList":       dealerList,
+		"manufacturerList": manufacturerList,
 	})
 }
 

controllers/manager_center_api_controller.go

 
 	list, err := service.GetAllDrugList(orgId)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
+	dealerList, _ := service.GetAllDealerList(orgId)
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{
 			"list":             list,
 			"manufacturerList": manufacturerList,
+			"dealerList":       dealerList,
 		})
 	} else {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 	orgId := c.GetAdminUserInfo().CurrentOrgId
 	list, err := service.GetSearchDrugList(keyword, orgId)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
+	dealerList, _ := service.GetAllDealerList(orgId)
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{
 			"list":             list,
 			"manufacturerList": manufacturerList,
+			"dealerList":       dealerList,
 		})
 	} else {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)

controllers/mobile_api_controllers/dialysis_api_controller.go

 
 		//查询是否有库存
 		for _, item := range consumables {
-			warehouse, err := service.FindFirstWarehousingInfoByStock(item.GoodId, item.GoodTypeId)
-			fmt.Println("库存数量00000000000000000000", warehouse.StockCount)
-			if err != nil {
+			warehouse, _ := service.FindFirstWarehousingInfoByStockTwo(item.GoodId, item.GoodTypeId)
+
+			if item.Count > warehouse.Count {
 				goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
 				c.ServeSuccessJSON(map[string]interface{}{
 					"message":            "1",
 	fmt.Println("前端数据9999999999999", beforePrepares)
 	//查询是否有库存
 	for _, item := range beforePrepares {
-		warehouse, err := service.FindFirstWarehousingInfoByStock(item.GoodId, item.GoodTypeId)
-		fmt.Println("库存数量00000000000000000000", warehouse.StockCount)
-		if err != nil {
+		warehouse, _ := service.FindFirstWarehousingInfoByStockTwo(item.GoodId, item.GoodTypeId)
+
+		if item.Count > warehouse.Count {
 			goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
 			c.ServeSuccessJSON(map[string]interface{}{
 				"message":            "1",

controllers/stock_in_api_controller.go

 	beego.Router("/api/good/getsingleoutorderdetail", &StockManagerApiController{}, "Get:GetSingleOutOrderDetail")
 	beego.Router("/api/stock/getexportstocklist", &StockManagerApiController{}, "Get:GetExprotStockList")
 	beego.Router("/api/stock/getoutexprotlist", &StockManagerApiController{}, "Get:GetOutExprotList")
+	beego.Router("/api/stock/getsinglecancelorder", &StockManagerApiController{}, "Get:GetSingleCancelOrder")
 
 }
 
 				var productDates int64
 				var expiryDates int64
 
-				fmt.Println()
-
 				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
 					expiryDates = 0
 				} else {
 	operation_time := time.Now().Unix()
 	creater := adminUserInfo.AdminUser.Id
 
-	_, errcode := service.FindStockOutByIsSys(adminUserInfo.CurrentOrgId, 0, operation_time)
 	warehouseOut := models.WarehouseOut{
 		WarehouseOutOrderNumber: warehousing_out_order,
 		OperationTime:           operation_time,
 		WarehouseOutTime:        warehousingOutDate.Unix(),
 		Type:                    types,
 	}
-	if errcode == gorm.ErrRecordNotFound {
-		service.AddSigleWarehouseOut(&warehouseOut)
-	}
 
 	dataBody := make(map[string]interface{}, 0)
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
 					}
 					productDate = theTime.Unix()
 				}
-
+				license_number := items["license_number"].(string)
 				warehouseOutInfo := &models.WarehouseOutInfo{
 					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 					WarehouseOutId:          warehouseOut.ID,
 					ExpiryDate:              expiryDate,
 					ProductDate:             productDate,
 					Dealer:                  dealer,
+					LicenseNumber:           license_number,
 				}
 				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 	//出库逻辑
 	for _, item := range warehousingOutInfo {
 		//查询库存
-		warehouse, err := service.FindFirstWarehousingInfoByStockTwo(item.GoodId, item.GoodTypeId)
+		warehouse, _ := service.FindFirstWarehousingInfoByStockTwo(item.GoodId, item.GoodTypeId)
 		fmt.Println("库存数量组吗", warehouse.Count)
-		if err != nil {
+		if item.Count > warehouse.Count {
 			goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
 			c.ServeSuccessJSON(map[string]interface{}{
 				"msg":                "1",
 			})
 			return
 		} else {
+			_, errcodes := service.FindStockOutByIsSys(adminUserInfo.CurrentOrgId, 0, operation_time)
+			if errcodes == gorm.ErrRecordNotFound {
+				service.AddSigleWarehouseOut(&warehouseOut)
+			}
 			parseDateErr := service.ConsumablesDeliveryOne(adminUserInfo.CurrentOrgId, warehousingOutDate.Unix(), item, &warehouseOut, item.Count)
-			fmt.Println(parseDateErr)
 			if parseDateErr != nil {
 				utils.ErrorLog(parseDateErr.Error())
 				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
 
 				number := items["number"].(string)
 
+				license_number := items["license_number"].(string)
+				fmt.Println("hhh23h2h32h3h232h3h23h2h3h23h2h3h23h2h3", license_number)
 				timeLayout := "2006-01-02"
 				loc, _ := time.LoadLocation("Local")
 				expiry_date := items["expiry_date"].(string)
 						ProductDate:             productDate,
 						Dealer:                  dealer,
 						Manufacturer:            manufacturer,
+						LicenseNumber:           license_number,
 					}
 					warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 						ExpiryDate:              expiryDate,
 						ProductDate:             productDate,
 						Dealer:                  dealer,
+						LicenseNumber:           license_number,
 					}
 					upDateWarehouseOutInfos = append(upDateWarehouseOutInfos, warehouseOutInfo)
 				}
 		}
 	}
 	errs := service.CreateCancelStockInfo(cancelStockInfos)
+
+	// 改变入库单的值
+	for _, item := range cancelStockInfos {
+
+		//查询该耗材的入库记录
+		list, _ := service.GetWarehoureOrderInfoList(item.GoodId, item.OrgId)
+		//调用退库的方法
+		service.UpdateCancelOut(list, item.Count)
+	}
+
 	if errs != nil {
 		utils.ErrorLog(errs.Error())
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
 		"count": outCount,
 	})
 }
+
+func (this *StockManagerApiController) GetSingleCancelOrder() {
+
+	id, _ := this.GetInt64("id")
+	adminUserInfo := this.GetAdminUserInfo()
+	orgId := adminUserInfo.CurrentOrgId
+	order, _ := service.GetSingleCancelOrder(id, orgId)
+	this.ServeSuccessJSON(map[string]interface{}{
+		"list": order,
+	})
+}

models/drug_stock.go

 	SysRecordTime           int64   `gorm:"column:sys_record_time" json:"sys_record_time" form:"sys_record_time"`
 	RetailPrice             float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
 	RetailTotalPrice        float64 `gorm:"column:retail_total_price" json:"retail_total_price" form:"retail_total_price"`
+	Number                  string  `gorm:"column:number" json:"number" form:"number"`
+	BatchNumber             string  `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
 }
 
 func (DrugWarehouseOutInfo) TableName() string {

models/self_drug_models.go

 	DrugSpec         string  `gorm:"column:drug_spec" json:"drug_spec" form:"drug_spec"`
 	Creater          int64   `gorm:"column:creater" json:"creater" form:"creater"`
 	MinUnit          string  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	MaxUnit          string  `json:"max_unit"`
+	MinNumber        int64   `json:"min_number"`
+	Dose             float64 `json:"dose"`
+	DoseUnit         string  `json:"dose_unit"`
 }
 
 type BloodDrugCancelStockInfo struct {
 	DrugSpec                string  `gorm:"column:drug_spec" json:"drug_spec" form:"drug_spec"`
 	Creater                 int64   `gorm:"column:creater" json:"creater" form:"creater"`
 	MinUnit                 string  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	MaxUnit                 string  `json:"max_unit"`
+	MinNumber               int64   `json:"min_number"`
+	Dose                    float64 `json:"dose"`
+	DoseUnit                string  `json:"dose_unit"`
 }
 
 type XtMonitorConfig struct {
 	Count                   int64   `gorm:"column:count" json:"count" form:"count"`
 	CountUnit               string  `gorm:"column:count_unit" json:"count_unit" form:"count_unit"`
 	Price                   float64 `gorm:"column:price" json:"price" form:"price"`
+	BuyPrice                float64 `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
 	TotalPrice              float64 `gorm:"column:total_price" json:"total_price" form:"total_price"`
 	ProductDate             int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
 	ExpiryDate              int64   `gorm:"column:expiry_date" json:"expiry_date" form:"expiry_date"`
 	DoseUnit                string  `json:"dose_unit"`
 	LastPrice               string  `json:"last_price"`
 	DrugName                string  `json:"drug_name"`
+	Number                  string  `json:"number"`
+	BatchNumber             string  `json:"batch_number"`
 }

models/stock_models.go

 	WarehousingCount  int64       `gorm:"column:warehousing_count" json:"warehousing_count"`
 	WarehousingUnit   string      `gorm:"column:warehousing_unit" json:"warehousing_unit"`
 	Price             float64     `gorm:"column:price" json:"price"`
+	BuyPrice          float64     `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
 	TotalPrice        float64     `gorm:"column:total_price" json:"total_price"`
 	Dealer            int64       `gorm:"column:dealer" json:"dealer"`
 	Manufacturer      int64       `gorm:"column:manufacturer" json:"manufacturer"`
 	SysRecordTime           int64        `gorm:"column:sys_record_time" json:"sys_record_time"`
 	PatientId               int64        `gorm:"column:patient_id" json:"patient_id"`
 	Number                  string       `gorm:"column:number" json:"number" form:"number"`
+	LicenseNumber           string       `gorm:"column:license_number" json:"license_number" form:"license_number"`
 }
 
 func (WarehouseOutInfo) TableName() string {
 	MinUnit                 string  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
 	Number                  string  `gorm:"column:number" json:"number" form:"number"`
 	PackingUnit             string  `gorm:"column:packing_unit" json:"packing_unit" form:"packing_unit"`
+	LicenseNumber           string  `gorm:"column:license_number" json:"license_number" form:"license_number"`
 }
 
 type WarehouseOutInfoTwo struct {

service/gobal_config_service.go

 	}
 
 	if manufacturerId > 0 {
-		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,t.manufacturer,x.remark,x.ctime,x.org_id,x.is_return,x.warehousing_order,x.type,x.retail_price,x.retail_total_price,t.drug_type,t.drug_name,t.drug_spec,t.min_unit,s.creater").Joins("left join xt_base_drug as t on t.id = x.drug_id and t.org_id = ? and t.status =1", orgid).Where("t.manufacturer = ?", manufacturerId).Joins("left join xt_drug_warehouse as s on s.id = x.warehousing_id and s.org_id = ? and s.status =1", orgid).Order("x.ctime desc").Count(&total).Offset(offset).Limit(limit).Scan(&drugInfo).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,t.manufacturer,x.remark,x.ctime,x.org_id,x.is_return,x.warehousing_order,x.type,x.retail_price,x.retail_total_price,t.drug_type,t.drug_name,t.drug_spec,t.min_unit,t.dose,t.dose_unit,t.max_unit,t.min_number,s.creater").Joins("left join xt_base_drug as t on t.id = x.drug_id and t.org_id = ? and t.status =1", orgid).Where("t.manufacturer = ?", manufacturerId).Joins("left join xt_drug_warehouse as s on s.id = x.warehousing_id and s.org_id = ? and s.status =1", orgid).Order("x.ctime desc").Count(&total).Offset(offset).Limit(limit).Scan(&drugInfo).Error
 	} else {
-		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,t.manufacturer,x.remark,x.ctime,x.org_id,x.is_return,x.warehousing_order,x.type,x.retail_price,x.retail_total_price,t.drug_type,t.drug_name,t.drug_spec,t.min_unit,s.creater").Joins("left join xt_base_drug as t on t.id = x.drug_id and t.org_id = ? and t.status =1", orgid).Joins("left join xt_drug_warehouse as s on s.id = x.warehousing_id and s.org_id = ? and s.status =1", orgid).Order("x.ctime desc").Count(&total).Offset(offset).Limit(limit).Scan(&drugInfo).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,t.manufacturer,x.remark,x.ctime,x.org_id,x.is_return,x.warehousing_order,x.type,x.retail_price,x.retail_total_price,t.drug_type,t.drug_name,t.drug_spec,t.min_unit,t.dose,t.dose_unit,t.max_unit,t.min_number,s.creater").Joins("left join xt_base_drug as t on t.id = x.drug_id and t.org_id = ? and t.status =1", orgid).Joins("left join xt_drug_warehouse as s on s.id = x.warehousing_id and s.org_id = ? and s.status =1", orgid).Order("x.ctime desc").Count(&total).Offset(offset).Limit(limit).Scan(&drugInfo).Error
 	}
 
 	return drugInfo, total, err
 	}
 
 	if manufacturerId > 0 {
-		err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.warehousing_out_target,x.count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.remark,x.is_cancel,x.warehouse_out_order_number,x.type,x.dealer,x.manufacturer,x.is_sys,x.sys_record_time,x.retail_price,x.retail_total_price,b.drug_name,b.drug_spec,b.drug_type,b.min_unit,t.creater").Joins("left join xt_base_drug as b on b.id = x.drug_id and b.org_id = ? and b.status =1", orgid).Joins("left join xt_drug_warehouse_out as t on t.id = x.warehouse_out_id and t.org_id = ? and t.status  =1", orgid).Where("t.manufacturer = ?", manufacturerId).Order("x.ctime desc").Count(&total).Offset(offset).Limit(limit).Scan(&outinfo).Error
+		err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.warehousing_out_target,x.count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.remark,x.is_cancel,x.warehouse_out_order_number,x.type,x.dealer,x.manufacturer,x.is_sys,x.sys_record_time,x.retail_price,x.retail_total_price,b.drug_name,b.drug_spec,b.drug_type,b.min_unit,b.max_unit,b.min_number,b.dose,b.dose_unit,t.creater").Joins("left join xt_base_drug as b on b.id = x.drug_id and b.org_id = ? and b.status =1", orgid).Joins("left join xt_drug_warehouse_out as t on t.id = x.warehouse_out_id and t.org_id = ? and t.status  =1", orgid).Where("t.manufacturer = ?", manufacturerId).Order("x.ctime desc").Count(&total).Offset(offset).Limit(limit).Scan(&outinfo).Error
 	} else {
-		err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.warehousing_out_target,x.count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.remark,x.is_cancel,x.warehouse_out_order_number,x.type,x.dealer,x.manufacturer,x.is_sys,x.sys_record_time,x.retail_price,x.retail_total_price,b.drug_name,b.drug_spec,b.drug_type,b.min_unit,t.creater").Joins("left join xt_base_drug as b on b.id = x.drug_id and b.org_id = ? and b.status =1", orgid).Joins("left join xt_drug_warehouse_out as t on t.id = x.warehouse_out_id and t.org_id = ? and t.status  =1", orgid).Order("x.ctime desc").Count(&total).Offset(offset).Limit(limit).Scan(&outinfo).Error
+		err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.warehousing_out_target,x.count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.remark,x.is_cancel,x.warehouse_out_order_number,x.type,x.dealer,x.manufacturer,x.is_sys,x.sys_record_time,x.retail_price,x.retail_total_price,b.drug_name,b.drug_spec,b.drug_type,b.min_unit,b.max_unit,b.min_number,b.dose,b.dose_unit,t.creater").Joins("left join xt_base_drug as b on b.id = x.drug_id and b.org_id = ? and b.status =1", orgid).Joins("left join xt_drug_warehouse_out as t on t.id = x.warehouse_out_id and t.org_id = ? and t.status  =1", orgid).Order("x.ctime desc").Count(&total).Offset(offset).Limit(limit).Scan(&outinfo).Error
 	}
 
 	return outinfo, total, err
 func GetDrugStockFlow(drugid int64, startime int64, endtime int64, page int64, limit int64, orgid int64) (list []*models.StDrugWarehouseInfo, total int64, err error) {
 
 	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
+	table := XTReadDB().Table("xt_base_drug as t").Where("t.status =1 ")
+	fmt.Println(table)
 	offset := (page - 1) * limit
 	if startime > 0 {
 		db = db.Where("x.ctime >=?", startime)
 	return list, total, err
 }
 
-func GetDrugStockOutFlow(drugid int64, startime int64, endtime int64, page int64, limit int64, orgid int64, stocktype int64) (list []*models.XtDrugWarehouseOutInfo, total int64, err error) {
+func GetDrugStockOutFlow(drugid int64, startime int64, endtime int64, page int64, limit int64, orgid int64, stocktype int64) (list []*models.VmDrugWarehouseOutInfo, total int64, err error) {
 
 	db := XTReadDB().Table("xt_drug_warehouse_out_info as x").Where("x.status = 1")
+	table := XTReadDB().Table("xt_base_drug as t").Where("t.status = 1")
+	fmt.Println(table)
 	offset := (page - 1) * limit
 	if startime > 0 {
 		db = db.Where("x.ctime >=?", startime)
 	if stocktype == 2 {
 		db = db.Where("x.is_sys = 1")
 	}
-	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.warehousing_out_target,x.count,x.price,x.total_price,x.product_date,x.expiry_date,x.org_id,x.remark,x.is_cancel,x.warehouse_out_order_number,x.type,x.dealer,x.manufacturer,x.is_sys,x.sys_record_time,x.retail_price,x.retail_total_price,x.warehouse_info_id,x.ctime").Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Scan(&list).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.warehousing_out_target,x.count,x.price,x.total_price,x.product_date,x.expiry_date,x.org_id,x.remark,x.is_cancel,x.warehouse_out_order_number,x.type,x.dealer,x.manufacturer,x.is_sys,x.sys_record_time,x.retail_price,x.retail_total_price,x.warehouse_info_id,x.ctime,t.drug_name,t.drug_type,t.min_number,t.min_unit,t.max_unit").Joins("left join xt_base_drug as t on t.id = x.drug_id").Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Scan(&list).Error
 	return list, total, err
 }
 
 		db = db.Where("x.warehouse_out_id = ?", id)
 	}
 
-	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.remark,x.is_cancel,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.retail_price,x.retail_total_price,t.drug_name,t.drug_type,t.max_unit,t.min_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").Group("x.drug_id").Scan(&info).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.remark,x.is_cancel,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.retail_price,x.retail_total_price,t.drug_name,t.drug_type,t.max_unit,t.min_unit,t.min_number,x.number,x.batch_number,t.dose,t.dose_unit,t.last_price").Joins("left join xt_base_drug as t on t.id = x.drug_id").Group("x.drug_id").Scan(&info).Error
 	return info, err
 }
 

service/stock_service.go

 	if len(warehousingInfo) > 0 {
 		utx := writeDb.Begin()
 		if len(warehousingInfo) > 0 {
-			thisSQL := "INSERT INTO xt_drug_warehouse_info (warehousing_id, drug_id, number, product_date,expiry_date,warehousing_count,price,total_price,dealer,manufacturer,remark,ctime,mtime,status,org_id,warehousing_order,type,retail_price,retail_total_price,stock_max_number,max_unit,min_unit) VALUES "
+			thisSQL := "INSERT INTO xt_drug_warehouse_info (warehousing_id, drug_id, number, product_date,expiry_date,warehousing_count,price,total_price,dealer,manufacturer,remark,ctime,mtime,status,org_id,warehousing_order,type,retail_price,retail_total_price,stock_max_number,max_unit,min_unit,batch_number) VALUES "
 			insertParams := make([]string, 0)
 			insertData := make([]interface{}, 0)
 			for _, info := range warehousingInfo {
-				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
 				insertData = append(insertData, info.WarehousingId)
 				insertData = append(insertData, info.DrugId)
 				insertData = append(insertData, info.Number)
 				insertData = append(insertData, info.StockMaxNumber)
 				insertData = append(insertData, info.MaxUnit)
 				insertData = append(insertData, info.MinUnit)
+				insertData = append(insertData, info.BatchNumber)
 			}
 			thisSQL += strings.Join(insertParams, ", ")
 			err = utx.Exec(thisSQL, insertData...).Error
 	return
 }
 
+func FindAllDrugWarehousingListOne(orgId int64, page int64, limit int64, startTime int64, endTime int64, types int64, keywords string, ids []int64) (list []*VMDrugWarehouse, total int64, err error) {
+	db := readDb.Model(&VMDrugWarehouse{})
+	db = db.Where("xt_drug_warehouse.org_id = ? AND xt_drug_warehouse.status = 1", orgId)
+	db = db.Preload("Manufacturers", "status = 1 AND org_id = ?", orgId)
+	db = db.Preload("Dealers", "status = 1 AND org_id = ?", orgId)
+	if len(keywords) > 0 {
+		likeKey := "%" + keywords + "%"
+		db = db.Joins("join sgj_users.sgj_user_admin_role on sgj_user_admin_role.admin_user_id = xt_drug_warehouse.creater")
+		db = db.Where(" sgj_user_admin_role.user_name LIKE ? OR xt_drug_warehouse.warehousing_order LIKE ?  OR xt_drug_warehouse.id in(?)", likeKey, likeKey, ids).Group("xt_drug_warehouse.id")
+	}
+	if startTime > 0 {
+		db = db.Where("xt_drug_warehouse.operation_time >=?", startTime)
+	}
+	if endTime > 0 {
+		db = db.Where("xt_drug_warehouse.operation_time<= ?", endTime)
+	}
+	db = db.Count(&total)
+	offset := (page - 1) * limit
+	err = db.Offset(offset).Limit(limit).Order("xt_drug_warehouse.ctime desc").Find(&list).Error
+	return
+}
+
 func FindWarehousingInfoById(id int64) (list []*models.WarehousingInfo, err error) {
 	err = readDb.Model(&models.WarehousingInfo{}).Where("warehousing_id = ? AND status = 1", id).Preload("GoodInfo").Find(&list).Error
 	return list, err
 }
 
 func FindCancelStockInfoById(id int64) (list []*models.CancelStockInfo, err error) {
-	err = readDb.Model(&models.CancelStockInfo{}).Where("cancel_stock_id = ? AND status = 1", id).Find(&list).Error
+	err = readDb.Model(&models.CancelStockInfo{}).Where("cancel_stock_id = ? AND status = 1", id).Preload("GoodInfo", "status = 1").Find(&list).Error
 	return list, err
 }
 
 	if len(warehouseOutInfo) > 0 {
 		utx := writeDb.Begin()
 		if len(warehouseOutInfo) > 0 {
-			thisSQL := "INSERT INTO xt_warehouse_out_info (warehouse_out_id, good_id, good_type_id, product_date,expiry_date,count,price,total_price,remark,ctime,status,org_id,warehouse_out_order_number,type,dealer,manufacturer,number) VALUES "
+			thisSQL := "INSERT INTO xt_warehouse_out_info (warehouse_out_id, good_id, good_type_id, product_date,expiry_date,count,price,total_price,remark,ctime,status,org_id,warehouse_out_order_number,type,dealer,manufacturer,number,license_number) VALUES "
 			insertParams := make([]string, 0)
 			insertData := make([]interface{}, 0)
 			for _, info := range warehouseOutInfo {
-				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
 				insertData = append(insertData, info.WarehouseOutId)
 				insertData = append(insertData, info.GoodId)
 				insertData = append(insertData, info.GoodTypeId)
 				insertData = append(insertData, info.Dealer)
 				insertData = append(insertData, info.Manufacturer)
 				insertData = append(insertData, info.Number)
+				insertData = append(insertData, info.LicenseNumber)
 			}
 			thisSQL += strings.Join(insertParams, ", ")
 			err = utx.Exec(thisSQL, insertData...).Error
 	if len(warehouseOutInfo) > 0 {
 		utx := writeDb.Begin()
 		if len(warehouseOutInfo) > 0 {
-			thisSQL := "INSERT INTO xt_drug_warehouse_out_info (warehouse_out_id, drug_id, product_date,expiry_date,count,price,total_price,remark,ctime,status,org_id,warehouse_out_order_number,type,dealer,manufacturer,retail_price,retail_total_price) VALUES "
+			thisSQL := "INSERT INTO xt_drug_warehouse_out_info (warehouse_out_id, drug_id, product_date,expiry_date,count,price,total_price,remark,ctime,status,org_id,warehouse_out_order_number,type,dealer,manufacturer,retail_price,retail_total_price,number,batch_number) VALUES "
 			insertParams := make([]string, 0)
 			insertData := make([]interface{}, 0)
 			for _, info := range warehouseOutInfo {
-				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
 				insertData = append(insertData, info.WarehouseOutId)
 				insertData = append(insertData, info.DrugId)
 				insertData = append(insertData, info.ProductDate)
 				insertData = append(insertData, info.Manufacturer)
 				insertData = append(insertData, info.RetailPrice)
 				insertData = append(insertData, info.RetailTotalPrice)
-
+				insertData = append(insertData, info.Number)
+				insertData = append(insertData, info.BatchNumber)
 			}
 			thisSQL += strings.Join(insertParams, ", ")
 			err = utx.Exec(thisSQL, insertData...).Error
 
 }
 
+func FindAllDrugWarehouseOutListOne(orgId int64, page int64, limit int64, startTime int64, endTime int64, types int64, keywords string, ids []int64) (list []*models.DrugWarehouseOut, total int64, err error) {
+	db := readDb.Model(&models.DrugWarehouseOut{})
+	db = db.Where("xt_drug_warehouse_out.org_id = ? AND xt_drug_warehouse_out.status = 1 ", orgId)
+
+	if len(keywords) > 0 {
+		likeKey := "%" + keywords + "%"
+		db = db.Joins("join sgj_users.sgj_user_admin_role on sgj_user_admin_role.admin_user_id = xt_drug_warehouse_out.creater")
+
+		db = db.Where("sgj_user_admin_role.user_name LIKE ? OR xt_drug_warehouse_out.warehouse_out_order_number LIKE ? or xt_drug_warehouse_out.id in(?) ", likeKey, likeKey, ids).Group("xt_drug_warehouse_out.id")
+	}
+
+	if startTime > 0 {
+		db = db.Where("xt_drug_warehouse_out.ctime >=?", startTime)
+	}
+	if endTime > 0 {
+		db = db.Where("xt_drug_warehouse_out.ctime<= ?", endTime)
+	}
+	db = db.Count(&total)
+	offset := (page - 1) * limit
+	err = db.Offset(offset).Limit(limit).Order("xt_drug_warehouse_out.ctime desc").Find(&list).Error
+	return list, total, err
+
+}
+
 func FindWarehouseOutInfoById(id int64) (list []*models.WarehouseOutInfo, err error) {
 	err = readDb.Model(&models.WarehouseOutInfo{}).Where("warehouse_out_id = ? AND status = 1 AND count <> 0 AND good_id <> 0", id).Preload("GoodInfo", "status = 1").Order("good_type_id desc").Find(&list).Error
 	return list, err
 	SysRecordTime           int64   `gorm:"column:sys_record_time" json:"sys_record_time" form:"sys_record_time"`
 	RetailPrice             float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
 	RetailTotalPrice        float64 `gorm:"column:retail_total_price" json:"retail_total_price" form:"retail_total_price"`
+	Number                  string  `gorm:"column:number" json:"number" form:"number"`
+	BatchNumber             string  `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
 	Drug                    *Drug   `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug"`
 }
 
 }
 
 func FindCancelStockById(id int64, org_id int64) (cancelStock models.CancelStock, err error) {
-	err = readDb.Model(&models.CancelStock{}).Preload("Manufacturers", "status = 1 AND org_id = ?", org_id).Preload("Dealers", "status = 1 AND org_id = ?", org_id).Where("id = ? AND status = 1", id).First(&cancelStock).Error
+	err = readDb.Model(&models.CancelStock{}).Where("id = ? AND status = 1", id).First(&cancelStock).Error
 	return cancelStock, err
 
 }
 	OrgId                   int64            `gorm:"column:org_id" json:"org_id" form:"org_id"`
 	DrugId                  int64            `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
 	Count                   int64            `gorm:"column:count" json:"count" form:"count"`
+	CountUnit               string           `gorm:"column:count_unit" json:"count_unit" form:"count_unit"`
 	Drug                    *Drug            `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug"`
 	Patients                *models.Patients `gorm:"ForeignKey:PatientId;AssociationForeignKey:ID" json:"user"`
 }
 	if good_id > 0 {
 		db = db.Where("x.good_id = ?", good_id)
 	}
-	err = db.Select("x.id,x.warehousing_id,x.good_id,x.good_type_id,x.number,x.product_date,x.expiry_date,x.warehousing_count,x.warehousing_unit,x.stock_count,x.price,x.total_price,x.dealer,t.manufacturer,x.remark,x.ctime,x.is_return,x.warehousing_order,x.type,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.min_unit").Joins("left join xt_good_information as t on t.id = x.good_id").Count(&total).Offset(offset).Limit(limit).Scan(&info).Error
+	err = db.Select("x.id,x.warehousing_id,x.good_id,x.good_type_id,x.number,x.product_date,x.expiry_date,x.warehousing_count,x.warehousing_unit,x.stock_count,x.price,x.total_price,x.dealer,t.manufacturer,x.remark,x.ctime,x.is_return,x.warehousing_order,x.type,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.min_unit,t.buy_price").Joins("left join xt_good_information as t on t.id = x.good_id").Count(&total).Offset(offset).Limit(limit).Scan(&info).Error
 	return info, total, err
 
 }
 	offset := (page - 1) * limit
 
 	db := XTReadDB().Table("xt_warehouse_out_info as x").Where("x.status= 1")
+
 	if startime > 0 {
 		db = db.Where("x.ctime>=?", startime)
 	}
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	}
-	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.number,x.remark,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.good_id").Order("x.ctime desc").Scan(&out).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.number,x.remark,x.license_number,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.good_id").Order("x.ctime desc").Scan(&out).Error
 	return out, err
 }
 
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	}
-	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.number,x.remark,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.good_id").Order("x.ctime desc").Scan(&out).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.number,x.remark,x.license_number,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.good_id").Order("x.ctime desc").Scan(&out).Error
 	return out, err
 }
 
 	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.warehousing_out_target,x.count,x.count_unit,x.price,x.product_date,x.expiry_date,x.number,x.batch_number,t.drug_type,t.max_unit,t.min_unit,t.min_number,t.dose,t.dose_unit,t.last_price,t.drug_name").Joins("left join xt_base_drug as t on t.id =x.drug_id").Scan(&info).Error
 	return info, err
 }
+
+func GetDrugNameByKeyword(keyword string, orgid int64) (basedrug []*models.XtBaseDrug, err error) {
+
+	db := XTReadDB().Table("xt_base_drug as x").Where("x.status = 1")
+	likeKey := "%" + keyword + "%"
+	if len(keyword) > 0 {
+		db = db.Where("x.drug_name like ?", likeKey)
+	}
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	err = db.Find(&basedrug).Error
+
+	return basedrug, err
+
+}
+
+func GetDrugWarehouseOrderDetail(ids []int64, orgid int64, startime int64, endtime int64) (info []*models.XtDrugWarehouseOutInfo, err error) {
+
+	db := XTReadDB().Table("xt_drug_warehouse_out_info as x").Where("x.status = 1")
+
+	if len(ids) > 0 {
+		db = db.Where("x.drug_id in(?)", ids)
+	}
+
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	if startime > 0 {
+		db = db.Where("x.ctime>=?", startime)
+	}
+	if endtime > 0 {
+		db = db.Where("x.ctime<=?", endtime)
+	}
+
+	err = db.Find(&info).Error
+	return info, err
+}
+
+func GetDrugWarehouseOrderDetailTwo(ids []int64, orgid int64, startime int64, endtime int64) (info []*models.XtDrugWarehouseInfo, err error) {
+
+	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
+
+	if len(ids) > 0 {
+		db = db.Where("x.drug_id in(?)", ids)
+	}
+
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	if startime > 0 {
+		db = db.Where("x.ctime>=?", startime)
+	}
+	if endtime > 0 {
+		db = db.Where("x.ctime<=?", endtime)
+	}
+
+	err = db.Find(&info).Error
+	return info, err
+}
+
+func GetDrugTotalCount(drugid int64, orgid int64) (info models.VmDrugWarehouseInfo, err error) {
+
+	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
+	if drugid > 0 {
+		db = db.Where("x.drug_id = ?", drugid)
+	}
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	err = db.Select("x.drug_id,sum(x.stock_max_number) as count").Find(&info).Error
+	return info, err
+}
+
+func GetDrugByGoodId(drugid int64) (models.BaseDrugLib, error) {
+
+	lib := models.BaseDrugLib{}
+	err := XTReadDB().Model(&lib).Where("id = ? and status = 1", drugid).Find(&lib).Error
+	return lib, err
+}
+
+func GetWarehoureOrderInfoList(goodid int64, orgid int64) (info []*models.WarehousingInfo, err error) {
+
+	db := XTReadDB().Table("xt_warehouse_info as x").Where("x.status = 1")
+
+	if goodid > 0 {
+		db = db.Where("x.good_id = ?", goodid)
+	}
+
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+
+	err = db.Select("x.id,x.warehousing_id,x.good_id,x.good_type_id,x.number,x.product_date,x.expiry_date,x.warehousing_count,x.price,x.total_price,x.dealer,x.manufacturer,x.remark,x.is_return,x.warehousing_order,x.warehousing_unit,x.stock_count,x.license_number").Order("x.ctime desc").Find(&info).Error
+	return info, err
+}
+
+func UpdateWarehousingCount(info *models.WarehousingInfo, goodid int64, orgid int64, warehousingId int64) error {
+
+	err := XTWriteDB().Model(&info).Where("good_id = ? and org_id = ? and status =1 and warehousing_id = ?", goodid, orgid, warehousingId).Updates(map[string]interface{}{"stock_cout": info.StockCount}).Error
+	return err
+}
+
+func GetSingleCancelOrder(id int64, orgid int64) (info []*models.CancelStockInfo, err error) {
+
+	err = XTReadDB().Where("cancel_stock_id = ? and status = 1 and org_id = ?", id, orgid).Preload("GoodInfo", "status = 1").Find(&info).Error
+	return info, err
+}
+
+func UpdateCancelOut(list []*models.WarehousingInfo, count int64) {
+
+	//遍历循环入库数据
+	for _, item := range list {
+
+		//计算每个批次剩余库存与入库数据的差 然后和退库数量比较
+		if (item.WarehousingCount - item.StockCount) >= count {
+			//如果差距大于退库数量，则直接把退库数量增加到该批次中
+			info := models.WarehousingInfo{
+				GoodId:        item.GoodId,
+				OrgId:         item.OrgId,
+				WarehousingId: item.WarehousingId,
+				StockCount:    count,
+			}
+			UpdateWarehousingCount(&info, item.GoodId, item.OrgId, item.WarehousingId)
+			break
+		}
+
+		if (item.WarehousingCount - item.StockCount) < count {
+
+			//如果该批次小于退库数量,则先出库该相差数量
+			var countOne = item.WarehousingCount - item.StockCount
+			infoOne := models.WarehousingInfo{
+				GoodId:        item.GoodId,
+				OrgId:         item.OrgId,
+				WarehousingId: item.WarehousingId,
+				StockCount:    countOne,
+			}
+
+			UpdateWarehousingCount(&infoOne, item.GoodId, item.OrgId, item.WarehousingId)
+
+			//剩余的出库到第二个批次
+			var countTwo = count - countOne
+			UpdateCancelOut(list, countTwo)
+		}
+	}
+
+}

service/warhouse_service.go

 
 import (
 	"XT_New/models"
-	"XT_New/models/service"
 	"XT_New/utils"
 	"errors"
 	"fmt"
 	// 如果没有对应的库存，则报错
 
 	warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId)
-	fmt.Println("库存数量", warehouse.StockCount)
+	fmt.Println("库存数量9999343434343434343434343434343434", warehouse.StockCount)
 	if err != nil {
 		return
 	}
 
 		return nil
 	} else {
+		fmt.Println("中国共产党万岁22322332323232322323232323232323")
+		// 当改批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
+		//warehouseOutInfo := &models.WarehouseOutInfo{
+		//  WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+		//  WarehouseOutId:          warehouseOut.ID,
+		//  WarehouseInfotId:        warehouse.ID,
+		//  Status:                  1,
+		//  Ctime:                   time.Now().Unix(),
+		//  Remark:                  goods.Remark,
+		//  OrgId:                   orgID,
+		//  Type:                    1,
+		//  Manufacturer:            goods.Manufacturer,
+		//  Dealer:                  goods.Dealer,
+		//  IsSys:                   0,
+		//  SysRecordTime:           record_time,
+		//  GoodTypeId:              goods.GoodTypeId,
+		//  GoodId:                  goods.GoodId,
+		//  ExpiryDate:              goods.ExpiryDate,
+		//  ProductDate:             goods.ProductDate,
+		//  Number:                  goods.Number,
+		//  Price:                   goods.Price,
+		//  LicenseNumber:           goods.LicenseNumber,
+		//}
+		//warehouseOutInfo.Count = stock_number
+		//stockInInfo, _ :=FindLastStockInInfoRecord(goods.GoodId, orgID)
+		//fmt.Println("stockINFO2232232323223322332323223323223",stockInInfo)
+		//warehouseOutInfo.Price = stockInInfo.Price
+		//
+		//errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
+		//fmt.Println("errOne2232323232323232333232323",errOne)
+		//if errOne != nil {
+		//  return errOne
+		//}
 		// 出库完成后，要将该批次库存清零
 		warehouse.StockCount = 0
 		warehouse.Mtime = time.Now().Unix()
 			ProductDate:             goods.ProductDate,
 			Number:                  goods.Number,
 			Price:                   goods.Price,
+			LicenseNumber:           goods.LicenseNumber,
 		}
 		warehouseOutInfo.Count = goods.Count
 		stockInInfo, _ := FindLastStockInInfoRecord(goods.GoodId, orgID)
 
 		warehouse.StockCount = warehouse.StockCount - maxNumber
 		warehouse.Mtime = time.Now().Unix()
+
 		if warehouse.StockCount < 0 {
-			fmt.Println("进来33232323232232323233232", warehouse.StockCount)
+
 			return errors.New("库存数量不足")
 		}
-		return nil
+		errThree := UpDateWarehouseInfoByStock(&warehouse)
+		if errThree != nil {
+			return errThree
+		}
 	} else {
+		fmt.Println("中国共产党万岁22322332323232322323232323232323")
 		// 当改批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
 		warehouseOutInfo := &models.WarehouseOutInfo{
 			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 			ProductDate:             goods.ProductDate,
 			Number:                  goods.Number,
 			Price:                   goods.Price,
+			LicenseNumber:           goods.LicenseNumber,
 		}
 		warehouseOutInfo.Count = stock_number
-		stockInInfo, _ := service.FindLastStockInInfoRecord(goods.GoodId, orgID)
+		stockInInfo, _ := FindLastStockInInfoRecord(goods.GoodId, orgID)
+		fmt.Println("stockINFO2232232323223322332323223323223", stockInInfo)
 		warehouseOutInfo.Price = stockInInfo.Price
 
-		errOne := service.AddSigleWarehouseOutInfo(warehouseOutInfo)
-
+		errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
+		fmt.Println("errOne2232323232323232333232323", errOne)
 		if errOne != nil {
 			return errOne
 		}
 		}
 		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
 		goods.Count = deliver_number - stock_number
-
+		fmt.Println("goods3333333333333333333333", goods.Count)
 		ConsumablesDeliveryOne(orgID, record_time, goods, warehouseOut, count)
 
 	}