11月8日库存管理

controllers/manager_center_api_controller.go

 	good_kind, _ := c.GetInt64("good_kind")
 	is_mark, _ := c.GetInt64("is_mark")
 	manufacturer, _ := c.GetInt64("manufacturer")
+	is_type, _ := c.GetInt64("is_type")
 	adminUserInfo := c.GetAdminUserInfo()
-	goodInfos, total, err := service.FindGoodInfoList(adminUserInfo.CurrentOrgId, page, limit, keyword, is_use, is_charge, good_kind, is_mark, manufacturer)
+	goodInfos, total, err := service.FindGoodInfoList(adminUserInfo.CurrentOrgId, page, limit, keyword, is_use, is_charge, good_kind, is_mark, manufacturer, is_type)
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{
 			"list":  goodInfos,

models/stock_models.go

 	WarehouseInfoId int64              `gorm:"column:warehouse_info_id" json:"warehouse_info_id" form:"warehouse_info_id"`
 	GoodInfo        GoodInfo           `gorm:"ForeignKey:ID;AssociationForeignKey:GoodId" `
 	WarehousingInfo []*WarehousingInfo `gorm:"ForeignKey:GoodId;AssociationForeignKey:GoodId" json:"xt_warehouse_info"`
+	PatientId       int64              `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	RecordDate      int64              `gorm:"column:record_date" json:"record_date" form:"record_date"`
 }
 
 func (CancelStockInfo) TableName() string {

service/print_data_service/schedule_dialysis/print_schedule_dialysis_models.go

 }
 
 type ScheduleVM struct {
-	ID           int64 `gorm:"column:id" json:"id"`
-	PatientID    int64 `gorm:"column:patient_id" json:"patient_id"`
-	ScheduleDate int64 `gorm:"column:schedule_date" json:"schedule_date"`
-	BedID        int64 `gorm:"column:bed_id" json:"bed_id"`
-	PartitionId  int64 `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
-
+	ID                       int64                            `gorm:"column:id" json:"id"`
+	PatientID                int64                            `gorm:"column:patient_id" json:"patient_id"`
+	ScheduleDate             int64                            `gorm:"column:schedule_date" json:"schedule_date"`
+	BedID                    int64                            `gorm:"column:bed_id" json:"bed_id"`
+	PartitionId              int64                            `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
 	Patient                  *PatientVM                       `gorm:"ForeignKey:PatientID" json:"patient"`
 	DialysisOrder            DialysisOrderVM                  `gorm:"ForeignKey:DialysisDate,PatientID;AssociationForeignKey:ScheduleDate,PatientID" json:"dialysis_order"`
 	Prescription             PrescriptionVM                   `gorm:"ForeignKey:RecordDate,PatientID;AssociationForeignKey:ScheduleDate,PatientID" json:"prescription"`
 	LastAfterWeight          XtAssessmentAfterDislysisVM      `gorm:"ForeignKey:PatientID;AssociationForeignKey:PatientID" json:"lastafterweight"`
 	HisAdvices               []*models.HisDoctorAdviceInfo    `gorm:"ForeignKey:RecordDate,PatientID;AssociationForeignKey:ScheduleDate,PatientID" json:"his_advices"`
 	HisPrescriptionProject   []*models.HisPrescriptionProject `gorm:"ForeignKey:RecordDate,PatientID;AssociationForeignKey:ScheduleDate,PatientID" json:"his_project"`
+	Count                    int
 }
 
 func (ScheduleVM) TableName() string {

service/print_data_service/schedule_dialysis/print_schedule_dialysis_service.go

 	for _, item := range schedules {
 
 		if orgID != 10101 {
-			dialysis_count, _ := GetDialysisOrderCount(orgID, item.PatientID, item.ScheduleDate)
+			dialysis_count, _ := GetDialysisOrderCountOne(orgID, item.PatientID, item.ScheduleDate)
 			item.Patient.TotalDialysis = dialysis_count
 		}
 		if orgID == 10101 {
 	return
 }
 
+//func GetDialysisOrderCount(orgID int64, patient_id int64, recordDate int64)(order []*models.DialysisOrder,err error) {
+// err = p_service.XTReadDB().Where("dialysis_date <= ? AND status = 1 AND user_org_id = ? AND patient_id = ?", recordDate, orgID, patient_id).Find(&order).Error
+// return order,err
+//}
+
 func GetDialysisOrderCountOne(orgID int64, patient_id int64, recordDate int64) (count int64, err error) {
 	err = p_service.XTReadDB().Model(&models.DialysisOrder{}).Where("dialysis_date >=1640966400 and dialysis_date <= ? AND status = 1 AND stage = 2 AND user_org_id = ? AND patient_id = ?", recordDate, orgID, patient_id).Count(&count).Error
 	return

service/stock_service.go

 
 }
 
-func FindGoodInfoList(orgId int64, page int64, limit int64, keyword string, is_use int64, is_charge int64, good_kind int64, is_mark int64, manufacturer int64) (list []*models.GoodInfo, total int64, err error) {
+func FindGoodInfoList(orgId int64, page int64, limit int64, keyword string, is_use int64, is_charge int64, good_kind int64, is_mark int64, manufacturer int64, is_type int64) (list []*models.GoodInfo, total int64, err error) {
 	offset := (page - 1) * limit
 	db := readDb.Model(&models.GoodInfo{})
 	db = db.Where("org_id = ? AND status = 1", orgId)
 		if manufacturer > 0 {
 			db = db.Where("manufacturer = ?", manufacturer)
 		}
+		if is_type > 0 {
+			db = db.Where("good_type_id = ?", is_type)
+		}
 	} else {
 		if is_use > 0 {
 			if is_use == 1 {
 		if manufacturer > 0 {
 			db = db.Where("manufacturer = ?", manufacturer)
 		}
+		if is_type > 0 {
+			db = db.Where("good_type_id = ?", is_type)
+		}
 	}
 
 	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&list).Error
 	return err
 }
 
+func GetWarehosueOutByStockFlow(patient_id int64, recrod_date int64, goodid int64) (stockflow []*models.VmStockFlow, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and system_time = ? and good_id = ? and consumable_type = 3 and status = 1", patient_id, recrod_date, goodid).Find(&stockflow).Error
+	return stockflow, err
+}
+
 func DeleteAutoRedeceDetailTen(orgid int64, patient_id int64, recordtime int64, goodid int64) error {
 
 	detail := models.BloodAutomaticReduceDetail{}
 	err = XTWriteDB().Model(&info).Where("org_id = ? and patient_id = ? and sys_record_time = ? and good_id = ? and status = 1", orgid, patient_id, recordtime, goodid).Updates(map[string]interface{}{"status": 0, "count": 0}).Error
 	prepare := models.DialysisBeforePrepare{}
 	err = XTWriteDB().Model(&prepare).Where("user_org_id = ? and patient_id = ? and record_date = ? and good_id = ? and status = 1", orgid, patient_id, recordtime, goodid).Updates(map[string]interface{}{"status": 0, "count": 0}).Error
+	flow := models.VmStockFlow{}
+	err = XTWriteDB().Model(&flow).Where("user_org_id = ? and patient_id = ? and system_time = ? and good_id = ? and status = 1", orgid, patient_id, recordtime, goodid).Updates(map[string]interface{}{"status": 0, "count": 0}).Error
 	return err
 
 }
 
 func UpDateWarehouseInfoByStockDelete(id int64, count int64) (err error) {
+
 	err = writeDb.Model(&models.WarehousingInfo{}).Where("id = ?", id).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", count)).Error
 	return err
 }
 
+func GetCancelStockInfoByPatientId(patientid int64, goodid int64, record_date int64) (info []*models.CancelStockInfo, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and good_id = ? and record_date = ? and status = 1", patientid, goodid, record_date).Find(&info).Error
+	return info, err
+}
+
+func GetHisPrepscritionByPatientId(patientid int64, goodid int64, record_date int64) (list []*models.HisPrescriptionProject, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and project_id = ? and record_date = ? and status = 1", patientid, goodid, record_date).Find(&list).Error
+	return list, err
+}
+
 func UpDateWarehouStockFlowByStockDelete(id int64, recordtime int64, good_id int64, count int64, patient_id int64) (err error) {
 
 	err = writeDb.Model(&models.VmStockFlow{}).Where("warehousing_id = ? and system_time = ? and good_id = ? and patient_id = ?", id, recordtime, good_id, patient_id).UpdateColumn("count", gorm.Expr("count - ?", count)).Error
 	return &autoreduece, nil
 }
 
-func GetAutoRecordByGoodId(goodid int64, patientid int64, recorddate int64) (models.WarehouseOutInfo, error) {
-	detail := models.WarehouseOutInfo{}
-	err := XTReadDB().Model(&detail).Where("good_id = ? and patient_id = ? and sys_record_time = ? and status = 1", goodid, patientid, recorddate).Find(&detail).Error
+func GetAutoRecordByGoodIdSeven(goodid int64, patientid int64, recorddate int64) (models.WarehouseOutInfoSeven, error) {
+	detail := models.WarehouseOutInfoSeven{}
+	err := XTReadDB().Select("id,count").Where(" good_id = ? and sys_record_time = ?  and patient_id = ?  and status = 1", goodid, recorddate, patientid).Find(&detail).Error
 	return detail, err
 }
 
-func GetAutoRecordByGoodIdSeven(goodid int64, patientid int64, recorddate int64) (models.WarehouseOutInfoSeven, error) {
-	detail := models.WarehouseOutInfoSeven{}
-	err := XTReadDB().Model(&detail).Where("sys_record_time = ? and good_id = ? and patient_id = ?  and status = 1", recorddate, goodid, patientid).Find(&detail).Error
+func GetAutoRecordByGoodIdSevenEight(goodid int64, patientid int64, recorddate int64) (detail []*models.WarehouseOutInfoSeven, err error) {
+	err = XTReadDB().Select("id,count").Where("good_id = ? and sys_record_time = ?  and patient_id = ?  and status = 1", goodid, recorddate, patientid).Find(&detail).Error
 	return detail, err
 }
 
 	return info, err
 }
 
-func GetLastDrugWarehouseOutByDrugId(drugid int64, patient_id int64, advice_date int64) (models.DrugAutomaticReduceDetail, error) {
+func GetLastDrugWarehouseOutByDrugId(drugid int64, patient_id int64, advice_date int64, advice_id int64) (models.DrugAutomaticReduceDetail, error) {
 	detail := models.DrugAutomaticReduceDetail{}
-	err := XTReadDB().Model(&detail).Where("drug_id = ? and patient_id = ? and record_time = ? and status = 1", drugid, patient_id, advice_date).Last(&detail).Error
+	err := XTReadDB().Model(&detail).Where("drug_id = ? and patient_id = ? and record_time = ? and status = 1 and advice_id = ?", drugid, patient_id, advice_date, advice_id).Last(&detail).Error
 	return detail, err
 }
 

service/warhouse_service.go

 
 		maxNumber = deliver_number / drup.MinNumber
 		minNumber = deliver_number % drup.MinNumber
+
 		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
 			minNumber = maxNumber
 		}
 				return errors.New("库存数量不足")
 			}
 		}
-
-		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
+		if minNumber != 0 {
+			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
+		}
 
 		if warehouse.StockMaxNumber < 0 {
 			warehouse.StockMaxNumber = 0
 		}
 
 		warehouse.Mtime = time.Now().Unix()
+		fmt.Println("w23332233232232332", warehouse.StockMinNumber, minNumber)
 
 		if warehouse.StockMinNumber < minNumber {
+			fmt.Println("进来的风3232332322323")
 			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
 			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
 		} else {
+			fmt.Println("进3232332322323")
 			warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
 		}
 
+		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
+			fmt.Println("2223232332322323", warehouse.StockMinNumber)
+			warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
+
+		}
+
 		if drup.MaxUnit != drup.MinUnit {
 			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
 				return errors.New("库存数量不足")
 			}
 		}
+		if warehouse.StockMinNumber <= 0 {
+			warehouse.StockMinNumber = 0
+		}
 
 		//扣减库存232332332332
 		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
 //耗材出库
 func ConsumablesDelivery(orgID int64, patient_id int64, record_time int64, goods *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut, count int64) (err error) {
 
+	fmt.Println("count23323223233232323232332232323", count, goods.Count)
 	var deliver_number int64 = 0
 	var stock_number int64 = 0
 	var maxNumber int64 = 0
 			PatientId:               advice.PatientId,
 			Count:                   deliver_number, //出最小单位
 			WarehouseInfoId:         warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 
 		drugflow := models.DrugFlow{
 			IsSys:                   1,
 			PatientId:               advice.PatientId,
 			WarehousingDetailId:     warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 
 		CreateDrugFlowOne(drugflow)
 			PatientId:               advice.PatientId,
 			Count:                   deliver_number,
 			WarehouseInfoId:         warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
 		if errOne != nil {
 			IsSys:                   1,
 			PatientId:               advice.PatientId,
 			WarehousingDetailId:     warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 
 		CreateDrugFlowOne(drugflow)
 			PatientId:               advice.PatientId,
 			WarehouseInfoId:         warehouse.ID,
 			Count:                   deliver_number,
+			AdviceId:                advice.ID,
 		}
 
 		drugflow := models.DrugFlow{
 			PatientId:               advice.PatientId,
 			SystemTime:              advice.RecordDate,
 			WarehousingDetailId:     warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 
 		CreateDrugFlowOne(drugflow)
 			Count:                   deliver_number,
 			CountUnit:               drup.MinUnit,
 			WarehouseInfoId:         warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
 		if errTwo != nil {
 		if warehouse.StockMaxNumber < 0 {
 			return errors.New("库存数量不足")
 		}
+		if warehouse.StockMinNumber <= 0 {
+			warehouse.StockMinNumber = 0
+		}
 
 		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
 
 			WarehouseInfoId:         warehouse.ID,
 			Count:                   deliver_number,
 			CountUnit:               drup.MinUnit,
+			AdviceId:                advice.ID,
 		}
 
 		drugflow := models.DrugFlow{
 			PatientId:               advice.PatientId,
 			SystemTime:              advice.RecordDate,
 			WarehousingDetailId:     warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 
 		CreateDrugFlowOne(drugflow)
 			Count:                   deliver_number,
 			CountUnit:               drup.MinUnit,
 			WarehouseInfoId:         warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
 		if errTwo != nil {