耗材参数

controllers/drug_stock_api_contorller.go

 	}
 	timeStr := time.Now().Format("2006-01-02")
 	timeArr := strings.Split(timeStr, "-")
-	total, _ := service.FindAllWarehouseTotal(adminUserInfo.CurrentOrgId)
+	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)
+	fmt.Println("r入库单据好  2323232322223", warehousing_order)
 	operation_time := time.Now().Unix()
 	creater := adminUserInfo.AdminUser.Id
 	warehousing := models.DrugWarehouse{
 	}
 
 	var cancelStockInfos []*models.DrugCancelStockInfo
+	var drugFlow []*models.DrugFlow
 
 	if dataBody["cancelStock"] != nil && reflect.TypeOf(dataBody["cancelStock"]).String() == "[]interface {}" {
 		thisStockIn, _ := dataBody["cancelStock"].([]interface{})
 
 				batch_number := items["batch_number"].(string)
 				max_unit := items["max_unit"].(string)
+				batch_number_id := int64(items["batch_number_id"].(float64))
 				cancelStockInfo := &models.DrugCancelStockInfo{
 					OrderNumber:      cancelStock.OrderNumber,
 					CancelStockId:    cancelStock.ID,
 					MaxUnit:          max_unit,
 					ProductDate:      productDates,
 					ExpiryDate:       expiryDates,
+					BatchNumberId:    batch_number_id,
 				}
 				cancelStockInfos = append(cancelStockInfos, cancelStockInfo)
 
+				flow := &models.DrugFlow{
+					WarehousingId:           0,
+					DrugId:                  drug_id,
+					Number:                  "",
+					BatchNumber:             batch_number,
+					Count:                   count,
+					UserOrgId:               adminUserInfo.CurrentOrgId,
+					PatientId:               0,
+					SystemTime:              ctime,
+					ConsumableType:          4,
+					IsSys:                   0,
+					WarehousingOrder:        "",
+					WarehouseOutId:          0,
+					WarehouseOutOrderNumber: "",
+					IsEdit:                  0,
+					CancelStockId:           cancelStock.ID,
+					CancelOrderNumber:       cancelStock.OrderNumber,
+					Manufacturer:            0,
+					Dealer:                  0,
+					Creator:                 adminUserInfo.AdminUser.Id,
+					UpdateCreator:           0,
+					Status:                  1,
+					Ctime:                   time.Now().Unix(),
+					Mtime:                   0,
+					Price:                   price,
+					WarehousingDetailId:     0,
+					WarehouseOutDetailId:    0,
+					CancelOutDetailId:       0,
+					ExpireDate:              expiryDates,
+					ProductDate:             productDates,
+					MaxUnit:                 max_unit,
+					MinUnit:                 "",
+				}
+				drugFlow = append(drugFlow, flow)
 			}
 		}
 	}
-	errs := service.CreateDrugCancelStockInfo(cancelStockInfos)
-	if errs != nil {
-		utils.ErrorLog(errs.Error())
-		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
-		return
-	}
+	//扣减库存逻辑
+	for _, item := range cancelStockInfos {
+		medical, _ := service.GetBaseDrugMedical(item.DrugId)
+		//查询当前药品退库的批次号的总入库数
+		infoWareInfo, _ := service.GetDrugWarehouseInfo(item.BatchNumberId)
+		fmt.Println("hhh2h3h2hh3233", item.MaxUnit, medical.MaxUnit)
+		var total_count int64
+		if item.MaxUnit == medical.MaxUnit {
+			total_count = infoWareInfo.WarehousingCount
+			fmt.Println("进来了吗发大发阿道夫阿方阿道夫撒发大发阿方阿方阿方阿道夫阿方暗示法", total_count)
+		}
+		//转化为最小库存
+		if item.MaxUnit == medical.MinUnit {
+			total_count = infoWareInfo.WarehousingCount * medical.MinNumber
+		}
+		fmt.Println("itme.count2323232323232323232332", item.Count)
+		fmt.Println("23232322322323232332", total_count)
+		//判断退库数量是否大于总入库数量
+		if item.Count > total_count {
+			c.ServeSuccessJSON(map[string]interface{}{
+				"msg": "2",
+			})
+			return
+		}
+		//正常退库
+		if item.Count <= infoWareInfo.WarehousingCount {
+			//创建退库详情
+			errs := service.CreateDrugCancelStockInfo(cancelStockInfos)
+			//创建库存明细
+			service.CreateDrugFlow(drugFlow)
 
-	c.ServeSuccessJSON(map[string]interface{}{
-		"msg": "退库成功",
-	})
+			var total int64
+			//退库到当前批次,获取当前退库批次的库存
+			info, _ := service.GetDrugWarehouseInfoById(item.BatchNumberId)
+
+			if info.MaxUnit == item.MaxUnit {
+				total = item.Count + info.StockMaxNumber
+
+				warehouseInfo := models.XtDrugWarehouseInfo{
+					StockMaxNumber: total,
+				}
+				errs = service.UpdateDrugWarehouseInfo(&warehouseInfo, item.BatchNumberId)
+				if errs != nil {
+					utils.ErrorLog(errs.Error())
+					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
+					return
+				}
+
+				c.ServeSuccessJSON(map[string]interface{}{
+					"msg": "1",
+				})
+			}
+			if medical.MinUnit == item.MaxUnit {
+				total = item.Count + info.StockMinNumber
+				warehouseInfo := models.XtDrugWarehouseInfo{
+					StockMinNumber: total,
+				}
+
+				errs = service.UpdateDrugWarehouseInfoOne(&warehouseInfo, item.BatchNumberId)
+				if errs != nil {
+					utils.ErrorLog(errs.Error())
+					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
+					return
+				}
 
+				c.ServeSuccessJSON(map[string]interface{}{
+					"msg": "1",
+				})
+			}
+		}
+	}
 }
 func (c *StockDrugApiController) GetDrugCancelStockInfoList() {
 	id, _ := c.GetInt64("id", 0)

controllers/gobal_config_api_controller.go

 	outCountList, _ := service.GetOutDrugCountList(startTime, endTime, orgId)
 	auCountList, err := service.GetAutoDrugCountList(startTime, endTime, orgId)
 	info, _ := service.GetDrugWarehouOrderInfo(startTime, endTime, orgId)
+	cancelCountList, _ := service.GetCancelDrugCountList(startTime, endTime, orgId)
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
 		return
 	}
 	c.ServeSuccessJSON(map[string]interface{}{
-		"countList":    list,
-		"outCountList": outCountList,
-		"auCountList":  auCountList,
-		"minCount":     countList,
-		"info":         info,
+		"countList":       list,
+		"outCountList":    outCountList,
+		"auCountList":     auCountList,
+		"minCount":        countList,
+		"info":            info,
+		"cancelCountList": cancelCountList,
 	})
 }
 

controllers/stock_in_api_controller.go

 
 				dealer, _ := items["dealer"].(string)
 
-				//productDate, _ := items["product_date"].(string)
-				//product_date, _ := utils.ParseTimeStringToTime("2006-01-02", productDate)
-				//
-				//expiryDate, _ := items["expiry_date"].(string)
-				//expiry_date, _ := utils.ParseTimeStringToTime("2006-01-02", expiryDate)
 				var expiryDates int64
 				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
 					expiryDates = 0
 		//调用退库的方法
 		parseDateErr := service.UpdateCancelOut(list, item.Count)
 		fmt.Println("999999999999", parseDateErr)
+		if parseDateErr != nil {
+			utils.ErrorLog(parseDateErr.Error())
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
+			return
+		}
 	}
 
 	if errs != nil {

models/drug_stock.go

 	BatchNumber      string      `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
 	MaxUnit          string      `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
 	BaseDrugLib      BaseDrugLib `gorm:"ForeignKey:ID;AssociationForeignKey:DrugId" `
+	BatchNumberId    int64       `gorm:"column:batch_number_id" json:"batch_number_id" form:"batch_number_id"`
 }
 
 func (DrugCancelStockInfo) TableName() string {
 	WarehouseOutOrderNumber string  `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number" form:"warehouse_out_order_number"`
 	IsEdit                  int64   `gorm:"column:is_edit" json:"is_edit" form:"is_edit"`
 	CancelStockId           int64   `gorm:"column:cancel_stock_id" json:"cancel_stock_id" form:"cancel_stock_id"`
-	CancelOrderNumber       int64   `gorm:"column:cancel_order_number" json:"cancel_order_number" form:"cancel_order_number"`
+	CancelOrderNumber       string  `gorm:"column:cancel_order_number" json:"cancel_order_number" form:"cancel_order_number"`
 	Manufacturer            int64   `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
 	Dealer                  int64   `gorm:"column:dealer" json:"dealer" form:"dealer"`
 	Creator                 int64   `gorm:"column:creator" json:"creator" form:"creator"`

models/good_models.go

 }
 
 type XtCancelStockInfo struct {
-	ID            int64       `gorm:"column:id" json:"id"`
-	GoodId        int64       `gorm:"column:good_id" json:"good_id"`
-	CancelStockId int64       `gorm:"column:cancel_stock_id" json:"cancel_stock_id"`
-	GoodTypeId    int64       `gorm:"column:good_type_id" json:"good_type_id"`
-	Count         int64       `gorm:"column:count" json:"count"`
-	Price         float64     `gorm:"column:price" json:"price"`
-	Total         float64     `gorm:"column:total" json:"total"`
-	ProductDate   int64       `gorm:"column:product_date" json:"product_date"`
-	ExpiryDate    int64       `gorm:"column:expiry_date" json:"expiry_date"`
-	Ctime         int64       `gorm:"column:ctime" json:"ctime"`
-	Mtime         int64       `gorm:"column:mtime" json:"mtime"`
-	Status        int64       `gorm:"column:status" json:"status"`
-	OrgId         int64       `gorm:"column:org_id" json:"org_id"`
-	OrderNumber   string      `gorm:"column:order_number" json:"order_number"`
-	Type          int64       `gorm:"column:type" json:"type"`
-	CancelStock   CancelStock `ForeignKey:CancelStockId json:"CancelStock"`
-	Dealer        int64       `gorm:"column:dealer" json:"dealer"`
-	Manufacturer  int64       `gorm:"column:manufacturer" json:"manufacturer"`
+	ID              int64    `gorm:"column:id" json:"id"`
+	GoodId          int64    `gorm:"column:good_id" json:"good_id"`
+	CancelStockId   int64    `gorm:"column:cancel_stock_id" json:"cancel_stock_id"`
+	GoodTypeId      int64    `gorm:"column:good_type_id" json:"good_type_id"`
+	Count           int64    `gorm:"column:count" json:"count"`
+	Price           float64  `gorm:"column:price" json:"price"`
+	Total           float64  `gorm:"column:total" json:"total"`
+	ProductDate     int64    `gorm:"column:product_date" json:"product_date"`
+	ExpiryDate      int64    `gorm:"column:expiry_date" json:"expiry_date"`
+	Ctime           int64    `gorm:"column:ctime" json:"ctime"`
+	Mtime           int64    `gorm:"column:mtime" json:"mtime"`
+	Status          int64    `gorm:"column:status" json:"status"`
+	OrgId           int64    `gorm:"column:org_id" json:"org_id"`
+	OrderNumber     string   `gorm:"column:order_number" json:"order_number"`
+	Type            int64    `gorm:"column:type" json:"type"`
+	Dealer          string   `gorm:"column:dealer" json:"dealer"`
+	Manufacturer    string   `gorm:"column:manufacturer" json:"manufacturer"`
+	GoodInfo        GoodInfo `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"GoodInfo"`
+	Number          string   `gorm:"column:number" json:"number" form:"number"`
+	RegisterAccount string   `gorm:"column:register_account" json:"register_account" form:"register_account"`
+	Remark          string   `gorm:"column:remark" json:"remark" form:"remark"`
 }
 
 func (XtCancelStockInfo) TableName() string {

models/self_drug_models.go

 	LmtUsedFlag            int64   `gorm:"column:lmt_used_flag" json:"lmt_used_flag" form:"lmt_used_flag"`
 	Total                  float64 `gorm:"column:total" json:"total" form:"total"`
 	PrescribingNumberUnit  string  `gorm:"column:prescribing_number_unit" json:"prescribing_number_unit" form:"prescribing_number_unit"`
+	MinNumber              int64   `gorm:"column:min_number" json:"min_number" form:"min_number"`
 }
 
 func (XtBaseDrug) TableName() string {
 	StockMaxNumber   int64   `gorm:"column:stock_max_number" json:"stock_max_number"`
 	StockMinNumber   int64   `gorm:"column:stock_min_number" json:"stock_min_number"`
 	BatchNumber      string  `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
+	MaxUnit          string  `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
 }
 
 func (XtDrugWarehouseInfo) TableName() string {

models/stock_models.go

 }
 
 type CancelStock struct {
-	ID              int64  `gorm:"column:id" json:"id"`
-	OrderNumber     string `gorm:"column:order_number" json:"order_number"`
-	OperaTime       int64  `gorm:"column:opera_time" json:"opera_time"`
-	Total           int64  `gorm:"column:total" json:"total"`
-	Creater         int64  `gorm:"column:creater" json:"creater"`
-	Ctime           int64  `gorm:"column:ctime" json:"ctime"`
-	Mtime           int64  `gorm:"column:mtime" json:"mtime"`
-	Status          int64  `gorm:"column:status" json:"status"`
-	OrgId           int64  `gorm:"column:org_id" json:"org_id"`
-	ReturnTime      int64  `gorm:"column:return_time" json:"return_time"`
-	Dealer          int64  `gorm:"column:dealer" json:"dealer"`
-	Manufacturer    int64  `gorm:"column:manufacturer" json:"manufacturer"`
-	Type            int64  `gorm:"column:type" json:"type"`
-	CancelStockInfo []*XtCancelStockInfo
+	ID                int64                `gorm:"column:id" json:"id"`
+	OrderNumber       string               `gorm:"column:order_number" json:"order_number"`
+	OperaTime         int64                `gorm:"column:opera_time" json:"opera_time"`
+	Total             int64                `gorm:"column:total" json:"total"`
+	Creater           int64                `gorm:"column:creater" json:"creater"`
+	Ctime             int64                `gorm:"column:ctime" json:"ctime"`
+	Mtime             int64                `gorm:"column:mtime" json:"mtime"`
+	Status            int64                `gorm:"column:status" json:"status"`
+	OrgId             int64                `gorm:"column:org_id" json:"org_id"`
+	ReturnTime        int64                `gorm:"column:return_time" json:"return_time"`
+	Dealer            int64                `gorm:"column:dealer" json:"dealer"`
+	Manufacturer      int64                `gorm:"column:manufacturer" json:"manufacturer"`
+	Type              int64                `gorm:"column:type" json:"type"`
+	XtCancelStockInfo []*XtCancelStockInfo `gorm:"ForeignKey:CancelStockId;AssociationForeignKey:ID" json:"XtCancelStockInfo"`
 }
 
 func (CancelStock) TableName() string {

service/gobal_config_service.go

 
 }
 
+func GetCancelDrugCountList(startime int64, endtime int64, orgid int64) (info []*models.XtCancelStockInfo, err error) {
+
+	db := XTReadDB().Table(" xt_drug_cancel_stock_info as x").Where("x.status = 1")
+
+	if startime > 0 {
+		db = db.Where("x.ctime >=?", startime)
+	}
+	if endtime > 0 {
+		db = db.Where("x.ctime<=?", endtime)
+	}
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	err = db.Select("sum(x.count) as count,x.drug_id").Group("x.drug_id").Scan(&info).Error
+	return info, err
+}
+
 func GetSingleOrderDetail(id int64, orgid int64) (info []*models.VmDrugWarehouseOutInfo, err error) {
 
 	db := XTReadDB().Table("xt_drug_warehouse_out_info as x").Where("x.status = 1")

service/stock_service.go

 	err = readDb.Model(&models.Warehousing{}).Where("org_id = ?", org_id).Count(&total).Error
 	return total, err
 }
+
+func FindAllWarehouseTotalOne(org_id int64) (total int64, err error) {
+	err = readDb.Model(&models.XtDrugWarehouse{}).Where("org_id = ?", org_id).Count(&total).Error
+	return total, err
+}
 func AddSigleWarehouse(warehouse *models.Warehousing) error {
 	err := writeDb.Create(&warehouse).Error
 	return err
 	if len(drugflow) > 0 {
 		utx := writeDb.Begin()
 		if len(drugflow) > 0 {
-			thisSQL := "INSERT INTO xt_drug_flow (warehousing_id, drug_id, number,batch_number,count,user_org_id,patient_id,system_time,consumable_type,is_sys,warehousing_order,warehouse_out_id,warehouse_out_order_number,is_edit,cancel_stock_id,cancel_order_number,manufacturer,dealer,creator,update_creator,status,ctime,mtime,price,warehousing_detail_id,warehouse_out_detail_id,cancel_out_detail_id,expire_date,product_date,max_unit,min_unit ) VALUES "
+			thisSQL := "INSERT INTO xt_drug_flow (warehousing_id, drug_id, number,batch_number,count,user_org_id,patient_id,system_time,consumable_type,is_sys,warehousing_order,warehouse_out_id,warehouse_out_order_number,is_edit,cancel_stock_id,cancel_order_number,manufacturer,dealer,creator,update_creator,status,ctime,mtime,price,warehousing_detail_id,warehouse_out_detail_id,cancel_out_detail_id,expire_date,product_date,max_unit,min_unit) VALUES "
 			insertParams := make([]string, 0)
 			insertData := make([]interface{}, 0)
 			for _, info := range drugflow {
 	if len(cancelStockInfo) > 0 {
 		utx := writeDb.Begin()
 		if len(cancelStockInfo) > 0 {
-			thisSQL := "INSERT INTO xt_drug_cancel_stock_info (drug_id,cancel_stock_id, count, price,total,ctime,status,org_id,order_number,type,dealer,manufacturer,retail_price,retail_total_price,register_account,batch_number,remark,max_unit,product_date,expiry_date) VALUES "
+			thisSQL := "INSERT INTO xt_drug_cancel_stock_info (drug_id,cancel_stock_id, count, price,total,ctime,status,org_id,order_number,type,dealer,manufacturer,retail_price,retail_total_price,register_account,batch_number,remark,max_unit,product_date,expiry_date,batch_number_id) VALUES "
 			insertParams := make([]string, 0)
 			insertData := make([]interface{}, 0)
 			for _, info := range cancelStockInfo {
-				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
 				insertData = append(insertData, info.DrugId)
 				insertData = append(insertData, info.CancelStockId)
 				insertData = append(insertData, info.Count)
 				insertData = append(insertData, info.MaxUnit)
 				insertData = append(insertData, info.ProductDate)
 				insertData = append(insertData, info.ExpiryDate)
+				insertData = append(insertData, info.BatchNumberId)
 			}
 			thisSQL += strings.Join(insertParams, ", ")
 			err = utx.Exec(thisSQL, insertData...).Error
 
 	if len(idstr) > 0 {
 		err = XTReadDB().Model(&info).Where("id in(?)", idstr).
-			Preload("CancelStockInfo", func(db *gorm.DB) *gorm.DB {
+			Preload("XtCancelStockInfo", func(db *gorm.DB) *gorm.DB {
 				return XTReadDB().Where("org_id=? and status = 1", orgid).Preload("GoodInfo", "status = 1 and org_id = ?", orgid)
 			}).Find(&info).Error
 	}
 	err = db.Find(&info).Error
 	return info, err
 }
+
+func GetDrugWarehouseInfo(id int64) (models.XtDrugWarehouseInfo, error) {
+
+	info := models.XtDrugWarehouseInfo{}
+
+	db := XTReadDB().Model(&info).Where("status = 1")
+	if id > 0 {
+		db = db.Where("id = ?", id)
+	}
+	err := db.Select("drug_id,warehousing_count").Find(&info).Error
+
+	return info, err
+}
+
+func GetDrugWarehouseInfoById(id int64) (models.XtDrugWarehouseInfo, error) {
+
+	info := models.XtDrugWarehouseInfo{}
+	err := XTReadDB().Model(&info).Where("id=? and status =1", id).Find(&info).Error
+	return info, err
+}
+
+func UpdateDrugWarehouseInfo(info *models.XtDrugWarehouseInfo, id int64) error {
+
+	err := XTWriteDB().Model(&info).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"stock_max_number": info.StockMaxNumber}).Error
+	return err
+}
+
+func UpdateDrugWarehouseInfoOne(info *models.XtDrugWarehouseInfo, id int64) error {
+
+	err := XTWriteDB().Model(&info).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"stock_min_number": info.StockMaxNumber}).Error
+	return err
+}

service/warhouse_service.go

 	warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId)
 	fmt.Println("err222222222222222222222", warehouse.StockCount)
 	if err != nil {
-		fmt.Println("232323232323进来")
+
 		return err
 	}
 
 			UserOrgId:               goods.OrgId,
 			PatientId:               goods.PatientId,
 			SystemTime:              record_time,
-			ConsumableType:          3,
+			ConsumableType:          2,
 			IsSys:                   goods.IsSys,
 			WarehousingOrder:        "",
 			WarehouseOutId:          warehouseOut.ID,
 			UserOrgId:               goods.OrgId,
 			PatientId:               0,
 			SystemTime:              record_time,
-			ConsumableType:          3,
+			ConsumableType:          2,
 			IsSys:                   0,
 			WarehousingOrder:        "",
 			WarehouseOutId:          warehouseOut.ID,