11月9日库存管理

models/dialysis.go

 	MonitoringTime              string  `gorm:"column:monitoring_time" json:"monitoring_time"`
 	PulseFrequency              float64 `gorm:"column:pulse_frequency" json:"pulse_frequency"`
 	BreathingRate               string  `gorm:"column:breathing_rate" json:"breathing_rate"`
+	BreathingRate               string  `gorm:"column:breathing_rate" json:"breathing_rate"`
 	SystolicBloodPressure       float64 `gorm:"column:systolic_blood_pressure" json:"systolic_blood_pressure"`
 	DiastolicBloodPressure      float64 `gorm:"column:diastolic_blood_pressure" json:"diastolic_blood_pressure"`
 	BloodPressureType           int64   `gorm:"column:blood_pressure_type" json:"blood_pressure_type"`

service/dialysis_service.go

 func FindDoctorAdviceOrderById(orgID int64, patientsId int64, recordDate int64) (patient []*models.DoctorAdvice, err error) {
 	err = readDb.Model(&models.DoctorAdvice{}).
 		Where("patient_id = ? and user_org_id=? and status=1 and advice_date = ? and advice_type = 2", patientsId, orgID, recordDate).
+		Where("patient_id = ? and user_org_id=? and status=1 and record_date = ? and （advice_type = 2 or advice_type = 3)", patientsId, orgID, recordDate).
 		Select("id, user_org_id, patient_id, advice_type, advice_date, record_date, start_time, advice_name,advice_desc, reminder_date, drug_spec, drug_spec_unit, single_dose, single_dose_unit, prescribing_number, prescribing_number_unit, delivery_way, execution_frequency, advice_doctor, status, created_time,updated_time, advice_affirm, remark, stop_time, stop_reason, stop_doctor, stop_state, parent_id, execution_time, execution_staff, execution_state, checker, check_state, check_time, groupno, IF(parent_id > 0, parent_id, id) as advice_order").Order("start_time asc, groupno desc, advice_order desc, id asc").
 		Find(&patient).Error
 	return

service/dialysis_solution_service.go

+package service
+
+import (
+	"XT_New/models"
+	"fmt"
+)
+
+func GetPatientSolutionGroupList(patient_id int64, orgid int64) (solution []*models.DialysisSolution, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and status = 1 and user_org_id = ?", patient_id, orgid).Group("mode_id").Find(&solution).Error
+
+	return solution, err
+}
+
+func GetNewPatientSolutionByModeId(patient_id int64, mode_id int64, orgid int64) (models.DialysisSolution, error) {
+
+	solution := models.DialysisSolution{}
+	err := XTReadDB().Where("patient_id = ? and mode_id = ? and user_org_id = ? and status = 1", patient_id, mode_id, orgid).Order("updated_time desc").First(&solution).Error
+	return solution, err
+}
+
+func UpdateDialysisSolutionStatus(id int64, mode_id int64, orgid int64, patient_id int64) error {
+
+	err := XTWriteDB().Model(&models.DialysisSolution{}).Where("id = ? and status = 1 and user_org_id = ?", id, orgid).Update(map[string]interface{}{"solution_status": 1}).Error
+
+	err = XTWriteDB().Model(&models.DialysisSolution{}).Where("id <> ? and mode_id = ? and user_org_id = ? and status = 1 and patient_id = ?", id, mode_id, orgid, patient_id).Update(map[string]interface{}{"solution_status": 2}).Error
+	return err
+}
+
+func UpdateDialysisSolutionStatusTwo(id int64, mode_id int64, orgid int64, patient_id int64) error {
+
+	err = XTWriteDB().Model(&models.DialysisSolution{}).Where("id <> ? and mode_id = ? and user_org_id = ? and status = 1 and patient_id = ?", id, mode_id, orgid, patient_id).Update(map[string]interface{}{"solution_status": 2}).Error
+	return err
+}
+
+func GetLastPatientDialysisSolution(patient_id int64, orgid int64) (models.DialysisSolution, error) {
+
+	solution := models.DialysisSolution{}
+	err := XTReadDB().Where("patient_id = ? and user_org_id = ? and status = 1", patient_id, orgid).Last(&solution).Error
+	return solution, err
+}
+
+func GetPatientDialysisSolutionGroupList(keywords string, limit int64, page int64, partition_id int64, schedule_type int64, scheduleDate int64, orgID int64) (schedule []*models.VmBloodSchedule, total int64, err error) {
+
+	db := XTReadDB().Model(&models.VmBloodSchedule{}).Where("status = 1")
+	offset := (page - 1) * limit
+	if scheduleDate > 0 {
+		db = db.Where("schedule_date = ?", scheduleDate)
+	}
+	if schedule_type > 0 {
+		db = db.Where("schedule_type = ?", schedule_type)
+	}
+	if partition_id > 0 {
+		db = db.Where("partition_id = ?", partition_id)
+	}
+	if orgID > 0 {
+		db = db.Where("user_org_id  = ?", orgID)
+	}
+
+	if len(keywords) > 0 {
+		keywords = "%" + keywords + "%"
+		db = db.Joins("JOIN xt_patients AS patient ON patient.id=xt_schedule.patient_id AND patient.status = 1 AND patient.user_org_id = ? AND patient.name Like ?", orgID, keywords)
+		err = db.Count(&total).Offset(offset).Limit(limit).Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+			Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
+			Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).
+			Preload("DialysisSolution", "status = 1 AND user_org_id = ? and solution_status = 1", orgID).Find(&schedule).Error
+	} else {
+		err = db.Count(&total).Offset(offset).Limit(limit).Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+			Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
+			Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).
+			Preload("DialysisSolution", "status = 1 AND user_org_id = ? and solution_status = 1", orgID).Find(&schedule).Error
+	}
+	fmt.Println("err2332232323233223232332", err)
+	fmt.Println("total99999999999999999999", total)
+	fmt.Println("scheudle23323233232", schedule)
+	return schedule, total, err
+}

service/gobal_config_service.go

 	return list, total, err
 }
 
-func GetBatchOrderDetail(drugid int64, orgid int64, page int64, limit int64) (drug []*models.DrugWarehouseInfo, total int64, err error) {
+func GetBatchOrderDetail(drugid int64, orgid int64, page int64, limit int64, startime int64, endtime int64, start_first_time int64, end_first_time int64) (drug []*models.DrugWarehouseInfo, total int64, err error) {
 	offset := (page - 1) * limit
-	err = XTReadDB().Model(&drug).Where("drug_id = ? and org_id = ? and status = 1 and is_check = 1", drugid, orgid).Count(&total).Offset(offset).Limit(limit).Order("id desc").Find(&drug).Error
+	db := XTReadDB().Model(&drug).Where("status = 1 and is_check = 1")
+	if drugid > 0 {
+		db = db.Where("drug_id = ?", drugid)
+	}
+	if orgid > 0 {
+		db = db.Where("org_id = ?", orgid)
+	}
+	if startime > 0 {
+		db = db.Where("ctime >=?", startime)
+	}
+	if endtime > 0 {
+		db = db.Where("ctime <=?", endtime)
+	}
+	if start_first_time > 0 {
+		db = db.Where("expiry_date >=?", start_first_time)
+	}
+	if end_first_time > 0 {
+		db = db.Where("expiry_date <=?", end_first_time)
+	}
+	err = db.Count(&total).Offset(offset).Limit(limit).Order("id desc").Find(&drug).Error
 	return drug, total, err
 }
 
 		db = db.Where("x.org_id = ?", orgid)
 	}
 	if id > 0 {
-		db = db.Where("x.warehouse_out_id = ?", id)
+		db = db.Where("x.warehouse_out_id in(?)", id)
 	}
 
 	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,sum(x.count) as count,x.count_unit,x.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 as total_price,x.retail_total_price,x.storehouse_id,x.stock_count,t.drug_name,t.drug_type,t.max_unit,t.min_unit,t.min_number,x.number,x.batch_number,x.admin_user_id,t.dose,t.dose_unit,t.last_price,t.min_price,t.medical_insurance_number,t.retail_price ,x.warehouse_info_id").Joins("left join xt_base_drug as t on t.id = x.drug_id").Group("x.drug_id").Scan(&info).Error
 	return info, err
 }
 
+func GetDrugWarehouseOutDetailSeventy(id int64, org_id int64) (info []*models.DrugWarehouseOutInfo, err error) {
+
+	err = XTReadDB().Where("warehouse_out_id in(?) and org_id = ? and status =1", id, org_id).Find(&info).Error
+	return info, err
+}
+
 func GetDrugStockFlowDetail(record_time int64, orgid int64) (drugflow []*models.XtDrugAutomaticReduceDetail, err error) {
 
 	err = XTReadDB().Where("record_time = ? and org_id = ? and status = 1", record_time, orgid).Preload("XtBaseDrug", "status = 1").Find(&drugflow).Error
 		db = db.Where("x.warehouse_out_id in(?)", id)
 	}
 
-	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.count,x.count_unit,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.retail_price,x.number,x.batch_number,t.dose,t.dose_unit,t.last_price,t.min_price").Joins("left join xt_base_drug as t on t.id = x.drug_id").Scan(&outInfo).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.count,x.count_unit,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,x.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.retail_price,x.number,x.batch_number,t.dose,t.dose_unit,t.last_price,t.min_price").Joins("left join xt_base_drug as t on t.id = x.drug_id").Scan(&outInfo).Error
 	return outInfo, err
 }
 
 	return outInfo, err
 }
 
+func GetDrugFlowList(id int64, orgid int64) (stockflow []*models.DrugFlow, err error) {
+
+	err = XTReadDB().Where("warehouse_out_id in(?) and user_org_id = ? and status = 1", id, orgid).Preload("BaseDrugLib", "org_id = ? and status = 1", orgid).Preload("DrugWarehouseInfoOne", "org_id = ? and status = 1", orgid).Find(&stockflow).Error
+	return stockflow, err
+}
+
+func GetDrugFlowListGroupById(id int64, orgid int64) (drugFlow []*models.DrugFlow, err error) {
+
+	err = XTReadDB().Where("warehouse_out_id in(?) and user_org_id = ? and status = 1", id, orgid).Group("warehousing_detail_id").Find(&drugFlow).Error
+	return drugFlow, err
+}
+
+func GetDrugFlowListGroupByIdOne(id int64, orgid int64) (drugFlow []*models.DrugFlow, err error) {
+
+	err = XTReadDB().Where("warehouse_out_id in(?) and user_org_id = ? and status = 1", id, orgid).Group("batch_number").Find(&drugFlow).Error
+	return drugFlow, err
+}
+
 func FindDrugStockUserDetailByIdThree(id int64, record_time int64, org_id int64) (user []*DrugAutomaticReduceDetail, err error, total int64) {
 
 	db := readDb.Model(&user)

service/manage_center_service.go

 	storeHouseConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)
 	//退库
 	drug, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)
-	fmt.Println("list223323232233223322323323223", len(list))
 
 	//如果剩余数量 + 退库数量 < 总入库数量
 	if len(list) > 0 {
 				sum_count = druginfo.WarehousingCount
 			}
 
-			fmt.Println("该批次剩余库存", over_count)
-			fmt.Println("该批次退库数量", out_count)
-			fmt.Println("该批次总入库数量", sum_count)
 			if (over_count + out_count) <= sum_count {
 				if its.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
 					fmt.Println("进来1", its.Count)
 						StockMinNumber: its.Count,
 					}
 					UpdateDrugWarehouse(its.WarehouseInfoId, warehouseInfo)
+
+					//增加退库数量
+					AddCancelSumCountOne(storeHouseConfig.DrugStorehouseOut, advice.DrugId, advice.UserOrgId, its.Count)
+					//出库数量减少
+					UpdateSumOutDrug(advice.UserOrgId, storeHouseConfig.DrugStorehouseOut, advice.DrugId, its.Count)
+
 				}
 				if its.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
 					fmt.Println("进来2", its.Count)
 						StockMaxNumber: its.Count,
 					}
 					UpdateDrugWarehouseOne(its.WarehouseInfoId, warehouseInfo)
+
+					//增加退库数量
+					AddCancelSumCountOne(storeHouseConfig.DrugStorehouseOut, advice.DrugId, advice.UserOrgId, its.Count*drug.MinNumber)
+					//出库数量减少
+					UpdateSumOutDrug(advice.UserOrgId, storeHouseConfig.DrugStorehouseOut, advice.DrugId, its.Count*drug.MinNumber)
 				}
 
 				if its.CountUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
 						StockMaxNumber: its.Count,
 					}
 					UpdateDrugWarehouseOne(its.WarehouseInfoId, warehouseInfo)
+					//增加退库数量
+					AddCancelSumCountOne(storeHouseConfig.DrugStorehouseOut, advice.DrugId, advice.UserOrgId, its.Count*drug.MinNumber)
+					//出库数量减少
+					UpdateSumOutDrug(advice.UserOrgId, storeHouseConfig.DrugStorehouseOut, advice.DrugId, its.Count*drug.MinNumber)
 				}
 
 			}
 			}
 
 			flow := models.DrugFlow{
-				WarehousingId:           0,
+				WarehousingId:           info.WarehouseInfoId,
 				DrugId:                  info.DrugId,
 				Number:                  "",
 				BatchNumber:             info.BatchNumber,
 				Ctime:                   time.Now().Unix(),
 				Mtime:                   0,
 				Price:                   info.Price,
-				WarehousingDetailId:     0,
+				WarehousingDetailId:     info.WarehouseInfoId,
 				WarehouseOutDetailId:    0,
 				CancelOutDetailId:       0,
 				ExpireDate:              info.ExpiryDate,
 			}
 
 			flow := models.DrugFlow{
-				WarehousingId:           0,
+				WarehousingId:           info.WarehouseInfoId,
 				DrugId:                  info.DrugId,
 				Number:                  "",
 				BatchNumber:             info.BatchNumber,
 				Ctime:                   time.Now().Unix(),
 				Mtime:                   0,
 				Price:                   info.Price,
-				WarehousingDetailId:     0,
+				WarehousingDetailId:     info.WarehouseInfoId,
 				WarehouseOutDetailId:    0,
 				CancelOutDetailId:       0,
 				ExpireDate:              info.ExpiryDate,
 			}
 
 			flow := models.DrugFlow{
-				WarehousingId:           0,
+				WarehousingId:           info.WarehouseInfoId,
 				DrugId:                  info.DrugId,
 				Number:                  "",
 				BatchNumber:             info.BatchNumber,
 				Ctime:                   time.Now().Unix(),
 				Mtime:                   0,
 				Price:                   info.Price,
-				WarehousingDetailId:     0,
+				WarehousingDetailId:     info.WarehouseInfoId,
 				WarehouseOutDetailId:    0,
 				CancelOutDetailId:       0,
 				ExpireDate:              info.ExpiryDate,
 			sum_count_one += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
 		}
 		UpdateBaseDrugSumTwo(advice.DrugId, sum_count_one, advice.UserOrgId)
+
+		//更新库存
+		UpdateSumDrug(advice.UserOrgId, storeHouseConfig.DrugStorehouseOut, advice.DrugId, sum_count_one)
+
 	}
 	return err
 }

service/mobile_dialysis_service.go

 	fmt.Println("key23233232323323wi", key)
 	doctor_advices_str, _ := redis.Get(key).Result()
 	redis.Set(doctor_advices_str, "", time.Second)
+	redis.Set(doctor_advices_str, "", time.Second)
 	if len(doctor_advices_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
 
 		err := readDb.Model(&models.DoctorAdvice{}).
 	DialysisBeforePrepare     []*DialysisBeforePrepare         `gorm:"ForeignKey:PatientId,ScheduleDate;AssociationForeignKey:PatientId,RecordDate" json:"good_user_detail"`
 	LastDialysisBeforePrepare []*DialysisBeforePrepare         `gorm:"-" json:"last_good_user_detail"`
 	Project                   []*models.HisPrescriptionProject `gorm:"-" json:"project"`
+	//WarehouseOutInfo          []*models.WarehouseOutInfoSeven   `gorm:"ForeignKey:PatientId,ScheduleDate;AssociationForeignKey:PatientId,SysRecordTime" json:"ware_house_out_info"`
 }
 
 func (MDialysisGoodsVM) TableName() string {
 	if patient_id != 0 {
 		db = db.Where("patient_id = ?", patient_id)
 	}
-	//db = db.Count(&total)
-	//offset := (page - 1) * limit
-	//
-	//db = db.Offset(offset).Limit(limit)
+
 	err := db.Find(&vms).Error
 
 	return vms, err, total
 	return
 }
 
+func GetAllWarehouseOutSumList(patient_id int64, orgID int64, record_time int64) (info []*models.WarehouseOutInfoSeven, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and org_id = ? and sys_record_time = ? and status = 1", patient_id, orgID, record_time).Find(&info).Error
+	return info, err
+}
+
 func MobileGetGoodsStatistics(orgID int64, start_time int64, end_time int64) (list []*models.StockInfo, err error) {
 	db := readDb.Model(&models.StockInfo{})
 	db = db.Where("xt_good_information.org_id = ? AND xt_good_information.status = 1", orgID)
 	his_doctor_advice_str, _ := redis.Get(key).Result()
 	redis.Set(key, "", time.Second)
 	if len(his_doctor_advice_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
-		err = readDb.Model(&models.HisDoctorAdviceInfo{}).Where("patient_id = ? AND user_org_id = ? AND status=1 AND record_date = ?", patientid, orgid, recorddate).Find(&his).Error
+		err = readDb.Model(&models.HisDoctorAdviceInfo{}).Where("patient_id = ? AND user_org_id = ? AND status=1 AND record_date = ?", patientid, orgid, recorddate).Order("created_time asc").Find(&his).Error
 		if err != nil {
 			if err == gorm.ErrRecordNotFound {
 				if len(his) <= 0 {
 	err = readDb.Where("org_id = ? and status = 1 and record_time >= ?", orgID, scheduleDate).Group("patient_id").Find(&auto).Error
 	return auto, err
 }
+
+func GetGoodWarehouseOutInfo(orgId int64, patient_id int64, sys_record_time int64) (outifno []*models.WarehouseOutInfoSeven, err error) {
+
+	err = readDb.Where("org_id = ? and patient_id = ? and sys_record_time = ? and status = 1", orgId, patient_id, sys_record_time).Find(&outifno).Error
+	return outifno, err
+}

service/new_stock_service.go

+package service
+
+import (
+	"XT_New/models"
+	"github.com/jinzhu/gorm"
+)
+
+func GetGoodStockCount(user_org_id int64, storehouse_id int64, good_id int64) (*models.XtGoodStockCount, error) {
+
+	goodStock := models.XtGoodStockCount{}
+	var err error
+	err = XTReadDB().Where("user_org_id = ? and storehouse_id = ? and good_id = ?", user_org_id, storehouse_id, good_id).Find(&goodStock).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &goodStock, nil
+}
+
+func CreateGoodCount(good models.XtGoodStockCount) error {
+
+	db := writeDb.Begin()
+	err := db.Create(&good).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func UpdateGoodStockCount(user_org_id int64, storehouse_id int64, good_id int64, count int64, flush_count int64) error {
+
+	db := writeDb.Begin()
+	err = db.Model(&models.XtGoodStockCount{}).Where("user_org_id = ? and storehouse_id  = ? and good_id  = ? and status = 1", user_org_id, storehouse_id, good_id).UpdateColumn("stock_in_count", gorm.Expr("stock_in_count + ?", count)).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	err = db.Model(&models.XtGoodStockCount{}).Where("user_org_id = ? and storehouse_id = ? and good_id = ? and status = 1", user_org_id, storehouse_id, good_id).Update(map[string]interface{}{"flush_count": flush_count}).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func UpdateGoodInCount(count int64, user_org_id int64, good_id int64, storehouse_id int64, flush_count int64) error {
+	db := writeDb.Begin()
+	err := db.Model(&models.XtGoodStockCount{}).Where("user_org_id = ? and good_id  = ? and storehouse_id = ? and status = 1", user_org_id, good_id, storehouse_id).UpdateColumn("stock_in_count", gorm.Expr("stock_in_count - ?", count)).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	err = db.Model(&models.XtGoodStockCount{}).Where("user_org_id = ? and good_id = ? and storehouse_id = ? and status = 1", user_org_id, good_id, storehouse_id).Update(map[string]interface{}{"flush_count": flush_count}).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func CreateGoodErrcode(errcode models.XtGoodErrcode) error {
+
+	db := writeDb.Begin()
+	err := db.Create(&errcode).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func GetGoodStockList(orgId int64, storehouse_id int64, good_type int64, keyword string, page int64, limit int64, ids []int64) (good []*models.GoodInformation, total int64, err error) {
+	offset := (page - 1) * limit
+	likeKey := "%" + keyword + "%"
+
+	db := XTReadDB().Table("xt_good_information as x").Where("x.status = 1 and x.total_count > 0 and x.org_id =?", orgId)
+
+	if good_type == 2 {
+		db = db.Where(" x.total_count<=x.stock_warn_count")
+	}
+
+	if len(keyword) > 0 {
+		db = db.Where("good_name like ? or manufacturer in(?)", likeKey, ids)
+	}
+
+	db = db.Preload("XtGoodStockCount", func(db *gorm.DB) *gorm.DB {
+		if storehouse_id > 0 {
+			db = db.Where("storehouse_id = ?", storehouse_id)
+		}
+		return db.Where("status = 1 and user_org_id = ?", orgId)
+	})
+
+	db = db.Preload("GoodStockCount", func(db *gorm.DB) *gorm.DB {
+		if storehouse_id > 0 {
+			db = db.Where("storehouse_id = ?", storehouse_id)
+		}
+		return db.Where("status = 1 and user_org_id = ?", orgId).Group("good_id,storehouse_id")
+	})
+
+	db = db.Preload("WarehousingInfo", func(db *gorm.DB) *gorm.DB {
+		if storehouse_id > 0 {
+			db = db.Where("storehouse_id = ?", storehouse_id)
+		}
+		return db.Where("status = 1 and org_id = ? and is_check = 1", orgId)
+	})
+
+	err = db.Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Find(&good).Error
+
+	return good, total, err
+}
+
+func GetSumGoodList(orgid int64, storehouse_id int64, good_id int64) (info []*models.WarehousingInfo, err error) {
+
+	err = XTReadDB().Where("org_id = ? and storehouse_id = ? and good_id = ? and status =1  and is_check = 1", orgid, storehouse_id, good_id).Find(&info).Error
+	return info, err
+}
+
+func UpdateSumGood(orgid int64, storehouse_id int64, good_id int64, flush_count int64) error {
+	db := writeDb.Begin()
+	err := db.Model(&models.XtGoodStockCount{}).Where("user_org_id = ? and storehouse_id = ? and good_id = ? and status = 1", orgid, storehouse_id, good_id).Update(map[string]interface{}{"flush_count": flush_count}).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func UpdateSumCount(user_org_id int64, storehouse_id int64, good_id int64, count int64) error {
+	ut := XTWriteDB().Begin()
+
+	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_out_count", gorm.Expr("stock_out_count - ?", count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
+	return err
+}
+
+func GetSendGoodInformation(org_id int64) (info []*models.WarehousingInfo, err error) {
+
+	err = XTReadDB().Where("org_id = ? and is_check = 1 and status = 1", org_id).Find(&info).Error
+	return info, err
+}
+
+func GetStockFlush(storehouse_id int64, good_id int64, orgid int64) (*models.XtGoodStockCount, error) {
+
+	stockCount := models.XtGoodStockCount{}
+	var err error
+	err = XTReadDB().Where("storehouse_id  =? and good_id = ? and user_org_id = ?", storehouse_id, good_id, orgid).Find(&stockCount).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &stockCount, nil
+}
+
+func CreateGoodCountSix(good models.XtGoodStockCount) error {
+
+	err := XTWriteDB().Create(&good).Error
+	return err
+}
+
+func UpdateGoodCount(warehousingCount int64, stock_count int64, out_count int64, storehouse_id int64, good_id int64, orgid int64, cancel_count int64, act_count int64) error {
+
+	err := XTWriteDB().Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and good_id = ? and status =1 and user_org_id = ?", storehouse_id, good_id, orgid).UpdateColumn("stock_in_count", gorm.Expr("stock_in_count+?", warehousingCount)).Error
+	err = XTWriteDB().Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and good_id = ? and status =1 and user_org_id = ?", storehouse_id, good_id, orgid).Update(map[string]interface{}{"stock_out_count": out_count}).Error
+	err = XTWriteDB().Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and good_id = ? and status =1 and user_org_id = ?", storehouse_id, good_id, orgid).UpdateColumn("flush_count", gorm.Expr("flush_count + ?", stock_count)).Error
+	err = XTWriteDB().Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and good_id = ? and status =1 and user_org_id = ?", storehouse_id, good_id, orgid).Update(map[string]interface{}{"stock_cancel_count": cancel_count}).Error
+	err = XTWriteDB().Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and good_id = ? and status =1 and user_org_id = ?", storehouse_id, good_id, orgid).Update(map[string]interface{}{"stock_act_out_count": act_count}).Error
+	return err
+}
+
+func GetAllCancelCount(storehouse_id int64, good_id int64, org_id int64) (flow []*models.VmStockFlow, err error) {
+
+	err = XTReadDB().Where("storehouse_id = ? and good_id = ? and user_org_id = ? and (consumable_type = 4 or consumable_type= 7) and status = 1", storehouse_id, good_id, org_id).Find(&flow).Error
+	return flow, err
+}
+
+func GetAllStockOutCount(storehouse_id int64, good_id int64, org_id int64) (flow []*models.VmStockFlow, err error) {
+
+	err = XTReadDB().Where("storehouse_id = ? and good_id = ? and user_org_id = ? and (consumable_type = 2 or consumable_type= 3) and is_read = 0", storehouse_id, good_id, org_id).Find(&flow).Error
+	return flow, err
+}
+
+func GetActStockOutCount(storehouse_id int64, good_id int64, org_id int64) (flow []*models.VmStockFlow, err error) {
+	err = XTReadDB().Where("storehouse_id = ? and good_id = ? and user_org_id = ? and (consumable_type = 2 or consumable_type= 3) and status = 1", storehouse_id, good_id, org_id).Find(&flow).Error
+	return flow, err
+}
+
+func GetDrugStockCount(storehouse_id int64, drug_id int64, org_id int64) (*models.XtDrugStockCount, error) {
+	drugStockCount := models.XtDrugStockCount{}
+	var err error
+	err = XTReadDB().Where("storehouse_id = ? and drug_id = ? and user_org_id  = ? and status = 1", storehouse_id, drug_id, org_id).Find(&drugStockCount).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &drugStockCount, nil
+}
+
+func CreateDrugStockSum(drug models.XtDrugStockCount) error {
+
+	ut := XTWriteDB().Begin()
+	err := ut.Create(&drug).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
+	return err
+}
+
+func AddDrugStockSum(storehouse_id int64, drug_id int64, user_org_id int64, waresing_count int64, over_count int64) error {
+
+	db := writeDb.Begin()
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id  = ? and drug_id  = ? and status = 1", user_org_id, storehouse_id, drug_id).UpdateColumn("sum_in_count", gorm.Expr("sum_in_count + ?", waresing_count)).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id = ? and drug_id = ? and status = 1", user_org_id, storehouse_id, drug_id).Update(map[string]interface{}{"flush_count": over_count}).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func UpdateDrugStockSum(storehouse_id int64, drug_id int64, user_org_id int64, waresing_count int64, over_count int64) error {
+	db := writeDb.Begin()
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id  = ? and drug_id  = ? and status = 1", user_org_id, storehouse_id, drug_id).Update(map[string]interface{}{"sum_in_count": waresing_count}).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id = ? and drug_id = ? and status = 1", user_org_id, storehouse_id, drug_id).Update(map[string]interface{}{"flush_count": over_count}).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func ReduceDrugStockCount(storehouse_id int64, drug_id int64, user_org_id int64, waresing_count int64, over_count int64) error {
+	db := writeDb.Begin()
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id  = ? and drug_id = ? and status = 1", user_org_id, storehouse_id, drug_id).UpdateColumn("sum_in_count", gorm.Expr("sum_in_count - ?", waresing_count)).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id = ? and drug_id = ? and status = 1", user_org_id, storehouse_id, drug_id).Update(map[string]interface{}{"flush_count": over_count}).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func AddCancelSumCount(storehouse_id int64, drug_id int64, user_org_id int64, cancel_count int64, over_count int64) error {
+
+	db := writeDb.Begin()
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id  = ? and drug_id = ? and status = 1", user_org_id, storehouse_id, drug_id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count + ?", cancel_count)).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id = ? and drug_id = ? and status = 1", user_org_id, storehouse_id, drug_id).Update(map[string]interface{}{"flush_count": over_count}).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func AddCancelSumCountOne(storehouse_id int64, drug_id int64, user_org_id int64, cancel_count int64) error {
+
+	db := writeDb.Begin()
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id  = ? and drug_id = ? and status = 1", user_org_id, storehouse_id, drug_id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count + ?", cancel_count)).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func ReduceCancelSumCount(storehouse_id int64, drug_id int64, user_org_id int64, cancel_count int64, over_count int64) error {
+	db := writeDb.Begin()
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id  = ? and drug_id = ? and status = 1", user_org_id, storehouse_id, drug_id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count - ?", cancel_count)).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	err = db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id = ? and drug_id = ? and status = 1", user_org_id, storehouse_id, drug_id).Update(map[string]interface{}{"flush_count": over_count}).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func UpdateSumDrug(orgid int64, storehouse_id int64, drug_id int64, flush_count int64) error {
+	db := writeDb.Begin()
+	err := db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id = ? and drug_id = ? and status = 1", orgid, storehouse_id, drug_id).Update(map[string]interface{}{"flush_count": flush_count}).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}
+
+func UpdateSumOutDrug(orgid int64, storehouse_id int64, drug_id int64, sum_out_count int64) error {
+	db := writeDb.Begin()
+	err := db.Model(&models.XtDrugStockCount{}).Where("user_org_id = ? and storehouse_id = ? and drug_id = ? and status = 1", orgid, storehouse_id, drug_id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count - ?", sum_out_count)).Error
+	if err != nil {
+		db.Rollback()
+		return err
+	}
+	db.Commit()
+	return err
+}

service/patient_service.go

 	err = XTReadDB().Where("user_org_id = ? and record_date = ? and status = 1", orgid, recorddate).Find(&project).Error
 	return project, err
 }
+
+func GetPatientDialysisLongSolution(patient_id int64, page int64, limit int64, orgid int64) (solution []*models.DialysisSolution, total int64, err error) {
+
+	db := XTReadDB().Model(&solution).Where("status = 1 and solution_status = 1")
+	if patient_id > 0 {
+		db = db.Where("patient_id = ?", patient_id)
+	}
+	if orgid > 0 {
+		db = db.Where("user_org_id = ?", orgid)
+	}
+	offset := (page - 1) * limit
+
+	err = db.Group("mode_id").Count(&total).Offset(offset).Limit(limit).Order("created_time desc").Find(&solution).Error
+	return solution, total, err
+}
+
+func GetDialysisSolutionDetailList(orgid int64, patient_id int64, mode_id int64, page int64, limit int64) (solution []*models.DialysisSolution, total int64, err error) {
+	offset := (page - 1) * limit
+	db := XTReadDB().Model(&solution).Where("status = 1")
+	if orgid > 0 {
+		db = db.Where("user_org_id = ?", orgid)
+	}
+	if patient_id > 0 {
+		db = db.Where("patient_id = ?", patient_id)
+	}
+	if mode_id > 0 {
+		db = db.Where("mode_id = ?", mode_id)
+	}
+	err = db.Count(&total).Offset(offset).Limit(limit).Find(&solution).Order("created_time desc").Error
+	return solution, total, err
+}

service/stock_service.go

 }
 
 func CreateDrugFlowOne(flow models.DrugFlow) error {
-
-	err := XTWriteDB().Create(&flow).Error
+	ut := writeDb.Begin()
+	err := ut.Create(&flow).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
 }
 
 
 func UpdateDrugFlowTens(patientid int64, warehouse_out_number string, drug_id int64, advice_id int64) (models.DrugFlow, error) {
 	flow := models.DrugFlow{}
-	err := XTWriteDB().Model(&flow).Where("patient_id =? and warehouse_out_order_number = ? and drug_id = ? and status = 1 and advice_id =?", patientid, warehouse_out_number, drug_id, advice_id).Updates(map[string]interface{}{"status": 0}).Error
+	err := XTWriteDB().Model(&flow).Where("patient_id =? and warehouse_out_order_number = ? and drug_id = ? and status = 1 and advice_id =?", patientid, warehouse_out_number, drug_id, advice_id).Updates(map[string]interface{}{"is_read": 1}).Error
 	return flow, err
 }
 
 
 func UpdateAutoMaticReduceDetail(goodid int64, goodtypeid int64, recordtime int64, patientid int64, orgid int64, prepare *models.WarehouseOutInfo) error {
 
-	err := XTWriteDB().Model(&prepare).Where("good_id = ? and good_type_id = ? and sys_record_time = ? and patient_id = ? and org_id = ? and status =1", goodid, goodtypeid, recordtime, patientid, orgid).Updates(map[string]interface{}{"count": prepare.Count}).Error
+	err := XTWriteDB().Model(&prepare).Where("good_id = ? and good_type_id = ? and sys_record_time = ? and patient_id = ? and org_id = ? and status =1", goodid, goodtypeid, recordtime, patientid, orgid).Updates(map[string]interface{}{"count": prepare.Count, "over_count": prepare.OverCount}).Error
 	return err
 }
 
 	return &autoreduece, nil
 }
 
+func GetAutoMaticReduceDetailTwenty(orgid int64, patient_id int64, recordtime int64, goodid int64, goodtypeid int64) (models.BloodAutomaticReduceDetail, error) {
+	auto := models.BloodAutomaticReduceDetail{}
+	err = XTReadDB().Model(&auto).Where("org_id = ? and patient_id = ?  and status = 1 and record_time = ? and good_id = ? and good_type_id = ? and count>0", orgid, patient_id, recordtime, goodid, goodtypeid).Find(&auto).Error
+	return auto, err
+}
+
 func DeleteAutoRedeceDetailTwo(orgid int64, patient_id int64, recordtime int64, goodid int64, goodtypeid int64) error {
 
 	detail := models.BloodAutomaticReduceDetail{}
 	return stockflow, err
 }
 
+func UpdateAutoGood(orgid int64, patient_id int64, recordtime int64, goodid int64, project_id int64, count int64) (err error) {
+
+	err = XTWriteDB().Model(models.BloodAutomaticReduceDetail{}).Where("org_id = ? and patient_id = ? and record_time = ? and status =1 and good_id = ?", orgid, patient_id, recordtime, goodid).UpdateColumn("count", gorm.Expr("count - ?", count)).Error
+	err = XTWriteDB().Model(models.WarehouseOutInfo{}).Where("org_id = ? and patient_id = ? and sys_record_time = ? and good_id = ? and status = 1", orgid, patient_id, recordtime, goodid).UpdateColumn("count", gorm.Expr("count - ?", count)).Error
+	//err = XTWriteDB().Model(models.WarehouseOutInfo{}).Where("org_id = ? and patient_id = ? and sys_record_time = ? and good_id = ? and status = 1", orgid, patient_id, recordtime, goodid).UpdateColumn("over_count", gorm.Expr("over_count + ?", count)).Error
+	err = XTWriteDB().Model(&models.DialysisBeforePrepare{}).Where("org_id = ? and patient_id = ? and sys_record_time = ? and good_id = ? and status = 1", orgid, patient_id, recordtime, goodid).UpdateColumn("count", gorm.Expr("count - ?", count)).Error
+	err = XTWriteDB().Model(&models.VmStockFlow{}).Where("org_id = ? and patient_id = ? and sys_record_time = ? and good_id = ? and status = 1 and project_id = ?", orgid, patient_id, recordtime, goodid, project_id).UpdateColumn("count", gorm.Expr("count - ?", count)).Error
+	return err
+}
+
 func DeleteAutoRedeceDetailTen(orgid int64, patient_id int64, recordtime int64, goodid int64) error {
 
 	detail := models.BloodAutomaticReduceDetail{}
 	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
+	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{}{"is_read": 1}).Error
 	return err
 
 }
 
-func UpDateWarehouseInfoByStockDelete(id int64, count int64) (err error) {
+func UpDateWarehouseInfoByStockDelete(id int64, count int64, patient_id int64, record_time int64, goodid int64) (err error) {
 
 	err = writeDb.Model(&models.WarehousingInfo{}).Where("id = ?", id).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", count)).Error
+	err = writeDb.Model(&models.VmStockFlow{}).Where("warehousing_id = ? and patient_id = ? and system_time = ? and good_id = ? and status = 1", id, patient_id, record_time, goodid).UpdateColumn("over_count", gorm.Expr("over_count + ?", count)).Error
 	return err
 }
 
 
 func GetAllAutoRecordByPatient(patientid int64, recorddate int64) (auto []*models.WarehouseOutInfoNight, err error) {
 
-	err = XTReadDB().Select("count,warehouse_info_id,good_id,org_id").Where(" patient_id = ? and sys_record_time = ?  and status = 1 and is_sys = 1 and count>0", patientid, recorddate).Find(&auto).Error
+	err = XTReadDB().Select("count,warehouse_info_id,good_id,org_id,sys_record_time,patient_id,project_id,warehouse_info_id,warehouse_out_order_number,storehouse_id,price,dealer,manufacturer,good_type_id,product_date,expiry_date,number,license_number").Where(" patient_id = ? and sys_record_time = ?  and status = 1 and is_sys = 1 and count>0", patientid, recorddate).Find(&auto).Error
 	return auto, err
 
 }
 
-//func GetAllAutoRecordByPatient(patientid int64, recorddate int64) (auto []*models.VmStockFlow, err error) {
-//
-//	err = XTReadDB().Select("count,warehousing_id").Where(" patient_id = ? and system_time = ?  and status = 1 and is_sys = 1 and count>0",patientid,recorddate).Find(&auto).Error
-//	return auto, err
-//
-//}
-
 func ModefyWarehouseInfo(count int64, id int64) error {
 
 	err := XTWriteDB().Model(models.WarehousingInfo{}).Where(" id =? and status = 1", id).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", count)).Error
 
 	err := XTWriteDB().Model(models.AutomaticReduceDetail{}).Where("patient_id = ? and record_time = ? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"status": 0}).Error
 	err = XTWriteDB().Model(models.DialysisBeforePrepare{}).Where("patient_id = ? and record_date = ? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"status": 0}).Error
-	err = XTWriteDB().Model(models.VmStockFlow{}).Where("patient_id = ? and system_time = ? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"status": 0}).Error
-	err = XTWriteDB().Model(models.WarehouseOutInfoNight{}).Where("patient_id = ? and sys_record_time = ? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"status": 0}).Error
-	fmt.Println("err2332332322323322323232323232332", err)
+	err = XTWriteDB().Model(models.VmStockFlow{}).Where("patient_id = ? and system_time = ? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"is_read": 1}).Error
+	//err = XTWriteDB().Model(models.WarehouseOutInfoNight{}).Where("patient_id = ? and sys_record_time = ? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"status": 0}).Error
+
 	return err
 }
 
 	return info, total, err
 }
 
-func GetStockListById(good_id int64, orgid int64, limit int64, page int64, startime int64, endtime int64) (info []*models.VmWarehousingInfo, total int64, err error) {
+func GetStockListById(good_id int64, orgid int64, limit int64, page int64, startime int64, endtime int64, startfirsttime int64, endfirsttime int64) (info []*models.VmWarehousingInfo, total int64, err error) {
 
 	offset := (page - 1) * limit
 	db := XTReadDB().Table("xt_warehouse_info as x").Where("x.status= 1 and x.is_check = 1")
 	if endtime > 0 {
 		db = db.Where("x.ctime<=?", endtime)
 	}
+	if startfirsttime > 0 {
+		db = db.Where("x.expiry_date >=?", startfirsttime)
+	}
+	if endfirsttime > 0 {
+		db = db.Where("x.expiry_date <=?", endfirsttime)
+	}
 
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	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,x.packing_price,t.manufacturer,x.remark,x.ctime,x.is_return,x.warehousing_order,x.type,x.storehouse_id,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.min_unit,t.buy_price,f.batch_number_count").Joins("left join xt_good_information as t on t.id = x.good_id").Joins("left join xt_stock_flow as f on f.warehousing_detail_id = x.id").Count(&total).Offset(offset).Limit(limit).Order("x.id desc").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,x.packing_price,t.manufacturer,x.remark,x.ctime,x.is_return,x.warehousing_order,x.type,x.storehouse_id,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.min_unit,t.buy_price,f.batch_number_count").Joins("left join xt_good_information as t on t.id = x.good_id").Joins("left join xt_stock_flow as f on f.warehousing_detail_id = x.id").Count(&total).Offset(offset).Limit(limit).Group("x.id").Order("x.id desc").Scan(&info).Error
 	return info, total, err
 
 }
 	if orgid > 0 {
 		db = db.Where("x.org_id= ?", orgid)
 	}
-	err = db.Select("x.id,x.warehouse_out_order_number,x.operation_time,x.creater,x.org_id,x.modifier,x.remark,x.warehouse_out_time,x.dealer,x.manufacturer,x.type").Preload("WarehouseOutInfo", func(db *gorm.DB) *gorm.DB {
-		return XTReadDB().Where("org_id=? and status = 1", orgid).Preload("WarehousingInfo", "status = 1 and org_id = ?", orgid)
-	}).Find(&out).Error
+	err = db.Select("x.id,x.warehouse_out_order_number,x.operation_time,x.creater,x.org_id,x.modifier,x.remark,x.warehouse_out_time,x.dealer,x.manufacturer,x.type").Find(&out).Error
 	return out, err
 }
 
 		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,t.social_security_directory_code,x.is_sys,x.sys_record_time,n.number,x.remark,x.license_number,x.storehouse_id,x.admin_user_id,x.buy_price,x.stock_count,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit,t.packing_price").Joins("left join xt_warehouse_info as n on n.id=x.warehouse_info_id").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.warehouse_out_id,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,x.manufacturer,t.social_security_directory_code,x.is_sys,x.sys_record_time,n.number,x.remark,x.license_number,x.storehouse_id,x.admin_user_id,x.buy_price,x.stock_count,x.warehouse_info_id,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit,t.packing_price").Joins("left join xt_warehouse_info as n on n.id=x.warehouse_info_id").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.warehouse_out_id,x.good_id").Order("x.ctime desc").Scan(&out).Error
 
 	return out, err
 }
 
 func GetStockFlowBatchNumberOne(id int64, goodid int64) (stock []*models.VmStockFlowOne, err error) {
 
-	db := XTReadDB().Table("xt_stock_flow as x").Where("x.status = 1 and count > 0")
+	db := XTReadDB().Table("xt_stock_flow as x").Where("x.status = 1 and x.count > 0 and (x.consumable_type = 3 or x.consumable_type = 2")
+	table := XTReadDB().Table("xt_patients as t").Where("t.status = 1")
+	fmt.Println(table)
+	tableone := XTReadDB().Table("xt_good_information as o").Where("o.status = 1")
+	fmt.Println(tableone)
+	if id > 0 {
+		db = db.Where("x.warehouse_out_id = ?", id)
+	}
+	if goodid > 0 {
+		db = db.Where("x.good_id = ?", goodid)
+	}
+
+	err = db.Select("x.id,x.warehousing_id,x.good_id,x.number,x.count,x.patient_id,x.system_time,x.is_sys,x.warehousing_order,x.warehouse_out_id,x.warehouse_out_order_number,x.price,x.product_date,x.expire_date,x.ctime,o.packing_unit,t.name").Joins("left join xt_patients as t on t.id = x.patient_id").Joins("left join xt_good_information as o on o.id = x.good_id").Scan(&stock).Error
+	return stock, err
+}
+
+func GetStockFlowCancelInfo(id int64, goodid int64) (stock []*models.VmStockFlowOne, err error) {
+	db := XTReadDB().Table("xt_stock_flow as x").Where("x.status = 1 and x.count > 0 and x.consumable_type = 7")
 	table := XTReadDB().Table("xt_patients as t").Where("t.status = 1")
 	fmt.Println(table)
 	tableone := XTReadDB().Table("xt_good_information as o").Where("o.status = 1")
 	}
 
 	err = db.Select("x.id,x.warehousing_id,x.good_id,x.number,x.count,x.patient_id,x.system_time,x.is_sys,x.warehousing_order,x.warehouse_out_id,x.warehouse_out_order_number,x.price,x.product_date,x.expire_date,x.ctime,o.packing_unit,t.name").Joins("left join xt_patients as t on t.id = x.patient_id").Joins("left join xt_good_information as o on o.id = x.good_id").Scan(&stock).Error
-	//err =XTReadDB()()()()().Model(&stock).Where("warehouse_out_id = ? and good_id = ? and status = 1", id, goodid).Find(&stock).Error
 	return stock, err
 }
 
 }
 
 func CreateStockFlowOne(flow models.VmStockFlow) error {
-	tx := XTWriteDB().Begin()
-	err := tx.Create(&flow).Error
+	utx := XTWriteDB().Begin()
+	err := utx.Create(&flow).Error
 	if err != nil {
-		tx.Rollback()
+		utx.Rollback()
 		return err
 	}
-	tx.Commit()
+	utx.Commit()
 	return err
 }
 
 
 func UpdatedStockFlowOne(flow models.VmStockFlow, warehousing_id int64, patient_id int64, record_time int64, good_id int64) error {
 
-	err = XTWriteDB().Model(&flow).Where("warehousing_id = ? and patient_id = ? and system_time = ? and good_id = ? and status = 1", warehousing_id, patient_id, record_time, good_id).Updates(map[string]interface{}{"number": flow.Number, "license_number": flow.LicenseNumber, "count": flow.Count, "expire_date": flow.ExpireDate, "product_date": flow.ProductDate, "price": flow.Price, "manufacturer": flow.Manufacturer, "dealer": flow.Dealer}).Error
+	err = XTWriteDB().Model(&flow).Where("warehousing_id = ? and patient_id = ? and system_time = ? and good_id = ? and status = 1", warehousing_id, patient_id, record_time, good_id).Updates(map[string]interface{}{"number": flow.Number, "license_number": flow.LicenseNumber, "count": flow.Count, "expire_date": flow.ExpireDate, "product_date": flow.ProductDate, "price": flow.Price, "manufacturer": flow.Manufacturer, "dealer": flow.Dealer, "over_count": flow.OverCount}).Error
 	return err
 }
 
 
 	stock := models.VmStockFlow{}
 	var err error
-	err = XTReadDB().Model(&stock).Where("warehousing_id = ? and patient_id = ? and system_time = ? and good_id = ? and status = 1", warehousing_id, patient_id, record_time, good_id).Find(&stock).Error
+	err = XTReadDB().Model(&stock).Where("warehousing_id = ? and patient_id = ? and system_time = ? and good_id = ? and status = 1 and is_read = 0", warehousing_id, patient_id, record_time, good_id).Find(&stock).Error
 	if err == gorm.ErrRecordNotFound {
 		return nil, err
 	}
 	return &stock, nil
 }
 
+func GetStockFlowIsBatchNumber(warehousing_id int64, patient_id int64, record_time int64, good_id int64) (flow []*models.VmStockFlow, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and system_time = ? and good_id = ? and status = 1 and consumable_type = 3", patient_id, record_time, good_id).Find(&flow).Error
+	return flow, nil
+}
+
+func GetStockFlowIsBatchNumberTwo(patient_id int64, record_time int64, good_id int64) (flow []*models.WarehouseOutInfo, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and sys_record_time = ? and good_id = ? and status = 1 ", patient_id, record_time, good_id).Find(&flow).Error
+	return flow, nil
+}
+
+func GetStockFlowIsBatchNumberThree(patient_id int64, record_time int64, good_id int64) (flow []*models.VmStockFlow, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and system_time = ? and good_id = ? and status = 1 and consumable_type =7", patient_id, record_time, good_id).Find(&flow).Error
+	return flow, nil
+}
+
 func GetWarehouseOutInfoIsExist(id int64) (*models.WarehouseOutInfo, error) {
 
 	info := models.WarehouseOutInfo{}
 	return &info, nil
 }
 
-func GetWarehouseOutInfoIsExistOne(good_id int64, patient_id int64, record_time int64) (*models.WarehouseOutInfo, error) {
+func GetWarehouseOutInfoIsExistOne(good_id int64, patient_id int64, record_time int64, project_id int64) (*models.WarehouseOutInfo, error) {
 
 	info := models.WarehouseOutInfo{}
 	var err error
 	return &info, nil
 }
 
+func GetWarehouseOutInfoIsExistTwo(good_id int64, patient_id int64, record_time int64, project_id int64) (models.WarehouseOutInfo, error) {
+	info := models.WarehouseOutInfo{}
+	err := XTReadDB().Where("good_id = ? and sys_record_time = ? and status = 1 and patient_id = ?", good_id, record_time, patient_id).Find(&info).Error
+	return info, err
+}
+
 func GetStockFlowList(limit int64, page int64, consumable_type int64, orgId int64, startTime int64, endTime int64, good_id int64) (flow []*models.VmStockFlow, total int64, err error) {
 
 	offset := (page - 1) * limit
 		if consumable_type == 4 {
 			db = db.Where(" consumable_type = ?", consumable_type)
 		}
+		//自动退库
+		if consumable_type == 7 {
+			db = db.Where(" consumable_type = ?", consumable_type)
+		}
 
 		if consumable_type == 10 {
 			db = db.Where(" consumable_type = ?", consumable_type)
 	return detail, err
 }
 
-func UpdatedWarehouseOutInfo(info *models.WarehouseOutInfo, good_id int64, patient_id int64, record_time int64) error {
+func UpdatedWarehouseOutInfo(info *models.WarehouseOutInfo, good_id int64, patient_id int64, record_time int64, project_id int64) error {
+
+	outInfo := models.WarehouseOutInfo{}
+	err := XTWriteDB().Model(&outInfo).Where("good_id = ? and patient_id = ? and sys_record_time  =? and status = 1", good_id, patient_id, record_time).Updates(map[string]interface{}{"warehouse_out_id": info.WarehouseOutId, "WarehouseOutOrderNumber": info.WarehouseOutOrderNumber, "sys_record_time": info.SysRecordTime, "good_type_id": info.GoodTypeId, "patient_id": info.PatientId, "consumable_type": info.ConsumableType, "count": info.Count, "price": info.Price, "dealer": info.Dealer, "manufacturer": info.Manufacturer, "number": info.Number, "license_number": info.LicenseNumber, "over_count": info.OverCount}).Error
+	return err
+}
+
+func UpdatedWarehouseOutInfoTwo(info *models.WarehouseOutInfo, good_id int64, patient_id int64, record_time int64) error {
 
 	outInfo := models.WarehouseOutInfo{}
 	err := XTWriteDB().Model(&outInfo).Where("good_id = ? and patient_id = ? and sys_record_time  =? and status = 1", good_id, patient_id, record_time).Updates(map[string]interface{}{"warehouse_out_id": info.WarehouseOutId, "WarehouseOutOrderNumber": info.WarehouseOutOrderNumber, "sys_record_time": info.SysRecordTime, "good_type_id": info.GoodTypeId, "patient_id": info.PatientId, "consumable_type": info.ConsumableType, "count": info.Count, "price": info.Price, "dealer": info.Dealer, "manufacturer": info.Manufacturer, "number": info.Number, "license_number": info.LicenseNumber}).Error
 func DeleteDrugAutoWarehouseSeven(drugid int64, patient_id int64, record_time int64, advice_id int64) error {
 
 	err := XTWriteDB().Model(models.DrugAutomaticReduceDetail{}).Where("drug_id = ? and patient_id = ? and record_time = ? and status = 1 and advice_id = ?", drugid, patient_id, record_time, advice_id).Updates(map[string]interface{}{"status": 0}).Error
-	err = XTWriteDB().Model(models.DrugWarehouseOutInfo{}).Where("drug_id = ? and patient_id = ? and sys_record_time = ? and status = 1 and advice_id = ?", drugid, patient_id, record_time, advice_id).Updates(map[string]interface{}{"status": 0}).Error
-	err = XTWriteDB().Model(models.DrugFlow{}).Where("drug_id = ? and patient_id = ? and system_time = ? and status = 1 and advice_id = ?", drugid, patient_id, record_time, advice_id).Updates(map[string]interface{}{"status": 0}).Error
+	//err = XTWriteDB().Model(models.DrugWarehouseOutInfo{}).Where("drug_id = ? and patient_id = ? and sys_record_time = ? and status = 1 and advice_id = ?", drugid, patient_id, record_time, advice_id).Updates(map[string]interface{}{"status": 0}).Error
+	//err = XTWriteDB().Model(models.DrugFlow{}).Where("drug_id = ? and patient_id = ? and system_time = ? and status = 1 and advice_id = ?", drugid, patient_id, record_time, advice_id).Updates(map[string]interface{}{"status": 0}).Error
 	return err
 }
 
 
 func GetGoodInventoryWarehouseList(id int64, storehouse_id int64) (info []*models.WarehousingInfo, err error) {
 
-	err = XTReadDB().Model(&info).Where("good_id = ? and status = 1 and storehouse_id=?", id, storehouse_id).Preload("GoodInfo", "status = 1").Find(&info).Error
+	err = XTReadDB().Model(&info).Where("good_id = ? and status = 1 and storehouse_id=? and is_check= 1", id, storehouse_id).Preload("GoodInfo", "status = 1").Find(&info).Error
 	return info, err
 }
 
 
 func UpdatedSigleWarehouseOutInfo(id int64, info *models.WarehouseOutInfo) error {
 
-	err := XTWriteDB().Model(&models.WarehouseOutInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"warehouse_info_id": info.WarehouseInfotId}).Error
-
+	tx := XTWriteDB().Begin()
+	err := tx.Model(&models.WarehouseOutInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"warehouse_info_id": info.WarehouseInfotId}).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	tx.Commit()
 	return err
 
 }
 
 func UpdateaGoodWarehouseInfo(count int64, good_id int64, orgid int64, warehouse_info_id int64) error {
 
-	err := XTWriteDB().Model(&models.WarehousingInfo{}).Where("good_id = ?  and org_id = ? and status = 1 and id = ?", good_id, orgid, warehouse_info_id).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", count)).Error
-
+	ut := writeDb.Begin()
+	err := ut.Model(&models.WarehousingInfo{}).Where("good_id = ?  and org_id = ? and status = 1 and id = ?", good_id, orgid, warehouse_info_id).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
+
 }
 
 func ModifyGoodWarehouseOut(id int64) error {
-
-	err := XTWriteDB().Model(&models.WarehouseOut{}).Where("id = ? and status =1", id).Update(map[string]interface{}{"is_check": 2}).Error
-	err = XTWriteDB().Model(&models.WarehouseOutInfo{}).Where("warehouse_out_id in(?) and status = 1", id).Update(map[string]interface{}{"is_check": 2}).Error
-	err = XTWriteDB().Model(&models.VmStockFlow{}).Where("warehouse_out_id in(?) and status = 1", id).Update(map[string]interface{}{"status": 0}).Error
-
+	ut := writeDb.Begin()
+	err := ut.Model(&models.WarehouseOut{}).Where("id = ? and status =1", id).Update(map[string]interface{}{"is_check": 2}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	err = ut.Model(&models.WarehouseOutInfo{}).Where("warehouse_out_id in(?) and status = 1", id).Update(map[string]interface{}{"is_check": 2}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	err = ut.Model(&models.VmStockFlow{}).Where("warehouse_out_id in(?) and status = 1", id).Update(map[string]interface{}{"status": 0, "is_check": 2}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	err = ut.Model(&models.XtWarehouseFlushInfo{}).Where("warehouse_out_id in(?) and status = 1", id).Update(map[string]interface{}{"status": 0}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
 }
 
 }
 
 func UpdateCheckWarehouseInfo(id int64) error {
+
+	tx := XTWriteDB().Begin()
+	err := tx.Model(&models.Warehousing{}).Where("id =? and status = 1", id).Update(map[string]interface{}{"is_check": 1}).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	tx.Commit()
+	return err
 	tx := XTWriteDB().Begin()
 	err := tx.Model(&models.Warehousing{}).Where("id =? and status = 1", id).Update(map[string]interface{}{"is_check": 1}).Error
 	if err != nil {
 }
 
 func UpdateWarehouseInfoByIdList(count int64, id int64) error {
+
+	tx := XTWriteDB().Begin()
+	err := tx.Model(&models.WarehousingInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", count)).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	err = tx.Model(&models.WarehousingInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 1}).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	tx.Commit()
+	return err
 	tx := XTWriteDB().Begin()
 	err := tx.Model(&models.WarehousingInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", count)).Error
 	if err != nil {
 }
 
 func ReturnCheckWarehouseInfo(id int64) error {
+
+	tx := XTWriteDB().Begin()
+	err := tx.Model(&models.Warehousing{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 2}).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	err = tx.Model(&models.WarehousingInfo{}).Where("warehousing_id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 2}).Error
+	tx.Commit()
+	return err
 	tx := XTWriteDB().Begin()
 	err := tx.Model(&models.Warehousing{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 2}).Error
 	if err != nil {
 }
 
 func UpdateWarehouseInfoByIdListTwo(count int64, id int64) error {
+
+	tx := XTWriteDB().Begin()
+	err := tx.Model(&models.WarehousingInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_count", gorm.Expr("stock_count - ?", count)).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	err = tx.Model(&models.WarehousingInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 2}).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	tx.Commit()
+	return err
 	tx := XTWriteDB().Begin()
 	err := tx.Model(&models.WarehousingInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_count", gorm.Expr("stock_count - ?", count)).Error
 	if err != nil {
 }
 
 func UpdateWarehouseInfoFlow(id int64) error {
+
 	tx := XTWriteDB().Begin()
-	err := tx.Model(models.VmStockFlow{}).Where("warehousing_detail_id =  ?", id).Update(map[string]interface{}{"status": 0}).Error
+	err := tx.Model(models.VmStockFlow{}).Where("warehousing_detail_id =  ?", id).Update(map[string]interface{}{"status": 0, "is_check": 2}).Error
 
 	if err != nil {
 		tx.Rollback()
 	}
 	tx.Commit()
 	return err
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	tx.Commit()
+	return err
 }
 
 func FindLastWarehousingSix(org_id int64) (info models.Warehousing, err error) {
 }
 
 func UpdateGoodInfoReduceSumCount(goodid int64, sum_count int64, orgid int64) error {
+	tx := XTWriteDB().Begin()
+	err = tx.Model(&models.GoodInfo{}).Where("id = ? and org_id = ? and status = 1", goodid, orgid).Update(map[string]interface{}{"sum_count": sum_count}).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	tx.Commit()
+	return err
 
 	err = XTWriteDB().Model(&models.GoodInfo{}).Where("id = ? and org_id = ? and status = 1", goodid, orgid).Update(map[string]interface{}{"sum_count": sum_count}).Error
 	return err
 	return err
 }
 
+func UpdateGoodInfoAddSumCount(goodid int64, sum_count int64, orgid int64, sum_in_count int64) error {
+
+	tx := XTWriteDB().Begin()
+	err := tx.Model(&models.GoodInfo{}).Where("id = ? and org_id = ? and status = 1", goodid, orgid).Update(map[string]interface{}{"sum_count": sum_count, "sum_in_count": sum_in_count}).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	tx.Commit()
+	return err
+}
+
 func GetCancelStockInfo(id int64, orgid int64) (stock []*models.CancelStockInfo, err error) {
 
 	err = XTReadDB().Where("cancel_stock_id  = ? and org_id = ? and status  = 1", id, orgid).Preload("GoodInfo", "status = 1 and org_id = ?", orgid).Preload("WarehousingInfo", "status = 1 and org_id = ?", orgid).Find(&stock).Error
 }
 
 func CheckCancelStock(stock models.CancelStock, cancel_stock_id int64, orgid int64) error {
-
-	err := XTWriteDB().Model(&models.CancelStock{}).Where("id = ? and status = 1 and org_id = ?", cancel_stock_id, orgid).Update(map[string]interface{}{"is_check": 1}).Error
-	err = XTWriteDB().Model(&models.CancelStockInfo{}).Where("cancel_stock_id = ? and status = 1 and org_id = ?", cancel_stock_id, orgid).Update(map[string]interface{}{"is_check": 1}).Error
+	ut := writeDb.Begin()
+	err := ut.Model(&models.CancelStock{}).Where("id = ? and status = 1 and org_id = ?", cancel_stock_id, orgid).Update(map[string]interface{}{"is_check": 1}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	err = ut.Model(&models.CancelStockInfo{}).Where("cancel_stock_id = ? and status = 1 and org_id = ?", cancel_stock_id, orgid).Update(map[string]interface{}{"is_check": 1}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
 }
 
 }
 
 func UpdateCancelStockNumber(stock_count int64, warehouse_info_id int64, orgid int64) error {
-
-	err := XTWriteDB().Model(&models.WarehousingInfo{}).Where("id = ? and org_id = ? and status = 1", warehouse_info_id, orgid).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", stock_count)).Error
+	ut := writeDb.Begin()
+	err := ut.Model(&models.WarehousingInfo{}).Where("id = ? and org_id = ? and status = 1", warehouse_info_id, orgid).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", stock_count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
 }
 
 func UpdateGoodSumCount(sum_count int64, good_id int64, orgid int64) error {
-
-	err := XTWriteDB().Model(&models.GoodInfo{}).Where("id = ? and org_id = ? and status = 1", good_id, orgid).UpdateColumn("sum_count", gorm.Expr("sum_count + ?", sum_count)).Error
+	ut := writeDb.Begin()
+	err := ut.Model(&models.GoodInfo{}).Where("id = ? and org_id = ? and status = 1", good_id, orgid).UpdateColumn("sum_count", gorm.Expr("sum_count + ?", sum_count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
 }
 
 func UpdateStockWarehouseInfo(cancel_stock_id int64, orgid int64, stock models.CancelStock) error {
-
-	err := XTWriteDB().Model(&models.CancelStock{}).Where("id = ? and org_id = ? and status = 1", cancel_stock_id, orgid).Update(map[string]interface{}{"is_check": 2}).Error
-	err = XTWriteDB().Model(&models.CancelStockInfo{}).Where("cancel_stock_id = ? and org_id = ? and status = 1", cancel_stock_id, orgid).Update(map[string]interface{}{"is_check": 2}).Error
+	ut := writeDb.Begin()
+	err := ut.Model(&models.CancelStock{}).Where("id = ? and org_id = ? and status = 1", cancel_stock_id, orgid).Update(map[string]interface{}{"is_check": 2}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	err = ut.Model(&models.CancelStockInfo{}).Where("cancel_stock_id = ? and org_id = ? and status = 1", cancel_stock_id, orgid).Update(map[string]interface{}{"is_check": 2}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
 }
 
 func UpdateStockWarehouseInfoStockFlow(id int64, orgid int64, goodid int64) error {
-	err = XTWriteDB().Model(&models.VmStockFlow{}).Where("cancel_out_detail_id = ? and user_org_id = ? and status = 1 and good_id =?", id, orgid, goodid).Update(map[string]interface{}{"status": 0}).Error
+	ut := writeDb.Begin()
+	err = ut.Model(&models.VmStockFlow{}).Where("cancel_out_detail_id = ? and user_org_id = ? and status = 1 and good_id =?", id, orgid, goodid).Update(map[string]interface{}{"status": 0}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
 }
 
 func UpdateStockNumberWarehouseInfo(warehouse_info_id int64, good_id int64, org_id int64, stock_count int64) error {
-
+	ut := writeDb.Begin()
 	err := XTWriteDB().Model(&models.WarehousingInfo{}).Where("id = ? and good_id = ? and org_id = ? and status = 1", warehouse_info_id, good_id, org_id).UpdateColumn("stock_count", gorm.Expr("stock_count - ?", stock_count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
 	err = XTWriteDB().Model(&models.GoodInfo{}).Where("id = ? and status = 1 and org_id = ?", good_id, org_id).UpdateColumn("sum_count", gorm.Expr("sum_count - ?", stock_count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
 }
 
 }
 
 func UpdateBaseDrugSumInfo(sum_count int64, drugid int64, orgid int64, sum_in_count int64) error {
+	ut := XTWriteDB().Begin()
+	err := ut.Model(&models.BaseDrugLib{}).Where("id = ? and status = 1 and org_id = ?", drugid, orgid).Update(map[string]interface{}{"sum_count": sum_count}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	err = ut.Model(&models.BaseDrugLib{}).Where("id = ? and status = 1 and org_id = ?", drugid, orgid).Update(map[string]interface{}{"sum_in_count": sum_in_count}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	tx := XTWriteDB().Begin()
 	err := tx.Model(&models.BaseDrugLib{}).Where("id = ? and status = 1 and org_id = ?", drugid, orgid).Update(map[string]interface{}{"sum_count": sum_count}).Error
 	if err != nil {
 }
 
 func UpdateBaseDrugSumTwo(drugid int64, sum_count int64, orgid int64) error {
-
-	err = XTWriteDB().Model(&models.BaseDrugLib{}).Where("id = ? and org_id = ? and status = 1", drugid, orgid).Update(map[string]interface{}{"sum_count": sum_count}).Error
+	ut := writeDb.Begin()
+	err = ut.Model(&models.BaseDrugLib{}).Where("id = ? and org_id = ? and status = 1", drugid, orgid).Update(map[string]interface{}{"sum_count": sum_count}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
 }
 
 }
 
 func ModifyDrugMaxNumberWarehouseInfo(id int64, count int64, orgid int64) error {
-
-	err := XTWriteDB().Model(&models.DrugWarehouseInfo{}).Where("id = ? and org_id = ? and status = 1", id, orgid).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number - ?", count)).Error
+	ut := XTWriteDB().Begin()
+	err := ut.Model(&models.DrugWarehouseInfo{}).Where("id = ? and org_id = ? and status = 1", id, orgid).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number - ?", count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
 	return err
+
 }
 
 func ModifyDrugMinNumberWarehouseInfo(id int64, count int64, orgid int64) error {
 	err = XTReadDB().Preload("GoodInfo", "status = 1 and org_id = ?", orgid).Preload("WarehousingInfo", "status = 1 and org_id=?", orgid).Find(&storeinventory).Error
 	return storeinventory, err
 }
+
+func GetGoodDialysisOutInfo(orgid int64, patient_id int64, sys_record_time int64, good_id int64) (models.AutomaticReduceDetail, error) {
+
+	detail := models.AutomaticReduceDetail{}
+	err := XTReadDB().Where("org_id =? and patient_id = ? and record_time = ? and good_id = ? and status= 1", orgid, patient_id, sys_record_time, good_id).Find(&detail).Error
+	return detail, err
+}