Merge branch '20220812' of http://git.shengws.com/csx/XT_New into 20220812

conf/app.conf

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

controllers/dialysis_api_controller.go

 
 	beego.Router("/api/getinitprintdateone", &DialysisApiController{}, "Get:GetInitPrintDataOne")
 
+	//新接口
+	beego.Router("/api/patient/getpatientdialysissolutiongrouplist", &DialysisApiController{}, "Get:GetPatientDialysisSolutionGroupList")
+
+	beego.Router("/api/patient/getdialysisadvicetemplatelist", &DialysisApiController{}, "Get:GetDialysisAdviceTemplateList")
+
+	beego.Router("/api/patient/savedialysissetting", &DialysisApiController{}, "Get:SaveDialysisSetting")
+
+	beego.Router("/api/patient/getdialysissetting", &DialysisApiController{}, "Get:GetDialysisSetting")
 }
 
 func (c *DialysisApiController) GetQueueCall() {
 		}
 
 		prescription.Creater = adminUserInfo.AdminUser.Id
+
+		//针对河间咸得
+		if adminUserInfo.CurrentOrgId == 10164 || adminUserInfo.CurrentOrgId == 10090 || adminUserInfo.CurrentOrgId == 3877 {
+
+			if prescription.ModeId != 2 && prescription.ModeId != 5 && prescription.ModeId != 12 {
+
+				prescription.DisplaceLiquiPart = 0
+				prescription.DisplaceLiquiValue = 0
+			}
+		}
+
 		err := service.AddSigleRecord(&prescription)
 		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
 		redis := service.RedisClient()
 		OxygenFlow:                 oxygen_flow,
 		OxygenTime:                 oxygen_time,
 		PreImpulse:                 preImpules,
+		SolutionStatus:             1,
+	}
+
+	//针对河间咸得
+	if adminUserInfo.CurrentOrgId == 10164 || adminUserInfo.CurrentOrgId == 10090 || adminUserInfo.CurrentOrgId == 3877 {
+
+		if prescription.ModeId != 2 && prescription.ModeId != 5 && prescription.ModeId != 12 {
+
+			prescription.DisplaceLiquiPart = 0
+			prescription.DisplaceLiquiValue = 0
+		}
 	}
+
+	if adminUserInfo.CurrentOrgId == 10164 || adminUserInfo.CurrentOrgId == 10090 || adminUserInfo.CurrentOrgId == 3877 {
+
+		if solution.ModeId != 2 && solution.ModeId != 5 && solution.ModeId != 12 {
+
+			solution.DisplaceLiquiPart = 0
+			solution.DisplaceLiquiValue = 0
+		}
+	}
+
 	err := service.SavePrescriptionAndCreateSolution(&solution, &prescription)
+
+	//获取最新1条
+	dialysisSolution, _ := service.GetLastPatientDialysisSolution(patient, adminUserInfo.CurrentOrgId)
+
+	//更新状态
+	service.UpdateDialysisSolutionStatusTwo(dialysisSolution.ID, dialysisSolution.ModeId, dialysisSolution.UserOrgId, dialysisSolution.PatientId)
+
 	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
 	redis := service.RedisClient()
 
 	blood_access_noise, _ := c.GetInt64("blood_access_noise", 0)
 	internal_fistula_other := c.GetString("internal_fistula_other")
 	blood_access_internal_fistula := c.GetString("blood_access_internal_fistula")
-
-	//breathing_rate, _ := c.GetFloat("breathing_rate", 0)
 	breathing_rate := c.GetString("breathing_rate")
-
 	is_infect, _ := c.GetInt64("is_infect", 0)
 	exposed, _ := c.GetFloat("exposed", 0)
 	skin := c.GetString("skin")
 	operate_time, _ := c.GetInt64("operate_time", 0)
 	// monitoring_time := c.GetString("monitoring_time")
 	pulse_frequency, _ := c.GetFloat("pulse_frequency", 0)
-	//breathing_rated, _ := c.GetFloat("breathing_rated", 0)
 	breathing_rated := c.GetString("breathing_rated")
 	systolic_blood_pressure, _ := c.GetFloat("systolic_blood_pressure", 0)
 	diastolic_blood_pressure, _ := c.GetFloat("diastolic_blood_pressure", 0)
 		return
 	}
 }
+
+//新接口
+func (this *DialysisApiController) GetPatientDialysisSolutionGroupList() {
+
+	keyword := this.GetString("keywords")
+
+	limit, _ := this.GetInt64("limit")
+
+	page, _ := this.GetInt64("page")
+
+	partition_id, _ := this.GetInt64("partition_id")
+
+	schedule_type, _ := this.GetInt64("schedule_type")
+
+	start_time := this.GetString("schedule_date")
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+
+	list, total, err := service.GetPatientDialysisSolutionGroupList(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId)
+
+	if err == nil {
+		this.ServeSuccessJSON(map[string]interface{}{
+			"list":  list,
+			"total": total,
+		})
+		return
+
+	} else {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+}
+
+func (this *DialysisApiController) GetDialysisAdviceTemplateList() {
+
+	keyword := this.GetString("keywords")
+
+	limit, _ := this.GetInt64("limit")
+
+	page, _ := this.GetInt64("page")
+
+	partition_id, _ := this.GetInt64("partition_id")
+
+	schedule_type, _ := this.GetInt64("schedule_type")
+
+	start_time := this.GetString("schedule_date")
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+
+	list, total, err := service.GetDialysisAdviceTemplateList(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId)
+
+	//获取长期医嘱
+	adviceList, _ := service.GetAllLongAdviceList(orgId)
+
+	//获取医嘱模版
+	templateList, _ := service.GetAllHisAdviceTemplateList(orgId)
+	if err == nil {
+		this.ServeSuccessJSON(map[string]interface{}{
+			"list":         list,
+			"total":        total,
+			"adviceList":   adviceList,
+			"templateList": templateList,
+		})
+		return
+
+	} else {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+}
+
+func (this *DialysisApiController) SaveDialysisSetting() {
+
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	device_number_set, _ := this.GetInt64("device_number_set")
+	device_type_set, _ := this.GetInt64("device_type_set")
+	name_set, _ := this.GetInt64("name_set")
+	admission_number_set, _ := this.GetInt64("admission_number_set")
+	dialysis_no_set, _ := this.GetInt64("dialysis_no_set")
+	weight_befor_set, _ := this.GetInt64("weight_befor_set")
+	dry_weight_set, _ := this.GetInt64("dry_weight_set")
+	blood_pressure_set, _ := this.GetInt64("blood_pressure_set")
+	ultrafiltration_volume_set, _ := this.GetInt64("ultrafiltration_volume_set")
+	internal_fistula_set, _ := this.GetInt64("internal_fistula_set")
+	blood_flow_volume_set, _ := this.GetInt64("blood_flow_volume_set")
+	anticoagulant_set, _ := this.GetInt64("anticoagulant_set")
+	sealing_fluid_dispose_set, _ := this.GetInt64("sealing_fluid_dispose_set")
+	mode_id_set, _ := this.GetInt64("mode_id_set")
+	dialysis_time_set, _ := this.GetInt64("dialysis_time_set")
+	dialysis_dialyszers_set, _ := this.GetInt64("dialysis_dialyszers_set")
+	dialysis_irrigation_set, _ := this.GetInt64("dialysis_irrigation_set")
+	gaijiliang_set, _ := this.GetInt64("gaijiliang_set")
+	kalium_set, _ := this.GetInt64("kalium_set")
+	displace_liqui_value_set, _ := this.GetInt64("displace_liqui_value_set")
+	bicarbonate_set, _ := this.GetInt64("bicarbonate_set")
+	glucose_set, _ := this.GetInt64("glucose_set")
+
+	dialysisSetting := models.XtDialysisSetting{
+		UserOrgId:             orgId,
+		Status:                1,
+		DeviceNumber:          device_number_set,
+		DeviceType:            device_type_set,
+		Name:                  name_set,
+		AdmissionNumber:       admission_number_set,
+		DialysisNo:            dialysis_no_set,
+		WeightBefor:           weight_befor_set,
+		DryWeight:             dry_weight_set,
+		BloodPressure:         blood_pressure_set,
+		UltrafiltrationVolume: ultrafiltration_volume_set,
+		InternalFistula:       internal_fistula_set,
+		BloodFlowVolume:       blood_flow_volume_set,
+		Anticoagulant:         anticoagulant_set,
+		SealingFluidDispose:   sealing_fluid_dispose_set,
+		ModeId:                mode_id_set,
+		DialysisTime:          dialysis_time_set,
+		DialysisDialyszers:    dialysis_dialyszers_set,
+		DialysisIrrigation:    dialysis_irrigation_set,
+		Gaijiliang:            gaijiliang_set,
+		Kalium:                kalium_set,
+		DisplaceLiquiValue:    displace_liqui_value_set,
+		Bicarbonate:           bicarbonate_set,
+		Glucose:               glucose_set,
+		Ctime:                 time.Now().Unix(),
+		Mtime:                 time.Now().Unix(),
+	}
+	err := service.SaveDialysisSetting(dialysisSetting)
+	if err == nil {
+		this.ServeSuccessJSON(map[string]interface{}{
+			"dialysisSetting": dialysisSetting,
+		})
+		return
+
+	} else {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+}
+
+func (this *DialysisApiController) GetDialysisSetting() {
+
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	dialysisSett, _ := service.GetDialysisSetting(orgId)
+	this.ServeSuccessJSON(map[string]interface{}{
+		"dialysisSett": dialysisSett,
+	})
+	return
+}

controllers/drug_stock_api_contorller.go

 	"encoding/json"
 	"fmt"
 	"github.com/astaxie/beego"
+	"github.com/jinzhu/gorm"
 	"reflect"
 	"strconv"
 	"strings"
 			}
 			service.UpdateMedicalSumCount(item.DrugId, sum_count, sum_in_count, item.OrgId)
 
+			drugInfolist, _ := service.GetDrugSumCountByStorehouseId(item.StorehouseId, item.OrgId, item.DrugId)
+			var total_count int64 // 入库总数量
+			var over_count int64  //剩余库存
+			for _, it := range drugInfolist {
+				baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
+				if it.MaxUnit == baseDrug.MaxUnit {
+					it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
+				}
+				total_count += it.WarehousingCount
+				over_count += it.StockMaxNumber*baseDrug.MinNumber + it.StockMinNumber
+			}
+			//查询该仓库是否有默认数据
+			_, errcode := service.GetDrugStockCount(item.StorehouseId, item.DrugId, item.OrgId)
+			if errcode == gorm.ErrRecordNotFound {
+				drugStock := models.XtDrugStockCount{
+					UserOrgId:      item.OrgId,
+					StorehouseId:   item.StorehouseId,
+					SumInCount:     total_count,
+					SumOutCount:    0,
+					SumCancelCount: 0,
+					DrugId:         item.DrugId,
+					Ctime:          time.Now().Unix(),
+					Mtime:          0,
+					Status:         1,
+					FlushCount:     over_count,
+					SumActOutCount: 0,
+				}
+				service.CreateDrugStockSum(drugStock)
+
+			} else if errcode == nil {
+				service.UpdateDrugStockSum(item.StorehouseId, item.DrugId, item.OrgId, total_count, over_count)
+			}
+
 		}
 
 		c.ServeSuccessJSON(map[string]interface{}{
 			}
 		}
 		service.UpdateBaseDrugSumInfo(sum_count, item.DrugId, item.OrgId, sum_in_count)
+
+		var total_count int64
+		if item.MaxUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
+			total_count = item.WarehousingCount * medical.MinNumber
+		}
+		if item.MaxUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
+			total_count = item.WarehousingCount
+		}
+		if item.MaxUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
+			total_count = item.WarehousingCount * medical.MinNumber
+		}
+		drugInfolist, _ := service.GetDrugSumCountByStorehouseId(item.StorehouseId, item.OrgId, item.DrugId)
+		var over_count int64 //剩余库存
+		for _, it := range drugInfolist {
+			over_count += it.StockMaxNumber*medical.MinNumber + it.StockMinNumber
+		}
+		//扣减库存
+		service.ReduceDrugStockCount(item.StorehouseId, item.DrugId, item.OrgId, total_count, over_count)
+
 	}
 	//更新审核
 	err := service.ReturnCheckWarehouseingInfo(warehousing_id, orgId)
 			total_count += item.StockMaxNumber + item.StockMinNumber
 		}
 
+		//if it.CountUnit == drup.MaxUnit && drup.MaxUnit != drup.MinUnit {
+		//	it.Count = it.Count * drup.MinNumber
+		//}
+		//out_count += it.Count
+
+		//出库数量累加
 		if it.CountUnit == drup.MaxUnit && drup.MaxUnit != drup.MinUnit {
-			it.Count = it.Count * drup.MinNumber
+			out_count = it.Count * drup.MinNumber
 		}
-		out_count += it.Count
-		fmt.Println("出库数量23232323232我", out_count)
-		fmt.Println("总库存", total_count)
+
+		if it.CountUnit == drup.MinUnit && drup.MaxUnit != drup.MinUnit {
+			out_count = it.Count
+		}
+
+		if it.CountUnit == drup.MinUnit && drup.MaxUnit == drup.MinUnit {
+			out_count = it.Count
+		}
+
 		if out_count > total_count {
 			c.ServeSuccessJSON(map[string]interface{}{
 				"warehousingOutInfoList": warehousingOutInfoList,
 		var sum_count int64
 		for _, its := range stockInfo {
 			sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+
 		}
 		service.UpdateBaseDrugSumTwo(it.DrugId, sum_count, it.OrgId)
+
+		////出库数量累加
+		var out_count_one int64
+		if it.CountUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
+			out_count_one = it.Count * medical.MinNumber
+		}
+
+		if it.CountUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
+			out_count_one = it.Count
+		}
+
+		if it.CountUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
+			out_count_one = it.Count
+		}
+
+		fmt.Println("out_count23233232323woede", out_count_one)
+		//增加出库数量
+		service.AddDrugCount(it.DrugId, it.OrgId, storeHouseConfig.DrugStorehouseOut, out_count_one)
+
+		//查询该药品剩余库存
+		infolist, _ := service.FindDrugWarehouseInfoFlushCountByStorehouse(it.DrugId, it.OrgId, storeHouseConfig.DrugStorehouseOut)
+		var over_count int64
+		for _, its := range infolist {
+			over_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+		}
+		service.UpdateDrugStockCount(it.DrugId, it.OrgId, storeHouseConfig.DrugStorehouseOut, over_count)
 	}
 
 	out := models.DrugWarehouseOut{
 		IsCheck: 2,
 	}
 	service.UpdateCheckDrugOutInfoList(outInfo, warehouse_out_id)
+	creater := c.GetAdminUserInfo().AdminUser.Id
 
 	orgId := c.GetAdminUserInfo().CurrentOrgId
 	list, _ := service.GetDrugWarehouseOutListById(warehouse_out_id, orgId)
 		medical, _ := service.GetBaseDrugMedical(item.DrugId)
 		if item.CountUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
 			service.UpdateDrugMaxNumber(item.Count, item.WarehouseInfoId)
+			var sum_out_count int64
+			sum_out_count = item.Count * medical.MinNumber
+			service.ModifyReduceDrugInformation(item.DrugId, sum_out_count, item.OrgId)
+			drugInfoList, _ := service.FindDrugWarehouseInfoList(item.DrugId, item.OrgId)
+			var drug_max_number int64
+			var drug_min_number int64
+			for _, item := range drugInfoList {
+				drug_max_number += item.StockMaxNumber
+				drug_min_number += item.StockMinNumber
+			}
+			drugFlushInfo := models.XtDrugWarehouseFlushInfo{
+				DrugMaxNumber:           drug_max_number,
+				UserOrgId:               item.OrgId,
+				WarehouseOutId:          item.ID,
+				Type:                    2,
+				SystemTime:              item.SysRecordTime,
+				PatientId:               0,
+				Ctime:                   time.Now().Unix(),
+				Mtime:                   0,
+				BatchNumberId:           item.WarehouseInfoId,
+				DrugId:                  item.DrugId,
+				Count:                   item.Count,
+				WarehouseOutOrderNumber: item.WarehouseOutOrderNumber,
+				Creater:                 creater,
+				DrugMinNumber:           drug_min_number,
+				Unit:                    item.CountUnit,
+				Status:                  1,
+			}
+			service.CreatedDrugFlushInfo(drugFlushInfo)
 			service.DeleteDrugOutFlow(item.ID, item.OrgId)
 		}
 		if item.CountUnit == medical.MaxUnit && medical.MaxUnit == medical.MinUnit {
 			service.UpdateDrugMaxNumber(item.Count, item.WarehouseInfoId)
+			var sum_out_count int64
+			sum_out_count = item.Count * medical.MinNumber
+			service.ModifyReduceDrugInformation(item.DrugId, sum_out_count, item.OrgId)
+
 			service.DeleteDrugOutFlow(item.ID, item.OrgId)
 		}
 		if item.CountUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
 			service.UpdateDrugMinNumber(item.Count, item.WarehouseInfoId)
+			var sum_out_count int64
+			sum_out_count = item.Count
+			service.ModifyReduceDrugInformation(item.DrugId, sum_out_count, item.OrgId)
+
 			service.DeleteDrugOutFlow(item.ID, item.OrgId)
 		}
 
 			sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
 		}
 		service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.OrgId)
+
+		//出库数量累加
+		var out_count int64
+		if item.CountUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
+			out_count = item.Count * medical.MinNumber
+		}
+
+		if item.CountUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
+			out_count = item.Count
+		}
+
+		if item.CountUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
+			out_count = item.Count
+		}
+		//增加出库数量
+		service.ReduceDrugCount(item.DrugId, item.OrgId, storeHouseConfig.DrugStorehouseOut, out_count)
+
+		//查询该药品剩余库存
+		infolist, _ := service.FindDrugWarehouseInfoFlushCountByStorehouse(item.DrugId, item.OrgId, storeHouseConfig.DrugStorehouseOut)
+		var over_count int64
+		for _, its := range infolist {
+			over_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+		}
+		service.UpdateDrugStockCount(item.DrugId, item.OrgId, storeHouseConfig.DrugStorehouseOut, over_count)
+
 	}
 	c.ServeSuccessJSON(map[string]interface{}{
 		"out": out,
 			})
 			return
 		}
+
 	}
 	for _, its := range list {
 		for _, item := range manufacturerList {
 		//查询该批次的退库数量
 		drugFlow := models.DrugFlow{
 			ID:                        0,
-			WarehousingId:             0,
+			WarehousingId:             its.BatchNumberId,
 			DrugId:                    its.DrugId,
 			Number:                    its.Number,
 			BatchNumber:               "",
 			Ctime:                     time.Now().Unix(),
 			Mtime:                     0,
 			Price:                     its.Price,
-			WarehousingDetailId:       0,
+			WarehousingDetailId:       its.BatchNumberId,
 			WarehouseOutDetailId:      0,
 			CancelOutDetailId:         its.ID,
 			ExpireDate:                its.ExpiryDate,
 			PharmacyId:                0,
 		}
 		service.CreateDrugFlowOne(drugFlow)
+
+		medical, _ := service.GetBaseDrugMedical(its.DrugId)
+		if its.MaxUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
+			var sum_cancel_count int64
+			sum_cancel_count += its.Count * medical.MinNumber
+			//退库数量增加
+			//service.ModifyAddCancelAddInfomation(its.DrugId,sum_cancel_count,its.OrgId,its.StorehouseId)
+			//出库数量减少
+			service.ModifyAddDrugOutReduceInfomation(its.DrugId, sum_cancel_count, its.OrgId, its.StorehouseId)
+		}
+
+		if its.MaxUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
+			//退库数量增加
+			//service.ModifyAddCancelAddInfomation(its.DrugId,its.Count,its.OrgId,its.StorehouseId)
+			//出库数量减少
+			service.ModifyAddDrugOutReduceInfomation(its.DrugId, its.Count, its.OrgId, its.StorehouseId)
+		}
+
+		if its.MaxUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
+			//退库数量增加
+			//service.ModifyAddCancelAddInfomation(its.DrugId,its.Count,its.OrgId,its.StorehouseId)
+			//出库数量减少
+			service.ModifyAddDrugOutReduceInfomation(its.DrugId, its.Count, its.OrgId, its.StorehouseId)
+		}
+
 	}
 	for _, its := range cancelList {
 		medical, _ := service.GetBaseDrugMedical(its.DrugId)
 		if its.MaxUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
 
 			service.ModifyDrugWarehouseInfoStockMaxNumber(its.Count, its.DrugId, its.OrgId, its.BatchNumberId)
+
 		}
 		if its.MaxUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
 
 		if its.MaxUnit == medical.MaxUnit && medical.MaxUnit == medical.MinUnit {
 
 			service.ModifyDrugWarehouseInfoStockMaxNumber(its.Count, its.DrugId, its.OrgId, its.BatchNumberId)
+
 		}
 
 		stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, its.OrgId, its.DrugId)
 			sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
 		}
 		service.UpdateBaseDrugSumTwo(its.DrugId, sum_count, its.OrgId)
-	}
-	service.ModifyCancelStock(cancelstock_id, cancelStock, orgId)
 
+		var cancel_count int64
+		if its.MaxUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
+			cancel_count = its.Count * medical.MinNumber
+		}
+		if its.MaxUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
+			cancel_count = its.Count
+		}
+
+		if its.MaxUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
+			cancel_count = its.Count * medical.MinNumber
+		}
+		cancelInfo, _ := service.GetDrugAllStockInfo(its.StorehouseId, its.OrgId, its.DrugId)
+		var over_count int64
+		for _, items := range cancelInfo {
+			over_count += items.StockMaxNumber*medical.MinNumber + items.StockMinNumber
+		}
+		service.AddCancelSumCount(its.StorehouseId, its.DrugId, its.OrgId, cancel_count, over_count)
+
+		service.ModifyCancelStock(cancelstock_id, cancelStock, orgId)
+	}
 	//新增库存
 	c.ServeSuccessJSON(map[string]interface{}{
 		"drug_name":  "",
 		//扣减库存
 		medical, _ := service.GetBaseDrugMedical(item.DrugId)
 		if item.MaxUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
-
+			var sum_cancel_count int64
+			sum_cancel_count += item.Count * medical.MinNumber
 			service.ModifyDrugMaxNumberWarehouseInfo(item.BatchNumberId, item.Count, item.OrgId)
+			//退库数量减少
+			//service.ModifyDrugCancelWarehouseInfo(item.DrugId,sum_cancel_count,item.OrgId,item.StorehouseId)
+			//出库数量增加
+			service.ModifyAddDrugOutAddInfomation(item.DrugId, sum_cancel_count, item.OrgId, item.StorehouseId)
+
 		}
 		if item.MaxUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
 
 			service.ModifyDrugMinNumberWarehouseInfo(item.BatchNumberId, item.Count, item.OrgId)
+			//退库数量减少
+			//service.ModifyDrugCancelWarehouseInfo(item.DrugId,item.Count,item.OrgId,item.StorehouseId)
+			//出库数量增加
+			service.ModifyAddDrugOutAddInfomation(item.DrugId, item.Count, item.OrgId, item.StorehouseId)
 		}
 		if item.MaxUnit == medical.MaxUnit && medical.MaxUnit == medical.MinUnit {
 			service.ModifyDrugMaxNumberWarehouseInfo(item.BatchNumberId, item.Count, item.OrgId)
+			//退库数量减少
+			//service.ModifyDrugCancelWarehouseInfo(item.DrugId,item.Count,item.OrgId,item.StorehouseId)
+			//出库数量增加
+			service.ModifyAddDrugOutAddInfomation(item.DrugId, item.Count, item.OrgId, item.StorehouseId)
 		}
 		stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.OrgId, item.DrugId)
 		var sum_count int64
 			sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
 		}
 		service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.OrgId)
+
+		var cancel_count int64
+		if item.MaxUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
+			cancel_count = item.Count * medical.MinNumber
+		}
+		if item.MaxUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
+			cancel_count = item.Count
+		}
+
+		if item.MaxUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
+			cancel_count = item.Count * medical.MinNumber
+		}
+		cancelInfo, _ := service.GetDrugAllStockInfo(item.StorehouseId, item.OrgId, item.DrugId)
+		var over_count int64
+		for _, items := range cancelInfo {
+			over_count += items.StockMaxNumber*medical.MinNumber + items.StockMinNumber
+		}
+		//退库数量减少，更新剩余库存
+		service.ReduceCancelSumCount(item.StorehouseId, item.DrugId, item.OrgId, cancel_count, over_count)
 	}
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{

controllers/gobal_config_api_controller.go

 	orgId := c.GetAdminUserInfo().CurrentOrgId
 
 	outList, total, err := service.GetDrugStockOutFlow(drug_id, startTime, endTime, page, limit, orgId, stock_type)
-	fmt.Println("outList22233333333333333333333", outList)
+
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
 		return
 	orgId := c.GetAdminUserInfo().CurrentOrgId
 	limit, _ := c.GetInt64("limit")
 	page, _ := c.GetInt64("page")
-	detail, total, err := service.GetBatchOrderDetail(drug_id, orgId, page, limit)
+	start_time := c.GetString("start_time")
+	end_time := c.GetString("end_time")
+	start_first_time := c.GetString("start_first_time")
+	end_first_time := c.GetString("end_first_time")
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	var startTime int64
+	if len(start_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+		if err != nil {
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		startTime = theTime.Unix()
+	}
+	var endTime int64
+	if len(end_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		endTime = theTime.Unix()
+	}
+
+	var startFistTime int64
+	if len(start_first_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_first_time+" 00:00:00", loc)
+		if err != nil {
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		startFistTime = theTime.Unix()
+	}
+	var endFirstTime int64
+	if len(end_first_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_first_time+" 23:59:59", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		endFirstTime = theTime.Unix()
+	}
+	detail, total, err := service.GetBatchOrderDetail(drug_id, orgId, page, limit, startTime, endTime, startFistTime, endFirstTime)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
 
 	drug, _ := service.GetBaseDrugMedical(drug_id)
 	orgId := c.GetAdminUserInfo().CurrentOrgId
 
 	list, err := service.GetSingleOrderDetail(id, orgId)
-
+	drugoutlist, _ := service.GetDrugWarehouseOutDetailSeventy(id, orgId)
 	dealerList, err := service.GetAllDealerList(orgId)
 	manufacturerList, err := service.GetAllManufacturerList(orgId)
 	drugFlowList, _ := service.GetDrugStockFlowDetail(start_time, orgId)
 	flowlist, _ := service.GetSingeOrderFlow(id, orgId)
+	drugList, _ := service.GetDrugFlowList(id, orgId)
+	drugListOne, _ := service.GetDrugFlowListGroupByIdOne(id, orgId)
+	drugListFlow, err := service.GetDrugFlowListGroupById(id, orgId)
 
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
 		"manufacturerList": manufacturerList,
 		"drugFlowList":     drugFlowList,
 		"flowlist":         flowlist,
+		"drugList":         drugList,
+		"drugListFlow":     drugListFlow,
+		"drugListOne":      drugListOne,
+		"drugoutlist":      drugoutlist,
 	})
 }
 

controllers/his_api_controller.go

 
 											}
 											pharmacyConfig, _ := service.FindPharmacyConfig(adminInfo.CurrentOrgId)
+											fmt.Println("device_number2333233232323222323232323323322332", device_number)
+											fmt.Println("number_count99999999999999999999999999999999999", number_count)
 											if pharmacyConfig.IsOpen != 1 {
 												if device_number != number_count {
 
 													if druginfo.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
 
 														service.ModefyDrugByWarehouseInfo(druginfo.WarehouseInfoId, number_count)
+
 													}
 													if druginfo.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
 														var stock_max_number int64
 
 															stock_max_number = device_number / drug.MinNumber
 															service.ModefyDrugByWarehouseInfo(druginfo.WarehouseInfoId, stock_max_number)
+
 															stock_min_number = device_number % drug.MinNumber
 															service.ModefyDrugByWarehouseInfoOne(druginfo.WarehouseInfoId, stock_min_number)
 
 														} else {
 
 															service.ModefyDrugByWarehouseInfoOne(druginfo.WarehouseInfoId, device_number)
+
 														}
 													}
 
 													if druginfo.CountUnit == drug.MaxUnit && druginfo.CountUnit == drug.MinUnit && drug.MaxUnit == drug.MinUnit {
 														service.ModefyDrugByWarehouseInfo(druginfo.WarehouseInfoId, device_number)
+
 													}
 													//删除记录
 													service.DeleteDrugAutoWarehouseSeven(drug_id, patient_id, recordDateTime, adviceId)
 
 										for _, item := range goodList {
 											//回退库存
-											service.ModefyWarehouseInfo(item.Count, item.WarehouseInfotId)
+											//service.ModefyWarehouseInfo(item.Count, item.WarehouseInfotId)
+
+											//service.ModifyReduceGoodSumCount(item.StorehouseId,item.Count,item.OrgId,item.GoodId)
+
+											goodListSix, _ := service.GetSumGoodList(item.OrgId, item.StorehouseId, item.GoodId)
+											var flush_count int64
+											for _, it := range goodListSix {
+												flush_count += it.StockCount
+											}
+											errs := service.UpdateSumGood(item.OrgId, item.StorehouseId, item.GoodId, flush_count)
+											creater := adminInfo.AdminUser.Id
+											if errs != nil {
+												goodErrcode := models.XtGoodErrcode{
+													UserOrgId:      item.OrgId,
+													Errcode:        "手动出库更新剩余出库失败",
+													GoodId:         item.GoodId,
+													Status:         1,
+													Ctime:          time.Now().Unix(),
+													Mtime:          0,
+													Count:          0,
+													StockCount:     0,
+													Creater:        creater,
+													BatchNumberId:  0,
+													WarehouseOutId: 0,
+												}
+												service.CreateGoodErrcode(goodErrcode)
+											}
+
 										}
 										//删除记录
 										service.DeleteAutoWarehouse(patient_id, recordDateTime)
+
 									}
 									if len(goodWarehouseInfo) > 0 {
 										//查询该患者耗材的历史数据
 
 											for _, item := range goodList {
 												//回退库存
-												service.ModefyWarehouseInfo(item.Count, item.WarehouseInfotId)
-
+												//service.ModefyWarehouseInfo(item.Count, item.WarehouseInfotId)
+												//扣减出库数量
+												//service.ModifyReduceGoodSumCount(item.StorehouseId,item.Count,item.OrgId,item.GoodId)
+
+												goodListSix, _ := service.GetSumGoodList(item.OrgId, item.StorehouseId, item.GoodId)
+												var flush_count int64
+												for _, it := range goodListSix {
+													flush_count += it.StockCount
+												}
+												errs := service.UpdateSumGood(item.OrgId, item.StorehouseId, item.GoodId, flush_count)
+
+												//减少出库数量
+												creater := adminInfo.AdminUser.Id
+												if errs != nil {
+													goodErrcode := models.XtGoodErrcode{
+														UserOrgId:      item.OrgId,
+														Errcode:        "手动出库更新剩余出库失败",
+														GoodId:         item.GoodId,
+														Status:         1,
+														Ctime:          time.Now().Unix(),
+														Mtime:          0,
+														Count:          0,
+														StockCount:     0,
+														Creater:        creater,
+														BatchNumberId:  0,
+														WarehouseOutId: 0,
+													}
+													service.CreateGoodErrcode(goodErrcode)
+												}
 												//查询默认仓库
 												stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeConfig.StorehouseOutInfo, item.OrgId)
 												var total_count int64
 												//基础库插入数据
 												service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, item.OrgId)
 											}
+
 											//删除记录
 											service.DeleteAutoWarehouse(patient_id, recordDateTime)
 
 					for _, it := range druginfo {
 
 						if it.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
+
 							service.ModifyDrugWarehouseInfoStockMaxNumber(it.Count, it.DrugId, it.OrgId, it.WarehouseInfoId)
+
 						}
 						if it.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
 							service.ModifyDrugWarehouseInfoStockMinNumber(it.Count, it.DrugId, it.OrgId, it.WarehouseInfoId)
+
 						}
 						if it.CountUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
 
 							service.ModifyDrugWarehouseInfoStockMaxNumber(it.Count, it.DrugId, it.OrgId, it.WarehouseInfoId)
+
 						}
 					}
 				}
 
 				//删除记录
 				service.DeleteDrugAutoWarehouseSeven(item.DrugId, patient_id, recordDateTime, item.ID)
+				//查询最后一次数据
 				if drugOutConfig.IsOpen == 1 {
 					//出库
 					if drug.IsUse == 2 {
 					stockInfo, _ := service.GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
 					var sum_count int64
 					for _, its := range stockInfo {
-						sum_count += its.StockMaxNumber*drug.MinNumber + its.StockMinNumber
+						baseDrug, _ := service.GetBaseDrugMedical(its.DrugId)
+						if its.MaxUnit == baseDrug.MaxUnit {
+							its.StockMaxNumber = its.StockMaxNumber * baseDrug.MinNumber
+						}
+						sum_count += its.StockMaxNumber + its.StockMinNumber
 					}
 					service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
+					//剩余库存
+					service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeConfig.DrugStorehouseOut, sum_count)
 				}
 			}
 		}
 					info, _ := service.GetLastWarehoseByGoodId(item.ProjectId, item.PatientId, item.RecordDate)
 					manufacturer, _ := service.GetManufactureById(info.Manufacturer)
 					deaerler, _ := service.GetDealerById(info.Dealer)
+
+					//查询今日该患者开了多少耗材
+					//projectList, _ := service.GetHisPrepscritionByPatientId(info.PatientId, item.ProjectId, info.SysRecordTime)
+					//
+					var total_count int64
+					//var cha_count int64
+					//for _, item := range projectList {
+					//  count, _ := strconv.ParseInt(item.Count, 10, 64)
+					//  total_count += count
+					//}
+					count, _ := strconv.ParseInt(item.Count, 10, 64)
+					total_count += count
+					//回退库存
+					service.UpDateWarehouseInfoByStockDelete(info.WarehouseInfotId, total_count, info.PatientId, info.SysRecordTime, info.ProjectId)
+					goodList, _ := service.GetSumGoodList(c.GetAdminUserInfo().CurrentOrgId, houseConfig.StorehouseOutInfo, info.ProjectId)
+					var flush_count int64
+					for _, it := range goodList {
+						flush_count += it.StockCount
+					}
 					if info.ID > 0 {
 						cancelStockInfo := models.CancelStockInfo{
 							GoodId:          item.ProjectId,
 						cancelInfo, _ := service.GetLastCancelStockInfoByGoodId(item.ProjectId)
 
 						flow := models.VmStockFlow{
-							WarehousingId:           0,
+							WarehousingId:           info.WarehouseInfotId,
 							GoodId:                  item.ProjectId,
 							Number:                  info.Number,
 							LicenseNumber:           info.LicenseNumber,
 							ConsumableType:          7,
 							IsSys:                   0,
 							WarehousingOrder:        "",
-							WarehouseOutId:          0,
+							WarehouseOutId:          info.WarehouseOutId,
 							WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
 							IsEdit:                  0,
 							CancelStockId:           cancel.ID,
 							Mtime:                   0,
 							Price:                   info.Price,
 							WarehousingDetailId:     info.WarehouseInfotId,
-							WarehouseOutDetailId:    0,
+							WarehouseOutDetailId:    info.ID,
 							CancelOutDetailId:       cancelInfo.ID,
 							ProductDate:             info.ProductDate,
 							ExpireDate:              info.ExpiryDate,
 							StorehouseId:            houseConfig.StorehouseOutInfo,
+							OverCount:               flush_count,
 						}
 						service.CreateStockFlowOne(flow)
 
-						//删除出库表
-						service.DeleteAutoRedeceDetailTen(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, item.ProjectId)
-
-						//查询今日该患者开了多少耗材
-						projectList, _ := service.GetHisPrepscritionByPatientId(info.PatientId, item.ProjectId, info.SysRecordTime)
+						//查询已出库数量
+						dialysisInfo, _ := service.GetGoodDialysisOutInfo(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, item.ProjectId)
 
-						var total_count int64
-						var cha_count int64
-						for _, item := range projectList {
-							count, _ := strconv.ParseInt(item.Count, 10, 64)
-							total_count += count
+						if prescribingNumber < dialysisInfo.Count {
+							//改变数量
+							service.UpdateAutoGood(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, item.ProjectId, item.ID, prescribingNumber)
 						}
-						//回退库存
-						service.UpDateWarehouseInfoByStockDelete(info.WarehouseInfotId, total_count)
 
-						//查询今日该耗材退库数量
-						cancelInfoOne, _ := service.GetCancelStockInfoByPatientId(info.PatientId, item.ProjectId, info.SysRecordTime)
-						var cancel_Count int64
-						for _, items := range cancelInfoOne {
-							cancel_Count += items.Count
+						if prescribingNumber == dialysisInfo.Count {
+							//删除出库表
+							service.DeleteAutoRedeceDetailTen(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, item.ProjectId)
 						}
 
-						cha_count = total_count - cancel_Count
-
-						if total_count > cancel_Count {
-
-							out, err := service.FindStockOutByIsSys(c.GetAdminUserInfo().CurrentOrgId, 1, info.SysRecordTime)
-							if err == gorm.ErrRecordNotFound {
-								//没有记录，则创建出库单
-								timeStr := time.Now().Format("2006-01-02")
-								timeArr := strings.Split(timeStr, "-")
-								total, _ := service.FindAllWarehouseOut(c.GetAdminUserInfo().CurrentOrgId)
-								total = total + 1
-								warehousing_out_order := strconv.FormatInt(c.GetAdminUserInfo().CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
-								number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
-								number = number + total
-								warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
-								warehouseOut := models.WarehouseOut{
-									WarehouseOutOrderNumber: warehousing_out_order,
-									OperationTime:           time.Now().Unix(),
-									OrgId:                   c.GetAdminUserInfo().CurrentOrgId,
-									Creater:                 creater,
-									Ctime:                   time.Now().Unix(),
-									Status:                  1,
-									WarehouseOutTime:        info.SysRecordTime,
-									Dealer:                  0,
-									Manufacturer:            0,
-									Type:                    1,
-									IsSys:                   1,
-									StorehouseId:            houseConfig.StorehouseOutInfo,
-									IsCheck:                 1,
-								}
-								err := service.AddSigleWarehouseOut(&warehouseOut)
-								if err != nil {
-									utils.TraceLog("创建出库单失败 err = %v", err)
-									return
-								}
-								prepare := &models.DialysisBeforePrepare{
-									UserOrgId:    c.GetAdminUserInfo().CurrentOrgId,
-									PatientId:    info.PatientId,
-									RecordDate:   info.SysRecordTime,
-									GoodId:       item.ProjectId,
-									GoodTypeId:   info.GoodTypeId,
-									Count:        cha_count,
-									StorehouseId: houseConfig.StorehouseOutInfo,
-								}
-								//出库
-								service.ConsumablesDelivery(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, prepare, &warehouseOut, cha_count)
-							} else if err == nil {
-
-								prepare := &models.DialysisBeforePrepare{
-									UserOrgId:    c.GetAdminUserInfo().CurrentOrgId,
-									PatientId:    info.PatientId,
-									RecordDate:   info.SysRecordTime,
-									GoodId:       item.ProjectId,
-									GoodTypeId:   info.GoodTypeId,
-									Count:        cha_count,
-									StorehouseId: houseConfig.StorehouseOutInfo,
-								}
-								//出库
-								service.ConsumablesDelivery(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, prepare, &out, cha_count)
-							}
+						////删除出库表
+						//service.DeleteAutoRedeceDetailTen(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, item.ProjectId)
 
-						}
+						//退库数量增加
+						service.UpdateSumAddCancelCount(c.GetAdminUserInfo().CurrentOrgId, item.ProjectId, houseConfig.StorehouseOutInfo, total_count)
+						//出库数量减少
+						service.UpdateSumCount(c.GetAdminUserInfo().CurrentOrgId, houseConfig.StorehouseOutInfo, item.ProjectId, total_count)
+
+						//更新库存
+						service.UpdateSumGood(c.GetAdminUserInfo().CurrentOrgId, houseConfig.StorehouseOutInfo, item.ProjectId, flush_count)
+
+						//查询今日该耗材退库数量
+						//cancelInfoOne, _ := service.GetCancelStockInfoByPatientId(info.PatientId, item.ProjectId, info.SysRecordTime)
+						//var cancel_Count int64
+						//for _, items := range cancelInfoOne {
+						//	cancel_Count += items.Count
+						//}
+						//
+						//cha_count = total_count - cancel_Count
+						//
+						//if total_count > cancel_Count {
+						//
+						//	out, err := service.FindStockOutByIsSys(c.GetAdminUserInfo().CurrentOrgId, 1, info.SysRecordTime)
+						//	if err == gorm.ErrRecordNotFound {
+						//		//没有记录，则创建出库单
+						//		timeStr := time.Now().Format("2006-01-02")
+						//		timeArr := strings.Split(timeStr, "-")
+						//		total, _ := service.FindAllWarehouseOut(c.GetAdminUserInfo().CurrentOrgId)
+						//		total = total + 1
+						//		warehousing_out_order := strconv.FormatInt(c.GetAdminUserInfo().CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
+						//		number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
+						//		number = number + total
+						//		warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
+						//		warehouseOut := models.WarehouseOut{
+						//			WarehouseOutOrderNumber: warehousing_out_order,
+						//			OperationTime:           time.Now().Unix(),
+						//			OrgId:                   c.GetAdminUserInfo().CurrentOrgId,
+						//			Creater:                 creater,
+						//			Ctime:                   time.Now().Unix(),
+						//			Status:                  1,
+						//			WarehouseOutTime:        info.SysRecordTime,
+						//			Dealer:                  0,
+						//			Manufacturer:            0,
+						//			Type:                    1,
+						//			IsSys:                   1,
+						//			StorehouseId:            houseConfig.StorehouseOutInfo,
+						//			IsCheck:                 1,
+						//		}
+						//		err := service.AddSigleWarehouseOut(&warehouseOut)
+						//		if err != nil {
+						//			utils.TraceLog("创建出库单失败 err = %v", err)
+						//			return
+						//		}
+						//		prepare := &models.DialysisBeforePrepare{
+						//			UserOrgId:    c.GetAdminUserInfo().CurrentOrgId,
+						//			PatientId:    info.PatientId,
+						//			RecordDate:   info.SysRecordTime,
+						//			GoodId:       item.ProjectId,
+						//			GoodTypeId:   info.GoodTypeId,
+						//			Count:        cha_count,
+						//			StorehouseId: houseConfig.StorehouseOutInfo,
+						//		}
+						//		//出库
+						//		service.ConsumablesDelivery(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, prepare, &warehouseOut, cha_count)
+						//	} else if err == nil {
+						//
+						//		prepare := &models.DialysisBeforePrepare{
+						//			UserOrgId:    c.GetAdminUserInfo().CurrentOrgId,
+						//			PatientId:    info.PatientId,
+						//			RecordDate:   info.SysRecordTime,
+						//			GoodId:       item.ProjectId,
+						//			GoodTypeId:   info.GoodTypeId,
+						//			Count:        cha_count,
+						//			StorehouseId: houseConfig.StorehouseOutInfo,
+						//		}
+						//		//出库
+						//		service.ConsumablesDelivery(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, prepare, &out, cha_count)
+						//	}
+						//
+						//}
 
 					}
 
 		}
 	}
 	if drugStockConfig.IsOpen == 1 {
-		fmt.Println("woowowowowowowowowowowowowowo", len(advices))
 		if len(advices) > 0 {
 			for _, item := range advices {
 				creater := c.GetAdminUserInfo().AdminUser.Id
 	redis.Set(keyOne, "", time.Second)
 
 	defer redis.Close()
+
 	if err == nil {
 		if drugStockConfig.IsOpen == 1 {
 
 			//查询是否在处方中出库
 			openConfig, _ := service.GetDrugOpenConfigOne(c.GetAdminUserInfo().CurrentOrgId)
+
 			if openConfig.IsOpen != 1 {
 
 				//判断该医嘱是否执行了
 				if advice.ExecutionState == 1 {
 					creater := c.GetAdminUserInfo().AdminUser.Id
 					service.DrugAutoAddCancelInfo(&advice, creater)
+
 				}
+
 			}
 
 			//开启保存处方扣减功能
 				ReturnTime:   project.RecordDate,
 				Type:         1,
 				StorehouseId: houseConfig.StorehouseOutInfo,
+				IsCheck:      1,
 			}
 			_, msgerrkonde := service.GetCancelStockDetailByOrderNumberOne(project.RecordDate, adminInfo.CurrentOrgId)
 			if msgerrkonde == gorm.ErrRecordNotFound {
 			cancel, _ := service.GetLastCancelStockById(adminInfo.CurrentOrgId)
 			floatPrescrip := strconv.FormatFloat(f_count, 'f', -1, 32)
 			prescribingNumber, _ := strconv.ParseInt(floatPrescrip, 10, 64)
-			//获取该耗材有库存的第一条数据
+			//获取出库数据
 			info, _ := service.GetLastWarehoseByGoodId(project.ProjectId, project.PatientId, project.RecordDate)
 
 			manufacturer, _ := service.GetManufactureById(info.Manufacturer)
 					PatientId:       info.PatientId,
 					RecordDate:      info.SysRecordTime,
 					StorehouseId:    houseConfig.StorehouseOutInfo,
+					IsCheck:         1,
 				}
 
 				service.CreateCancelStockInfoOne(&cancelStockInfo)
 
 				cancelInfo, _ := service.GetLastCancelStockInfoByGoodId(project.ProjectId)
 
+				//回退库存
+				service.UpDateWarehouseInfoByStockDelete(info.WarehouseInfotId, prescribingNumber, info.PatientId, info.SysRecordTime, project.ProjectId)
+				goodList, _ := service.GetSumGoodList(adminInfo.CurrentOrgId, houseConfig.StorehouseOutInfo, project.ProjectId)
+				var over_count int64
+				for _, it := range goodList {
+					over_count += it.StockCount
+				}
 				flow := models.VmStockFlow{
-					WarehousingId:           0,
+					WarehousingId:           info.WarehouseInfotId,
 					GoodId:                  project.ProjectId,
 					Number:                  info.Number,
 					LicenseNumber:           info.LicenseNumber,
 					ConsumableType:          7,
 					IsSys:                   0,
 					WarehousingOrder:        "",
-					WarehouseOutId:          0,
-					WarehouseOutOrderNumber: "",
+					WarehouseOutId:          info.WarehouseOutId,
+					WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
 					IsEdit:                  0,
 					CancelStockId:           cancel.ID,
 					CancelOrderNumber:       cancel.OrderNumber,
 					Mtime:                   0,
 					Price:                   info.Price,
 					WarehousingDetailId:     info.WarehouseInfotId,
-					WarehouseOutDetailId:    0,
+					WarehouseOutDetailId:    info.ID,
 					CancelOutDetailId:       cancelInfo.ID,
 					ProductDate:             info.ProductDate,
 					ExpireDate:              info.ExpiryDate,
 					StorehouseId:            houseConfig.StorehouseOutInfo,
+					OverCount:               over_count,
 				}
 				service.CreateStockFlowOne(flow)
 
-				//删除出库表
-				service.DeleteAutoRedeceDetailTen(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, project.ProjectId)
+				//查询已出库数量
+				dialysisInfo, _ := service.GetGoodDialysisOutInfo(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, project.ProjectId)
 
-				//查询今日该患者开了多少耗材
-				projectList, _ := service.GetHisPrepscritionByPatientId(info.PatientId, project.ProjectId, info.SysRecordTime)
-
-				var total_count int64
-				var cha_count int64
-				for _, item := range projectList {
-					count, _ := strconv.ParseInt(item.Count, 10, 64)
-					total_count += count
+				if prescribingNumber < dialysisInfo.Count {
+					//改变数量
+					service.UpdateAutoGood(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, project.ProjectId, id, prescribingNumber)
 				}
-				//回退库存
-				service.UpDateWarehouseInfoByStockDelete(info.WarehouseInfotId, total_count)
-
-				//查询今日该耗材退库数量
-				cancelInfoOne, _ := service.GetCancelStockInfoByPatientId(info.PatientId, project.ProjectId, info.SysRecordTime)
-				var cancel_count int64
-				for _, items := range cancelInfoOne {
-					cancel_count += items.Count
-				}
-
-				cha_count = total_count - cancel_count
-
-				if total_count > cancel_count {
-
-					out, err := service.FindStockOutByIsSys(adminInfo.CurrentOrgId, 1, info.SysRecordTime)
-					if err == gorm.ErrRecordNotFound {
-						//没有记录，则创建出库单
-						timeStr := time.Now().Format("2006-01-02")
-						timeArr := strings.Split(timeStr, "-")
-						total, _ := service.FindAllWarehouseOut(adminInfo.CurrentOrgId)
-						total = total + 1
-						warehousing_out_order := strconv.FormatInt(adminInfo.CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
-						number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
-						number = number + total
-						warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
-						warehouseOut := models.WarehouseOut{
-							WarehouseOutOrderNumber: warehousing_out_order,
-							OperationTime:           time.Now().Unix(),
-							OrgId:                   adminInfo.CurrentOrgId,
-							Creater:                 creater,
-							Ctime:                   time.Now().Unix(),
-							Status:                  1,
-							WarehouseOutTime:        info.SysRecordTime,
-							Dealer:                  0,
-							Manufacturer:            0,
-							Type:                    1,
-							IsSys:                   1,
-							StorehouseId:            houseConfig.StorehouseOutInfo,
-						}
-						err := service.AddSigleWarehouseOut(&warehouseOut)
-						if err != nil {
-							utils.TraceLog("创建出库单失败 err = %v", err)
-							return
-						}
-						prepare := &models.DialysisBeforePrepare{
-							UserOrgId:    adminInfo.CurrentOrgId,
-							PatientId:    info.PatientId,
-							RecordDate:   info.SysRecordTime,
-							GoodId:       project.ProjectId,
-							GoodTypeId:   info.GoodTypeId,
-							Count:        cha_count,
-							StorehouseId: houseConfig.StorehouseOutInfo,
-						}
-						//出库
-						service.ConsumablesDelivery(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, prepare, &warehouseOut, cha_count)
-					} else if err == nil {
-						prepare := &models.DialysisBeforePrepare{
-							UserOrgId:    adminInfo.CurrentOrgId,
-							PatientId:    info.PatientId,
-							RecordDate:   info.SysRecordTime,
-							GoodId:       project.ProjectId,
-							GoodTypeId:   info.GoodTypeId,
-							Count:        cha_count,
-							StorehouseId: houseConfig.StorehouseOutInfo,
-						}
-						//出库
-						service.ConsumablesDelivery(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, prepare, &out, cha_count)
-					}
 
+				if prescribingNumber == dialysisInfo.Count {
+					//删除出库表
+					service.DeleteAutoRedeceDetailTen(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, project.ProjectId)
 				}
 
+				//退库数量增加
+				service.UpdateSumAddCancelCount(adminInfo.CurrentOrgId, project.ProjectId, houseConfig.StorehouseOutInfo, prescribingNumber)
+				//出库数量减少
+				service.UpdateSumCount(adminInfo.CurrentOrgId, houseConfig.StorehouseOutInfo, project.ProjectId, prescribingNumber)
+
+				//更新剩余库存
+				service.UpdateSumGood(adminInfo.CurrentOrgId, houseConfig.StorehouseOutInfo, project.ProjectId, over_count)
+				//查询今日该患者开了多少耗材
+				//projectList, _ := service.GetHisPrepscritionByPatientId(info.PatientId, project.ProjectId, info.SysRecordTime)
+				//
+				//var total_count int64
+				//var cha_count int64
+				//for _, item := range projectList {
+				//	count, _ := strconv.ParseInt(item.Count, 10, 64)
+				//	total_count += count
+				//}
+				//
+				////查询今日该耗材退库数量
+				//cancelInfoOne, _ := service.GetCancelStockInfoByPatientId(info.PatientId, project.ProjectId, info.SysRecordTime)
+				//var cancel_count int64
+				//for _, items := range cancelInfoOne {
+				//	cancel_count += items.Count
+				//}
+				//
+				//cha_count = total_count - cancel_count
+				//
+				//if total_count > cancel_count {
+				//
+				//	out, err := service.FindStockOutByIsSys(adminInfo.CurrentOrgId, 1, info.SysRecordTime)
+				//	if err == gorm.ErrRecordNotFound {
+				//		//没有记录，则创建出库单
+				//		timeStr := time.Now().Format("2006-01-02")
+				//		timeArr := strings.Split(timeStr, "-")
+				//		total, _ := service.FindAllWarehouseOut(adminInfo.CurrentOrgId)
+				//		total = total + 1
+				//		warehousing_out_order := strconv.FormatInt(adminInfo.CurrentOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
+				//		number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
+				//		number = number + total
+				//		warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
+				//		warehouseOut := models.WarehouseOut{
+				//			WarehouseOutOrderNumber: warehousing_out_order,
+				//			OperationTime:           time.Now().Unix(),
+				//			OrgId:                   adminInfo.CurrentOrgId,
+				//			Creater:                 creater,
+				//			Ctime:                   time.Now().Unix(),
+				//			Status:                  1,
+				//			WarehouseOutTime:        info.SysRecordTime,
+				//			Dealer:                  0,
+				//			Manufacturer:            0,
+				//			Type:                    1,
+				//			IsSys:                   1,
+				//			StorehouseId:            houseConfig.StorehouseOutInfo,
+				//		}
+				//		err := service.AddSigleWarehouseOut(&warehouseOut)
+				//		if err != nil {
+				//			utils.TraceLog("创建出库单失败 err = %v", err)
+				//			return
+				//		}
+				//		prepare := &models.DialysisBeforePrepare{
+				//			UserOrgId:    adminInfo.CurrentOrgId,
+				//			PatientId:    info.PatientId,
+				//			RecordDate:   info.SysRecordTime,
+				//			GoodId:       project.ProjectId,
+				//			GoodTypeId:   info.GoodTypeId,
+				//			Count:        cha_count,
+				//			StorehouseId: houseConfig.StorehouseOutInfo,
+				//		}
+				//		//出库
+				//		service.ConsumablesDelivery(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, prepare, &warehouseOut, cha_count)
+				//	} else if err == nil {
+				//		prepare := &models.DialysisBeforePrepare{
+				//			UserOrgId:    adminInfo.CurrentOrgId,
+				//			PatientId:    info.PatientId,
+				//			RecordDate:   info.SysRecordTime,
+				//			GoodId:       project.ProjectId,
+				//			GoodTypeId:   info.GoodTypeId,
+				//			Count:        cha_count,
+				//			StorehouseId: houseConfig.StorehouseOutInfo,
+				//		}
+				//		//出库
+				//		service.ConsumablesDelivery(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, prepare, &out, cha_count)
+				//	}
+				//
+				//}
+
 				stockList, _ := service.GetStockCountByGoodId(project.ProjectId, houseConfig.StorehouseOutInfo, project.UserOrgId)
 				var total_count_one int64
 				for _, it := range stockList {
 					total_count_one += it.StockCount
 				}
 				//基础库插入数据
-				service.UpdateGoodInfoSumCount(project.ProjectId, total_count_one, project.UserOrgId)
+				service.UpdateGoodInfoSumCountSix(project.ProjectId, total_count_one, project.UserOrgId)
+
+				goodListOne, _ := service.GetSumGoodList(project.UserOrgId, houseConfig.StorehouseOutInfo, project.ProjectId)
+				var flush_count int64
+				for _, it := range goodListOne {
+					flush_count += it.StockCount
+				}
+				errs := service.UpdateSumGood(project.UserOrgId, houseConfig.StorehouseOutInfo, project.ProjectId, flush_count)
+				if errs != nil {
+					goodErrcode := models.XtGoodErrcode{
+						UserOrgId:      project.UserOrgId,
+						Errcode:        "手动出库更新剩余出库失败",
+						GoodId:         project.ProjectId,
+						Status:         1,
+						Ctime:          time.Now().Unix(),
+						Mtime:          0,
+						Count:          0,
+						StockCount:     0,
+						Creater:        creater,
+						BatchNumberId:  0,
+						WarehouseOutId: 0,
+					}
+					service.CreateGoodErrcode(goodErrcode)
+				}
 			}
 			err := service.DelelteProject(id, c.GetAdminUserInfo().CurrentOrgId)
 			fmt.Println(err)
 
 	patient, _ := service.GetPatientByID(adminUser.CurrentOrgId, patient_id)
 
-	//prescriptions, _ := service.GetHisPrescriptionThree(adminUser.CurrentOrgId, patient_id, order.Number)
-
 	var bedCostTotal float64 = 0         //床位总费
 	var bedCostSelfTotal float64 = 0     //床位自费
 	var bedCostPartSelfTotal float64 = 0 //床位部分项目自费

controllers/mobile_api_controllers/check_weight_api_controller.go

 			dialysisSolution, _ = service.MobileGetDialysisSolutionByModeIdSix(adminUserInfo.Org.Id, id, schedual.ModeId)
 			system_dialysisPrescribe, _ = service.MobileGetSystemDialysisPrescribeByModeIdSix(adminUserInfo.Org.Id, schedual.ModeId)
 			lastDialysisPrescribe, _ = service.MobileGetLastDialysisPrescribeByModeIdSix(adminUserInfo.Org.Id, id, schedual.ModeId)
+
+			//判断透析模式,针对河间咸的
+			if adminUserInfo.Org.Id == 10090 {
+				if dialysisSolution.ModeId != 2 && dialysisSolution.ModeId != 5 && dialysisSolution.ModeId != 12 {
+					dialysisSolution.DisplaceLiquiPart = 0
+					dialysisSolution.DisplaceLiquiValue = 0
+				}
+				if lastDialysisPrescribe.ModeId != 2 && lastDialysisPrescribe.ModeId != 5 && lastDialysisPrescribe.ModeId != 12 {
+					dialysisSolution.DisplaceLiquiPart = 0
+					dialysisSolution.DisplaceLiquiValue = 0
+				}
+			}
+
 			mode_id = schedual.ModeId
 		} else {
 			// 获取透析模版

controllers/mobile_api_controllers/mobile_api_router_register.go

 	beego.Router("/m/api/dialysisbeforeprepare/edit", &DialysisAPIController{}, "Post:EditConsumables")
 
 	beego.Router("/m/api/stockout/create", &DialysisAPIController{}, "Post:CreateStockOutInfo")
-	//beego.Router("/m/api/stockout/edit", &DialysisAPIController{}, "Post:EditStockOutInfo")
 
 	beego.Router("/m/api/otherstockout/create", &DialysisAPIController{}, "Post:CreateOtherStockOutInfo")
 
 
 	beego.Router("/m/api/getrolelist", &DialysisAPIController{}, "Get:GetRoleList")
 
+	beego.Router("/m/api/savepatientsign", &DialysisAPIController{}, "Post:SavePatientSign")
+	beego.Router("/m/api/getpatientsign", &DialysisAPIController{}, "Get:GetPatientSign")
+
 }

controllers/patient_api_controller.go

 
 	beego.Router("/api/patients/banner", &PatientApiController{}, "Get:GetBanner")
 
+	//长期医嘱新接口
+	beego.Router("/api/patient/findepatientdialysislongsolutions", &PatientApiController{}, "Get:GetPatientDialysisLongSolution")
+	beego.Router("/api/patient/getdialysissolutiondetaillist", &PatientApiController{}, "Get:GetDialysisSolutionDetailList")
+
 }
 
 //GetPatientsList 取患者列表
 	solution.UpdatedTime = time.Now().Unix()
 	solution.SubName = ""
 	solution.ParentId = 0
+	solution.SolutionStatus = 1
 
 	err := service.CreatePatientDialysisSolution(&solution)
+
+	//获取最新1条
+	dialysisSolution, _ := service.GetLastPatientDialysisSolution(id, adminUserInfo.CurrentOrgId)
+
+	//更新状态
+	service.UpdateDialysisSolutionStatusTwo(dialysisSolution.ID, dialysisSolution.ModeId, dialysisSolution.UserOrgId, dialysisSolution.PatientId)
+
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionCreate)
 		return
 							if medical.IsUse == 2 {
 								//是通过药房发药
 								if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
+									//执行出库
 									service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
 								}
 								//不通过药房发药
 								if pharmacyConfig.IsOpen != 1 {
+									//执行出库
 									service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
 								}
 
 								fmt.Println("pharmacyConfig23232332322323", pharmacyConfig.IsOpen, medical.IsPharmacy)
 								if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
 									service.HisDrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
+
 								}
 								//不通过药房发药
 								if pharmacyConfig.IsOpen != 1 {
 									sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
 								}
 								service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
+
+								//出库数量累加
+								//service.AddDrugCount(item.DrugId,item.UserOrgId,storeHouseConfig.DrugStorehouseOut,prescribing_number_total)
+								//剩余库存
+								service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
 								break
 								c.ServeSuccessJSON(map[string]interface{}{
 									"msg":    "1",
 		})
 	}
 }
+
+func (c *PatientApiController) GetPatientDialysisLongSolution() {
+
+	patient_id, _ := c.GetInt64("id", 0)
+	page, _ := c.GetInt64("page", 0)
+	limit, _ := c.GetInt64("limit", 0)
+	if patient_id <= 0 {
+		c.ServeSuccessJSON(map[string]interface{}{
+			"solutions": nil,
+		})
+		return
+	}
+	if page <= 0 {
+		page = 1
+	}
+	if limit <= 0 {
+		limit = 10
+	}
+
+	adminUserInfo := c.GetAdminUserInfo()
+
+	//获取该患者分组的透析模式
+	list, _ := service.GetPatientSolutionGroupList(patient_id, adminUserInfo.CurrentOrgId)
+
+	for _, item := range list {
+		//获取该模式最新的1条数据
+		solution, _ := service.GetNewPatientSolutionByModeId(patient_id, item.ModeId, adminUserInfo.CurrentOrgId)
+
+		//更新状态值
+		service.UpdateDialysisSolutionStatus(solution.ID, item.ModeId, adminUserInfo.CurrentOrgId, patient_id)
+	}
+
+	solution, total, err := service.GetPatientDialysisLongSolution(patient_id, page, limit, adminUserInfo.CurrentOrgId)
+	stockType, _ := service.GetStockType(adminUserInfo.CurrentOrgId)
+	if err != nil {
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
+		return
+	}
+	c.ServeSuccessJSON(map[string]interface{}{
+		"solutions": solution,
+		"total":     total,
+		"stockType": stockType,
+	})
+}
+
+func (c *PatientApiController) GetDialysisSolutionDetailList() {
+
+	patient_id, _ := c.GetInt64("patient_id")
+	mode_id, _ := c.GetInt64("mode_id")
+	page, _ := c.GetInt64("page")
+	limit, _ := c.GetInt64("limit")
+	orgId := c.GetAdminUserInfo().CurrentOrgId
+	list, total, err := service.GetDialysisSolutionDetailList(orgId, patient_id, mode_id, page, limit)
+	if err != nil {
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
+		return
+	}
+	c.ServeSuccessJSON(map[string]interface{}{
+		"list":  list,
+		"total": total,
+	})
+}

controllers/pharmacy_controller.go

 		return
 	}
 	total, err := service.CalculateTheTotalAmount(listll, drug_id)
+	fmt.Println("total2322332232323232332322wo", total)
 	if err != nil {
 		utils.ErrorLog(err.Error())
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)

controllers/schedule_api_controller.go

 	weekEnd := theEndTime.Unix()
 
 	patients, _ := service.GetPatientWithScheduleAndSolution(adminInfo.CurrentOrgId, keywords, weekStart, weekEnd, schedule, contagion)
-
+	fmt.Println("patinets23233232323232232322323wode", patients)
 	c.ServeSuccessJSON(map[string]interface{}{
 		"patients": patients,
 	})

controllers/secondary_order_api_contorller.go

 		return
 	}
 	defer func() {
-		if err != nil{
-			service.SaveErrs(this.GetAdminUserInfo().CurrentOrgId,this.Ctx.Input,err)
+		if err != nil {
+			service.SaveErrs(this.GetAdminUserInfo().CurrentOrgId, this.Ctx.Input, err)
 		}
 	}()
 	var storehouse_status, admin_id int64
 					}
 					service.UpdateBaseDrugSumTwo(item.ProjectId, sum_count, item.UserOrgId)
 				}
+
 			}
 
 			//耗材
 					total_count += it.StockCount
 				}
 				//基础库插入数据
-				service.UpdateGoodInfoSumCount(item.ProjectId, total_count, orgId)
+				service.UpdateGoodInfoSumCountSix(item.ProjectId, total_count, orgId)
+			}
+		}
+	}
+
+	//获取所有的入库仓库
+	druglist, _ := service.GetDrugWarehouseInfoStorehouseList(orgId)
+	for _, item := range druglist {
+		//查询该药品该仓库是否有数据
+		drug, _ := service.GetDrugStockCout(item.DrugId, item.StorehouseId, item.OrgId)
+
+		//查询该仓库该药品的入库数量
+		medical, _ := service.GetBaseDrugMedical(item.DrugId)
+
+		var sum_in_count int64
+		var flush_count int64
+		var sum_out_count int64
+		var cancel_out_count int64
+		//查询入库数量和剩余库存
+		infolist, _ := service.GetDrugWarehouseInfoByStorehouseId(item.StorehouseId, item.DrugId, item.OrgId)
+		for _, it := range infolist {
+			if it.MaxUnit == medical.MaxUnit {
+				it.WarehousingCount = it.WarehousingCount * medical.MinNumber
+				it.StockMaxNumber = it.StockMaxNumber * medical.MinNumber
+			}
+			sum_in_count += it.WarehousingCount
+			flush_count += it.StockMaxNumber + it.StockMinNumber
+		}
+
+		//获取出库数量
+		outinfolist, _ := service.GetDrugFlowStockOutCount(item.StorehouseId, item.DrugId, item.OrgId)
+		for _, it := range outinfolist {
+			if it.MaxUnit == medical.MaxUnit {
+				it.Count = it.Count * medical.MinNumber
+			}
+			sum_out_count += it.Count
+		}
+
+		//获取退库数量
+		cancelinfolist, _ := service.GetDrugFlowStockCancelCount(item.StorehouseId, item.DrugId, item.OrgId)
+		for _, it := range cancelinfolist {
+			if it.MaxUnit == medical.MaxUnit {
+				it.Count = it.Count * medical.MinNumber
+			}
+			cancel_out_count += it.Count
+		}
+
+		//新增
+		if drug.ID == 0 {
+			drugstock := models.XtDrugStockCount{
+				UserOrgId:      orgId,
+				StorehouseId:   item.StorehouseId,
+				SumInCount:     sum_in_count,
+				SumOutCount:    sum_out_count - cancel_out_count,
+				SumCancelCount: cancel_out_count,
+				DrugId:         item.DrugId,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Status:         1,
+				FlushCount:     flush_count,
+				SumActOutCount: sum_out_count,
+			}
+			service.CreateDrugStockCount(drugstock)
+		}
+	}
+
+	//获取入库数据
+	goodlist, _ := service.GetSendGoodInformation(orgId)
+	for _, it := range goodlist {
+		//查询是否有数据
+		_, errcode := service.GetStockFlush(it.StorehouseId, it.GoodId, it.OrgId)
+		//获取总退库数量
+		var cancel_count int64
+		var out_count int64
+		var act_count int64
+		//退库总数量
+		cancellist, _ := service.GetAllCancelCount(it.StorehouseId, it.GoodId, it.OrgId)
+		for _, item := range cancellist {
+			cancel_count += item.Count
+		}
+		//出库总数量
+		outlist, _ := service.GetAllStockOutCount(it.StorehouseId, it.GoodId, it.OrgId)
+		for _, item := range outlist {
+			out_count += item.Count
+		}
+
+		//实际出库总数量
+		actlist, _ := service.GetActStockOutCount(it.StorehouseId, it.GoodId, it.OrgId)
+		for _, item := range actlist {
+			act_count += item.Count
+		}
+
+		if errcode == gorm.ErrRecordNotFound {
+			good := models.XtGoodStockCount{
+				UserOrgId:        it.OrgId,
+				GoodId:           it.GoodId,
+				StorehouseId:     it.StorehouseId,
+				Status:           1,
+				Ctime:            time.Now().Unix(),
+				Mtime:            0,
+				StockInCount:     it.WarehousingCount,
+				StockOutCount:    out_count - cancel_count,
+				StockCancelCount: cancel_count,
+				FlushCount:       it.StockCount,
+				StockActOutCount: act_count,
 			}
+			service.CreateGoodCountSix(good)
+		}
+		if errcode == nil {
+			service.UpdateGoodCount(it.WarehousingCount, it.StockCount, out_count, it.StorehouseId, it.GoodId, it.OrgId, cancel_count, act_count)
 		}
 	}
 
 		}
 	}
 
+	//获取所有的入库仓库
+	druglist, _ := service.GetDrugWarehouseInfoStorehouseList(orgId)
+	for _, item := range druglist {
+		//查询该药品该仓库是否有数据
+		drug, _ := service.GetDrugStockCout(item.DrugId, item.StorehouseId, item.OrgId)
+
+		//查询该仓库该药品的入库数量
+		medical, _ := service.GetBaseDrugMedical(item.DrugId)
+
+		var sum_in_count int64
+		var flush_count int64
+		var sum_out_count int64
+		var cancel_out_count int64
+		//查询入库数量和剩余库存
+		infolist, _ := service.GetDrugWarehouseInfoByStorehouseId(item.StorehouseId, item.DrugId, item.OrgId)
+		for _, it := range infolist {
+			if it.MaxUnit == medical.MaxUnit {
+				it.WarehousingCount = it.WarehousingCount * medical.MinNumber
+				it.StockMaxNumber = it.StockMaxNumber * medical.MinNumber
+			}
+			sum_in_count += it.WarehousingCount
+			flush_count += it.StockMaxNumber + it.StockMinNumber
+		}
+
+		//获取出库数量
+		outinfolist, _ := service.GetDrugFlowStockOutCount(item.StorehouseId, item.DrugId, item.OrgId)
+		for _, it := range outinfolist {
+			if it.MaxUnit == medical.MaxUnit {
+				it.Count = it.Count * medical.MinNumber
+			}
+			sum_out_count += it.Count
+		}
+
+		//获取退库数量
+		cancelinfolist, _ := service.GetDrugFlowStockCancelCount(item.StorehouseId, item.DrugId, item.OrgId)
+		for _, it := range cancelinfolist {
+			if it.MaxUnit == medical.MaxUnit {
+				it.Count = it.Count * medical.MinNumber
+			}
+			cancel_out_count += it.Count
+		}
+
+		//新增
+		if drug.ID == 0 {
+			drugstock := models.XtDrugStockCount{
+				UserOrgId:      orgId,
+				StorehouseId:   item.StorehouseId,
+				SumInCount:     sum_in_count,
+				SumOutCount:    sum_out_count - cancel_out_count,
+				SumCancelCount: cancel_out_count,
+				DrugId:         item.DrugId,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Status:         1,
+				FlushCount:     flush_count,
+				SumActOutCount: sum_out_count,
+			}
+			service.CreateDrugStockCount(drugstock)
+		}
+	}
+
+	//获取入库数据
+	goodlist, _ := service.GetSendGoodInformation(orgId)
+	for _, it := range goodlist {
+		//查询是否有数据
+		_, errcode := service.GetStockFlush(it.StorehouseId, it.GoodId, it.OrgId)
+		//获取总退库数量
+		var cancel_count int64
+		var out_count int64
+		var act_count int64
+		//退库总数量
+		cancellist, _ := service.GetAllCancelCount(it.StorehouseId, it.GoodId, it.OrgId)
+		for _, item := range cancellist {
+			cancel_count += item.Count
+		}
+		//出库总数量
+		outlist, _ := service.GetAllStockOutCount(it.StorehouseId, it.GoodId, it.OrgId)
+		for _, item := range outlist {
+			out_count += item.Count
+		}
+
+		//实际出库总数量
+		actlist, _ := service.GetActStockOutCount(it.StorehouseId, it.GoodId, it.OrgId)
+		for _, item := range actlist {
+			act_count += item.Count
+		}
+
+		if errcode == gorm.ErrRecordNotFound {
+			good := models.XtGoodStockCount{
+				UserOrgId:        it.OrgId,
+				GoodId:           it.GoodId,
+				StorehouseId:     it.StorehouseId,
+				Status:           1,
+				Ctime:            time.Now().Unix(),
+				Mtime:            0,
+				StockInCount:     it.WarehousingCount,
+				StockOutCount:    out_count - cancel_count,
+				StockCancelCount: cancel_count,
+				FlushCount:       it.StockCount,
+				StockActOutCount: act_count,
+			}
+			service.CreateGoodCountSix(good)
+		}
+		if errcode == nil {
+			service.UpdateGoodCount(it.WarehousingCount, it.StockCount, out_count, it.StorehouseId, it.GoodId, it.OrgId, cancel_count, act_count)
+		}
+	}
+
 	this.ServeSuccessJSON(map[string]interface{}{
 		"msg": "1",
 	})

controllers/self_drug_api_congtroller.go

 	//药品库存优化接口
 	beego.Router("/api/good/getdrugwarehouseoutdetailbypatientid", &SelfDrugApiController{}, "Get:GetDrugWarehouseOutDetailByPatientId")
 	beego.Router("/api/drug/getdrugexpirydatequery", &SelfDrugApiController{}, "Get:GetDrugExpiryDateQuery")
+	beego.Router("/api/drug/getpurchasedrugquery", &SelfDrugApiController{}, "Get:GetPurchaseDrugQuery")
+	beego.Router("/api/drug/getdrugnewquery", &SelfDrugApiController{}, "Get:GetDrugNewQuery")
+	beego.Router("/api/drug/getdrugwarehouseoutinfobyid", &SelfDrugApiController{}, "Get:GetDrugWarehouseInfoById")
 
+	//耗材脚本
+	beego.Router("/api/stock/tosendgoodinfomation", &SelfDrugApiController{}, "Get:GetSendGoodInformation")
+	//药品脚本
+	beego.Router("/api/drug/getdruginitdatalist", &SelfDrugApiController{}, "Get:GetDrugInitDetailList")
 }
 
 func (this *SelfDrugApiController) GetCurrentPatient() {
 			}
 			service.UpdateMedicalSumCount(drugInfo.DrugId, sum_count, sum_in_count, drugInfo.OrgId)
 
+			//更新剩余库存
+			service.UpdateDrugStockCount(drugInfo.DrugId, drugInfo.OrgId, houseConfig.DrugStorehouseOut, sum_count)
 			inventory := models.XtDrugInventory{
 				DrugName:           drug_name,
 				SpecificationName:  specification_name,
 	keyword := this.GetString("keyword")
 	page, _ := this.GetInt64("page")
 	limit, _ := this.GetInt64("limit")
-	start_time := this.GetString("start_time")
-	end_time := this.GetString("end_time")
-	timeLayout := "2006-01-02"
-	loc, _ := time.LoadLocation("Local")
-	var startTime int64
-	if len(start_time) > 0 {
-		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
-		if err != nil {
-			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-			return
-		}
-		startTime = theTime.Unix()
-	}
-	var endTime int64
-	if len(end_time) > 0 {
-		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
-		if err != nil {
-			utils.ErrorLog(err.Error())
-			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-			return
+	//start_time := this.GetString("start_time")
+	//end_time := this.GetString("end_time")
+	//timeLayout := "2006-01-02"
+	//loc, _ := time.LoadLocation("Local")
+	//var startTime int64
+	//if len(start_time) > 0 {
+	//	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+	//	if err != nil {
+	//		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+	//		return
+	//	}
+	//	startTime = theTime.Unix()
+	//}
+	//var endTime int64
+	//if len(end_time) > 0 {
+	//	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
+	//	if err != nil {
+	//		utils.ErrorLog(err.Error())
+	//		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+	//		return
+	//	}
+	//	endTime = theTime.Unix()
+	//}
+
+	// 查询该机构所有耗材入库信息
+	goodList, _ := service.GetAllGoodListSeven(orgId)
+
+	for _, it := range goodList {
+		var sum_total int64
+		//查询该耗材入库信息
+		warehouseinfo, _ := service.GetGoodInformationWarehouseInfo(it.ID, orgId)
+		for _, item := range warehouseinfo {
+			sum_total += item.StockCount
 		}
-		endTime = theTime.Unix()
-	}
+		service.UpdateGoodInformation(it.ID, orgId, sum_total)
+	}
+
+	//查询删除的耗材数据
+	//listOne, _ := service.GetHisPrescriptionProjectByOrgId(orgId)
+	//for _, item := range listOne {
+	// //查询流水
+	// flowDetail, _ := service.GetPatientStockFlow(item.PatientId, item.RecordDate, item.ProjectId)
+	// formatInt, _ := strconv.ParseInt(item.Count, 10, 64)
+	// vmFlow := models.VmStockFlow{
+	//   Count:  formatInt,
+	// }
+	// service.ModifyPatientStockFlow(flowDetail.ID,vmFlow)
+	//}
+
 	var ids []int64
 	var goodIds []int64
 	manufacturerList, _ := service.GetManufacturerListByKeyword(orgId, keyword)
-	infoList, _ := service.GetGoodWarehouseInfoByOrgId(orgId)
 	for _, it := range manufacturerList {
 		ids = append(ids, it.ID)
 	}
+	infoList, _ := service.GetGoodWarehouseInfoByOrgId(orgId, storehouse_id)
 	for _, it := range infoList {
 		goodIds = append(goodIds, it.GoodId)
 	}
-	list, total, err := service.GetGoodNewQuery(orgId, storehouse_id, good_type, keyword, page, limit, ids, goodIds, startTime, endTime)
+	//list, _, err := service.GetGoodNewQuery(orgId, storehouse_id, good_type, keyword, page, limit, ids, goodIds, startTime, endTime)
+
+	stockList, total, err := service.GetGoodStockList(orgId, storehouse_id, good_type, keyword, page, limit, ids)
+	//for _,item :=range list{
+	// //查询入库信息分组
+	//  warehouseInfo, _ := service.FindGoodWarehouseInfoGroup(item.ID, orgId, storehouse_id, startTime, endTime)
+	//  for _,it :=range warehouseInfo {
+	//    item.WarehousingInfo = append(item.WarehousingInfo, it)
+	//  }
+	//  //查询入库信息
+	//  info, _ := service.FindGoodWarehouseInfo(item.ID, orgId, storehouse_id, startTime, endTime)
+	//  for _,it :=range info {
+	//    item.StWarehousingInfo = append(item.StWarehousingInfo, it)
+	//  }
+	//  //出库数据
+	//  outInfo, _ := service.FindGoodWarehouseOutInfo(item.ID, orgId, storehouse_id, startTime, endTime)
+	//  for _,it :=range outInfo {
+	//    item.WarehouseOutInfo = append(item.WarehouseOutInfo, it)
+	//  }
+	//  //出库流水
+	//  outFlow, _ := service.FindGoodStockOutFlow(item.ID, item.OrgId, storehouse_id, startTime, endTime)
+	//  for _,it :=range outFlow {
+	//    item.FlowOutInfo = append(item.FlowOutInfo, it)
+	//  }
+	//  //退库流水
+	//  cancelFlow, _ := service.FindGoodCancelFlow(item.ID, item.OrgId, storehouse_id, startTime, endTime)
+	//  for _,it :=range cancelFlow {
+	//    item.FlowCancelInfo = append(item.FlowCancelInfo, it)
+	//  }
+	//  //退库数据
+	//  cancelInfo, _ := service.FindCancelStockInfo(item.ID, orgId, storehouse_id, startTime, endTime)
+	//  for _,it :=range cancelInfo {
+	//    item.CancelStockInfo = append(item.CancelStockInfo, it)
+	//  }
+	//}
+
 	if err != nil {
 		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取查询信息失败")
 		return
 
 	this.ServeSuccessJSON(map[string]interface{}{
 		"total": total,
-		"list":  list,
+		//"list":  list,
+		"stockList": stockList,
 	})
 }
 
 	page, _ := this.GetInt64("page")
 	start_time := this.GetString("start_first_time")
 	end_time := this.GetString("end_first_time")
+	storehouse_id, _ := this.GetInt64("storehouse_id")
 	orgId := this.GetAdminUserInfo().CurrentOrgId
 	timeLayout := "2006-01-02"
 	loc, _ := time.LoadLocation("Local")
 		}
 		endTime = theTime.Unix()
 	}
-	list, total, err := service.GetGoodWarehouseOutInfoByIdList(good_id, limit, page, orgId, startTime, endTime)
+	list, total, err := service.GetGoodWarehouseOutInfoByIdList(good_id, limit, page, orgId, startTime, endTime, storehouse_id)
+	//flushList, _ := service.GetStockFlushByGoodId(good_id, orgId, startTime, endTime)
+
+	//warehouseInfoByList, _ := service.GetGoodWarehouseInfoByList(good_id, orgId, startTime, endTime)
+	//cancelStockInfoByList, _ := service.GetGoodCancelStockInfoByList(good_id, orgId, startTime, endTime)
+	//warehouseOutByList,_ := service.GetGoodWarehouseOutInfoByIdListTwenty(good_id, limit, page, orgId, startTime, endTime)
+
 	if err != nil {
 		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取查寻出库信息失败")
 		return
 	this.ServeSuccessJSON(map[string]interface{}{
 		"total": total,
 		"list":  list,
+		//"warehouseInfoByList":warehouseInfoByList,
+		//"cancelStockInfoByList":cancelStockInfoByList,
+		//"warehouseOutByList":warehouseOutByList,
+		//"flushList":flushList,
 	})
 }
 
 func (this *SelfDrugApiController) GetWarehouseOutDetailByPatientId() {
 
 	patient_id, _ := this.GetInt64("patient_id")
-	start_time := this.GetString("start_first_time")
-	end_time := this.GetString("end_first_time")
+	start_time := this.GetString("start_time")
+	end_time := this.GetString("end_time")
 	limit, _ := this.GetInt64("limit")
 	page, _ := this.GetInt64("page")
 	orgId := this.GetAdminUserInfo().CurrentOrgId
 		}
 		endTime = theTime.Unix()
 	}
-	list, total, err := service.GetWarehouseOutDetailByPatientId(orgId, patient_id, startTime, endTime, limit, page)
+	list, total, err := service.GetWarehouseOutDetailByPatientIdOne(orgId, patient_id, startTime, endTime, limit, page)
+	outlist, _ := service.GetWarehouseOutDetailByPatientId(orgId, patient_id, startTime, endTime)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
 	if err != nil {
 		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取患者信息失败")
 		"list":             list,
 		"manufacturerList": manufacturerList,
 		"total":            total,
+		"outlist":          outlist,
 	})
 }
 
 		goodIds = append(goodIds, it.ID)
 	}
 	list, total, err := service.GetGoodExpiryDateQuery(storehouse_id, expiry_type, keyword, page, limit, orgId, ids, goodIds, nowtime, endTime)
+	fmt.Println("total233223322332323232323223", total)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
 
 	if err != nil {
 
 	limit, _ := this.GetInt64("limit")
 
-	start_time := this.GetString("start_first_time")
-	end_time := this.GetString("end_first_time")
+	start_time := this.GetString("start_time")
+	end_time := this.GetString("end_time")
 	orgId := this.GetAdminUserInfo().CurrentOrgId
 	timeLayout := "2006-01-02"
 	loc, _ := time.LoadLocation("Local")
 		}
 		startTime = theTime.Unix()
 	}
+
 	var endTime int64
 	if len(end_time) > 0 {
 		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
 		endTime = theTime.Unix()
 	}
 	var ids []int64
-	var infoIds []int64
+	var goodIds []int64
+	infoList, _ := service.GetGoodWarehouseInfoByOrgIdTwo(orgId)
+	for _, it := range infoList {
+		goodIds = append(goodIds, it.GoodId)
+	}
 
 	manufacturers, _ := service.GetManufacturerListByKeyword(orgId, keyword)
 	for _, it := range manufacturers {
 		ids = append(ids, it.ID)
 	}
-	infoList, _ := service.GetGoodWarehouseInfoByOrgId(orgId)
-	for _, it := range infoList {
-		infoIds = append(infoIds, it.GoodId)
-	}
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
-	list, total, err := service.GetGoodPurchaseStockQuery(good_type, keyword, page, limit, orgId, startTime, endTime, ids, infoIds)
-	fmt.Println("list233323233233232332233232", list)
+	list, total, err := service.GetGoodPurchaseStockQuery(good_type, keyword, page, limit, orgId, ids, goodIds)
+	for _, item := range list {
+
+		//获取期初结余数量
+		infoList, _ := service.GetStartGoodWarehouseInfoList(item.ID, orgId, startTime)
+		for _, it := range infoList {
+			item.WarehousingInfoStart = append(item.WarehousingInfoStart, it)
+		}
+
+		//获取期末结余数量
+		warehouseInfoList, _ := service.GetEndGoodWarehouseInfoList(item.ID, orgId, endTime)
+		for _, it := range warehouseInfoList {
+			item.WarehousingInfoEnd = append(item.WarehousingInfoEnd, it)
+		}
+
+		//获取期间增加
+		goodWarehouseInfoList, _ := service.GetAddGoodWarehouseInfoList(item.ID, orgId, startTime, endTime)
+		for _, it := range goodWarehouseInfoList {
+			item.WarehousingInfoOne = append(item.WarehousingInfoOne, it)
+		}
+
+		//获取本期增加
+		WarehouseInfoFlowList, _ := service.GetAddStartFlow(item.ID, orgId, startTime, endTime)
+		for _, it := range WarehouseInfoFlowList {
+			item.StartFlowWarehouseInfo = append(item.StartFlowWarehouseInfo, it)
+		}
+		//获取本期减少
+		reduceWarehouseInfoList, _ := service.GetReduceWarehouseInfoList(item.ID, orgId, startTime, endTime)
+		for _, it := range reduceWarehouseInfoList {
+			item.WarehouseOutInfoStart = append(item.WarehouseOutInfoStart, it)
+		}
+
+		//获取期中减少退库
+		lowInfo, _ := service.GetStartEndCancelFLowInfo(item.ID, orgId, startTime, endTime)
+		for _, it := range lowInfo {
+			item.StartEndCancelFLowInfo = append(item.StartEndCancelFLowInfo, it)
+		}
+		//
+		outInfo, _ := service.FindeWarehouseOutInfo(item.ID, orgId, startTime)
+		for _, it := range outInfo {
+			item.WarehouseOutInfoEnd = append(item.WarehouseOutInfoEnd, it)
+		}
+
+		//获取期初结余
+		info, _ := service.FindeStartFlowInfo(item.ID, orgId, startTime)
+		for _, it := range info {
+			item.StartFlowInfo = append(item.StartFlowInfo, it)
+		}
+		//获取期初结余
+		flowOutInfo, _ := service.FindeStartFlowOutInfo(item.ID, orgId, startTime)
+		for _, it := range flowOutInfo {
+			item.StartOutFlowInfo = append(item.StartOutFlowInfo, it)
+		}
+
+		//获取期初退库
+		cancelInfo, _ := service.FindeStartCancelInfo(item.ID, orgId, startTime)
+		for _, it := range cancelInfo {
+			item.StartCancelFlowInfo = append(item.StartCancelFlowInfo, it)
+		}
+
+		//获取期末结余
+		flowInfo, _ := service.FindEndStartFlowInfo(item.ID, orgId, endTime)
+		for _, it := range flowInfo {
+			item.EndFlowInfo = append(item.EndFlowInfo, it)
+		}
+
+		//获取期末出库
+		lowOutInfo, _ := service.FindeEndFLowOutInfo(item.ID, orgId, endTime)
+		for _, it := range lowOutInfo {
+			item.EndFlowOutInfo = append(item.EndFlowOutInfo, it)
+		}
+
+		//获取期末退库
+		endCancelInfo, _ := service.FindEndCancelInfo(item.ID, orgId, endTime)
+		for _, it := range endCancelInfo {
+			item.EndCancelFLowInfo = append(item.EndCancelFLowInfo, it)
+		}
+
+		//期初盘赢
+		inventory, _ := service.FindeStartStockInventoryProfit(item.ID, orgId, startTime)
+		for _, it := range inventory {
+			item.WareStartStockInventoryProfit = append(item.WareStartStockInventoryProfit, it)
+		}
+		//期初盘亏
+		stockInventory, _ := service.FindStartStockInventoryLosses(item.ID, orgId, startTime)
+		for _, it := range stockInventory {
+			item.WareStartStockInventoryLosses = append(item.WareStartStockInventoryLosses, it)
+		}
+
+		//期末盘盈
+		inventoryProfit, _ := service.FindeStartStockInventoryProfit(item.ID, orgId, endTime)
+		for _, it := range inventoryProfit {
+			item.WareEndStockInventoryProfit = append(item.WareEndStockInventoryProfit, it)
+		}
+		//期末盘亏
+		inventoryLosses, _ := service.FindStartStockInventoryLosses(item.ID, orgId, endTime)
+		for _, it := range inventoryLosses {
+			item.WareEndStockInventoryLosses = append(item.WareEndStockInventoryLosses, it)
+		}
+
+		//期中盘盈
+		profit, _ := service.FindeEndStokInventoryProfit(item.ID, orgId, startTime, endTime)
+		for _, it := range profit {
+			item.WareStartEndStockInventoryProfit = append(item.WareStartEndStockInventoryProfit, it)
+		}
+		//期中盘亏
+		losses, _ := service.FindeEndStockInventoryLosses(item.ID, orgId, startTime, endTime)
+		for _, it := range losses {
+			item.WareStartEndStockInventoryLosses = append(item.WareStartEndStockInventoryLosses, it)
+		}
+	}
+
 	if err != nil {
 		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取患者信息失败")
 		return
 		}
 		endTime = theTime.Unix()
 	}
-
-	list, total, _ := service.GetDrugWarehouseOutDetailByPatientId(patient_id, orgId, startTime, endTime, page, limit)
+	list, total, _ := service.GetDrugWarehouseOutDetailByPatientIdOne(patient_id, orgId, startTime, endTime, page, limit)
+	outlist, _ := service.GetDrugWarehouseOutDetailByPatientId(patient_id, orgId, startTime, endTime)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
 	this.ServeSuccessJSON(map[string]interface{}{
 		"list":             list,
 		"total":            total,
 		"manufacturerList": manufacturerList,
+		"outlist":          outlist,
 	})
 }
 
 		"drugTypeList":     drugTypeList,
 	})
 }
+
+func (this *SelfDrugApiController) GetPurchaseDrugQuery() {
+	good_type, _ := this.GetInt64("good_type")
+
+	keyword := this.GetString("keyword")
+
+	page, _ := this.GetInt64("page")
+
+	limit, _ := this.GetInt64("limit")
+
+	start_time := this.GetString("start_time")
+	end_time := this.GetString("end_time")
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+
+	var startTime int64
+
+	if len(start_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+		if err != nil {
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		startTime = theTime.Unix()
+	}
+
+	var endTime int64
+	if len(end_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		endTime = theTime.Unix()
+	}
+	var ids []int64
+	var infoIds []int64
+
+	manufacturers, _ := service.GetManufacturerListByKeyword(orgId, keyword)
+	for _, it := range manufacturers {
+		ids = append(ids, it.ID)
+	}
+	infoList, _ := service.GetDrugWarehouseInfoByOrgIdTwo(orgId)
+	for _, it := range infoList {
+		infoIds = append(infoIds, it.DrugId)
+	}
+	manufacturerList, _ := service.GetAllManufacturerList(orgId)
+	list, total, err := service.GetDrugPurchaseStockQuery(good_type, keyword, page, limit, orgId, startTime, endTime, ids, infoIds)
+
+	for _, item := range list {
+
+		//获取期初结余入库数量
+		startDrugInfo, _ := service.GetDrugWarehouseInfoStart(item.ID, orgId, startTime)
+		for _, it := range startDrugInfo {
+			item.DrugWarehouseInfoStart = append(item.DrugWarehouseInfoStart, it)
+		}
+
+		//获取期初结余出库数量
+		flowOutList, _ := service.GetDrugFlowOut(item.ID, orgId, startTime)
+		for _, it := range flowOutList {
+			item.DrugWarehouseOutInfoStart = append(item.DrugWarehouseOutInfoStart, it)
+		}
+
+		//获取期初结余退库数量
+		cancelInfo, _ := service.GetStartDrugFlowCancelInfo(item.ID, orgId, startTime)
+		for _, it := range cancelInfo {
+			item.WareStartStockCancelInfo = append(item.WareStartStockCancelInfo, it)
+		}
+
+		//获取期末结余入库数量
+		drugwarehouseinfoend, _ := service.DrugWarehouseInfoEnd(item.ID, orgId, endTime)
+		for _, it := range drugwarehouseinfoend {
+			item.DrugWarehouseInfoEnd = append(item.DrugWarehouseInfoEnd, it)
+		}
+
+		//获取期末出库结余
+		endDrugInfo, _ := service.DrugWarehouseOutInfoEnd(item.ID, orgId, endTime)
+		for _, it := range endDrugInfo {
+			item.DrugWarehouseOutInfoEnd = append(item.DrugWarehouseOutInfoEnd, it)
+		}
+
+		//获取期末退库数量
+		flowCancelInfo, _ := service.GetEndDrugFlowCancelInfo(item.ID, orgId, endTime)
+		for _, it := range flowCancelInfo {
+			item.WareEndStockCancelInfo = append(item.WareEndStockCancelInfo, it)
+		}
+
+		//期中增加
+		drugWarehouse, _ := service.GetDrugWarehouseStartEnd(item.ID, orgId, startTime, endTime)
+		for _, it := range drugWarehouse {
+			item.DrugWarehouseInfoStartEnd = append(item.DrugWarehouseInfoStartEnd, it)
+		}
+
+		//期中减少
+		outInfo, _ := service.FindeDrugWarehouseOutInfo(item.ID, item.OrgId, startTime, endTime)
+		for _, it := range outInfo {
+			item.DrugWarehouseOutInfoStartEnd = append(item.DrugWarehouseOutInfoStartEnd, it)
+		}
+
+		//期中退库
+		cancelstartInfo, _ := service.FindStartEndDrugWarehouseOutInfo(item.ID, item.OrgId, startTime, endTime)
+		for _, it := range cancelstartInfo {
+			item.WareStartEndStockCancelInfo = append(item.WareStartEndStockCancelInfo, it)
+		}
+
+		//获取期初盘盈
+		startProfit, _ := service.GetDrugFlowStartProfit(item.ID, orgId, startTime)
+		for _, it := range startProfit {
+			item.WareStartStockInventoryProfit = append(item.WareStartStockInventoryProfit, it)
+		}
+		//获取期初盘亏
+		startLosses, _ := service.GetDrugFlowStartLosses(item.ID, orgId, startTime)
+		for _, it := range startLosses {
+			item.WareStartStockInventoryLosses = append(item.WareStartStockInventoryLosses, it)
+		}
+		//获取期末盘盈
+		endProfit, _ := service.GetDrugFlowEndProfit(item.ID, orgId, endTime)
+		for _, it := range endProfit {
+			item.WareEndStockInventoryProfit = append(item.WareEndStockInventoryProfit, it)
+		}
+		//获取期末盘亏
+		losses, _ := service.GetDrugFlowEndLosses(item.ID, orgId, endTime)
+		for _, it := range losses {
+			item.WareEndStockInventoryLosses = append(item.WareEndStockInventoryLosses, it)
+		}
+
+		//获取期中盘盈
+		profit, _ := service.GetDrugFlowStartEndProfit(item.ID, orgId, startTime, endTime)
+		for _, it := range profit {
+			item.WareStartEndStockInventoryProfit = append(item.WareStartEndStockInventoryProfit, it)
+		}
+
+		//获取期中盘亏
+		endLosses, _ := service.GetDrugFlowStartEndLosses(item.ID, orgId, startTime, endTime)
+		for _, it := range endLosses {
+			item.WareStartEndStockInventoryLosses = append(item.WareStartEndStockInventoryLosses, it)
+		}
+	}
+	if err != nil {
+		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取患者信息失败")
+		return
+	}
+	var drugType = "药品类型"
+	drugTypeParent, _ := service.GetDrugDataConfig(0, drugType)
+	drugTypeList, _ := service.GetParentDataConfig(drugTypeParent.ID, orgId)
+
+	this.ServeSuccessJSON(map[string]interface{}{
+		"list":             list,
+		"manufacturerList": manufacturerList,
+		"total":            total,
+		"drugTypeList":     drugTypeList,
+	})
+}
+
+func (this *SelfDrugApiController) GetDrugNewQuery() {
+
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	storehouse_id, _ := this.GetInt64("storehouse_id")
+	good_type, _ := this.GetInt64("good_type")
+	keyword := this.GetString("keyword")
+	page, _ := this.GetInt64("page")
+	limit, _ := this.GetInt64("limit")
+	start_time := this.GetString("start_time")
+	end_time := this.GetString("end_time")
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	var startTime int64
+	if len(start_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+		if err != nil {
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		startTime = theTime.Unix()
+	}
+	var endTime int64
+	if len(end_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		endTime = theTime.Unix()
+	}
+	var ids []int64
+	var goodIds []int64
+	manufacturerList, _ := service.GetManufacturerListByKeyword(orgId, keyword)
+
+	//查询药品库信息
+	drug, _ := service.GetBaseDrugName(orgId)
+
+	for _, it := range drug {
+		var sum_count int64
+		var limit_count int64
+
+		drugInfo, _ := service.GetDrugWarehouseInfoName(it.ID, orgId)
+		for _, item := range drugInfo {
+			sum_count += item.StockMaxNumber*it.MinNumber + item.StockMinNumber
+		}
+		limit_count = it.DrugStockLimitCount * it.MinNumber
+		service.UpdateDrugById(it.ID, orgId, limit_count, sum_count)
+	}
+
+	for _, it := range manufacturerList {
+		ids = append(ids, it.ID)
+	}
+	infoList, _ := service.GetDrugWarehouseInfoByOrgId(orgId, storehouse_id)
+	for _, it := range infoList {
+		goodIds = append(goodIds, it.DrugId)
+	}
+	//list, total, err := service.GetDrugNewQuery(orgId, storehouse_id, good_type, keyword, page, limit, ids, goodIds, startTime, endTime)
+
+	countList, total, err := service.GetDrugStockCountList(orgId, storehouse_id, good_type, keyword, page, limit, ids, goodIds, startTime, endTime)
+
+	if err != nil {
+		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取查询信息失败")
+		return
+	}
+	var drugType = "药品类型"
+	drugTypeParent, _ := service.GetDrugDataConfig(0, drugType)
+	drugTypeList, _ := service.GetParentDataConfig(drugTypeParent.ID, orgId)
+
+	this.ServeSuccessJSON(map[string]interface{}{
+		"total": total,
+		//"list":  list,
+		"drugTypeList": drugTypeList,
+		"countList":    countList,
+	})
+}
+
+func (this *SelfDrugApiController) GetDrugWarehouseInfoById() {
+
+	drug_id, _ := this.GetInt64("drug_id")
+	limit, _ := this.GetInt64("limit")
+	page, _ := this.GetInt64("page")
+	start_time := this.GetString("start_first_time")
+	end_time := this.GetString("end_first_time")
+	storehouse_id, _ := this.GetInt64("storehouse_id")
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	var startTime int64
+	if len(start_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+		if err != nil {
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		startTime = theTime.Unix()
+	}
+	var endTime int64
+	if len(end_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		endTime = theTime.Unix()
+	}
+	list, total, err := service.GetDrugWarehouseOutInfoByIdList(drug_id, limit, page, orgId, startTime, endTime, storehouse_id)
+	flushList, _ := service.GetDrugFlowFlush(drug_id, orgId, startTime, endTime)
+	flushOne, _ := service.GetDrugFlowFlushOne(drug_id, orgId, startTime, endTime)
+	if err != nil {
+		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取查寻出库信息失败")
+		return
+	}
+
+	this.ServeSuccessJSON(map[string]interface{}{
+		"total":        total,
+		"list":         list,
+		"flushList":    flushList,
+		"flushListOne": flushOne,
+	})
+}
+
+func (this *SelfDrugApiController) GetSendGoodInformation() {
+
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	//获取入库数据
+	list, _ := service.GetSendGoodInformation(orgId)
+	for _, it := range list {
+		//查询是否有数据
+		_, errcode := service.GetStockFlush(it.StorehouseId, it.GoodId, it.OrgId)
+		//获取总退库数量
+		var cancel_count int64
+		var out_count int64
+		var act_count int64
+		//退库总数量
+		cancellist, _ := service.GetAllCancelCount(it.StorehouseId, it.GoodId, it.OrgId)
+		for _, item := range cancellist {
+			cancel_count += item.Count
+		}
+		//出库总数量
+		outlist, _ := service.GetAllStockOutCount(it.StorehouseId, it.GoodId, it.OrgId)
+		for _, item := range outlist {
+			out_count += item.Count
+		}
+
+		//实际出库总数量
+		actlist, _ := service.GetActStockOutCount(it.StorehouseId, it.GoodId, it.OrgId)
+		for _, item := range actlist {
+			act_count += item.Count
+		}
+
+		if errcode == gorm.ErrRecordNotFound {
+			good := models.XtGoodStockCount{
+				UserOrgId:        it.OrgId,
+				GoodId:           it.GoodId,
+				StorehouseId:     it.StorehouseId,
+				Status:           1,
+				Ctime:            time.Now().Unix(),
+				Mtime:            0,
+				StockInCount:     it.WarehousingCount,
+				StockOutCount:    out_count - cancel_count,
+				StockCancelCount: cancel_count,
+				FlushCount:       it.StockCount,
+				StockActOutCount: act_count,
+			}
+			service.CreateGoodCountSix(good)
+		}
+		if errcode == nil {
+			service.UpdateGoodCount(it.WarehousingCount, it.StockCount, out_count, it.StorehouseId, it.GoodId, it.OrgId, cancel_count, act_count)
+		}
+	}
+
+	this.ServeSuccessJSON(map[string]interface{}{
+		"msg": "1",
+	})
+}
+
+func (this *SelfDrugApiController) GetDrugInitDetailList() {
+
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+
+	//获取所有的入库仓库
+	list, _ := service.GetDrugWarehouseInfoStorehouseList(orgId)
+	for _, item := range list {
+		//查询该药品该仓库是否有数据
+		drug, _ := service.GetDrugStockCout(item.DrugId, item.StorehouseId, item.OrgId)
+
+		//查询该仓库该药品的入库数量
+		medical, _ := service.GetBaseDrugMedical(item.DrugId)
+
+		var sum_in_count int64
+		var flush_count int64
+		var sum_out_count int64
+		var cancel_out_count int64
+		//查询入库数量和剩余库存
+		infolist, _ := service.GetDrugWarehouseInfoByStorehouseId(item.StorehouseId, item.DrugId, item.OrgId)
+		for _, it := range infolist {
+			if it.MaxUnit == medical.MaxUnit {
+				it.WarehousingCount = it.WarehousingCount * medical.MinNumber
+				it.StockMaxNumber = it.StockMaxNumber * medical.MinNumber
+			}
+			sum_in_count += it.WarehousingCount
+			flush_count += it.StockMaxNumber + it.StockMinNumber
+		}
+
+		//获取出库数量
+		outinfolist, _ := service.GetDrugFlowStockOutCount(item.StorehouseId, item.DrugId, item.OrgId)
+		for _, it := range outinfolist {
+			if it.MaxUnit == medical.MaxUnit {
+				it.Count = it.Count * medical.MinNumber
+			}
+			sum_out_count += it.Count
+		}
+
+		//获取退库数量
+		cancelinfolist, _ := service.GetDrugFlowStockCancelCount(item.StorehouseId, item.DrugId, item.OrgId)
+		for _, it := range cancelinfolist {
+			if it.MaxUnit == medical.MaxUnit {
+				it.Count = it.Count * medical.MinNumber
+			}
+			cancel_out_count += it.Count
+		}
+
+		//新增
+		if drug.ID == 0 {
+			drugstock := models.XtDrugStockCount{
+				UserOrgId:      orgId,
+				StorehouseId:   item.StorehouseId,
+				SumInCount:     sum_in_count,
+				SumOutCount:    sum_out_count - cancel_out_count,
+				SumCancelCount: cancel_out_count,
+				DrugId:         item.DrugId,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Status:         1,
+				FlushCount:     flush_count,
+				SumActOutCount: sum_out_count,
+			}
+			service.CreateDrugStockCount(drugstock)
+		}
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"msg": "1",
+	})
+}

controllers/sign_weigh_api_controller.go

 	dry_weight, _ := c.GetFloat("dry_weight", 0)
 	temperature, _ := c.GetFloat("temperature", 0)
 	pulse_frequency, _ := c.GetFloat("pulse_frequency", 0)
-	//breathing_rate, _ := c.GetFloat("breathing_rate", 0)
 	breathing_rate := c.GetString("breathing_rate")
 	systolic_blood_pressure, _ := c.GetFloat("systolic_blood_pressure", 0)
 	diastolic_blood_pressure, _ := c.GetFloat("diastolic_blood_pressure", 0)
-
 	predialysisevaluation := &models.PredialysisEvaluation{
 		WeightBefore:           weight_before,
 		DryWeight:              dry_weight,
 	dry_weight, _ := c.GetFloat("dry_weight", 0)
 	temperature, _ := c.GetFloat("temperature", 0)
 	pulse_frequency, _ := c.GetFloat("pulse_frequency", 0)
-	//breathing_rate, _ := c.GetFloat("breathing_rate", 0)
 	breathing_rate := c.GetString("breathing_rate")
 	systolic_blood_pressure, _ := c.GetFloat("systolic_blood_pressure", 0)
 	diastolic_blood_pressure, _ := c.GetFloat("diastolic_blood_pressure", 0)
-
 	assessmentafterdislysis := &models.AssessmentAfterDislysis{
 		WeightAfter:            weight_after,
 		DryWeight:              dry_weight,

controllers/stock_in_api_controller.go

 	loc, _ := time.LoadLocation("Local")
 	start_time := this.GetString("start_time")
 	end_time := this.GetString("end_time")
-
+	start_first_time := this.GetString("start_first_time")
+	end_first_time := this.GetString("end_first_time")
 	var startTime int64
 	if len(start_time) > 0 {
 		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
 		}
 		endTime = theTime.Unix()
 	}
+
+	var startFistTime int64
+	if len(start_first_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_first_time+" 00:00:00", loc)
+		if err != nil {
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		startFistTime = theTime.Unix()
+	}
+	var endFirstTime int64
+	if len(end_first_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_first_time+" 23:59:59", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		endFirstTime = theTime.Unix()
+	}
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
-	list, total, _ := service.GetStockListById(id, orgId, limit, page, startTime, endTime)
+	list, total, _ := service.GetStockListById(id, orgId, limit, page, startTime, endTime, startFistTime, endFirstTime)
 	houseList, _ := service.GetAllStoreHouseList(orgId)
 	good, _ := service.GetGoodInformationByGoodId(id)
 	this.ServeSuccessJSON(map[string]interface{}{
 	orgId := this.GetAdminUserInfo().CurrentOrgId
 	order, _ := service.GetWarehouseOutOrder(idsArray, orgId)
 	list, _ := service.GetOrderDetialByOrderIdOne(idsArray, orgId)
+	stockFlowListGroup, _ := service.GetOrderDetailStockFlowByStorehouseById(idsArray, orgId)
+	stockFlowList, _ := service.GetOrderDetailStockFlow(idsArray, orgId)
+	//获取耗材退库数据
+	cancelInfolist, _ := service.GetOrderStockFlow(idsArray, orgId)
 	this.ServeSuccessJSON(map[string]interface{}{
-		"list":  list,
-		"order": order,
+		"list":               list,
+		"order":              order,
+		"stockFlowList":      stockFlowList,
+		"stockFlowListGroup": stockFlowListGroup,
+		"cancelInfolist":     cancelInfolist,
 	})
 }
 
 	//手动出库
 	info, _ := service.GetWarehouseOutInfoById(id, good_id)
 
+	//出库数据
 	stockFlowList, err := service.GetStockFlowBatchNumberOne(id, good_id)
+	//退库数据
+	cancelInfo, err := service.GetStockFlowCancelInfo(id, good_id)
 	if err == nil {
 		this.ServeSuccessJSON(map[string]interface{}{
 			"list":          userDetails,
 			"total":         total,
 			"info":          info,
 			"stockFlowList": stockFlowList,
+			"cancelInfo":    cancelInfo,
 		})
 	} else {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 			}
 			service.UpdateGoodByGoodId(good_id, sum_count, sum_in_count, warehosueinfos.OrgId)
 
+			goodListOne, _ := service.GetSumGoodList(orgId, storeConfig.StorehouseOutInfo, good_id)
+			var flush_count int64
+			for _, it := range goodListOne {
+				flush_count += it.StockCount
+			}
+			service.UpdateSumGood(orgId, storeConfig.StorehouseOutInfo, good_id, flush_count)
 			this.ServeSuccessJSON(map[string]interface{}{
 				"inventory": inventory,
 			})
 
 	id, _ := this.GetInt64("id")
 	orgId := this.GetAdminUserInfo().CurrentOrgId
-
-	warehouseOut, _ := service.GetWarehouseById(id)
+	creater := this.GetAdminUserInfo().AdminUser.Id
+	warehouseOut, errcode := service.GetWarehouseById(id)
+	if errcode != nil {
+		goodErrcode := models.XtGoodErrcode{
+			UserOrgId:      orgId,
+			Errcode:        "查询审核出库单报错",
+			GoodId:         0,
+			Status:         0,
+			Ctime:          0,
+			Mtime:          0,
+			Count:          0,
+			StockCount:     0,
+			Creater:        creater,
+			BatchNumberId:  0,
+			WarehouseOutId: 0,
+		}
+		service.CreateGoodErrcode(goodErrcode)
+	}
 	//查询已审核的单据
-	warehousingOutInfo, _ := service.GetWarehouseOutById(id, orgId)
+	warehousingOutInfo, erroce := service.GetWarehouseOutById(id, orgId)
+	if erroce != nil {
+		goodErrcode := models.XtGoodErrcode{
+			UserOrgId:      orgId,
+			Errcode:        "查询已审核出库详情单报错",
+			GoodId:         0,
+			Status:         0,
+			Ctime:          0,
+			Mtime:          0,
+			Count:          0,
+			StockCount:     0,
+			Creater:        creater,
+			BatchNumberId:  0,
+			WarehouseOutId: 0,
+		}
+		service.CreateGoodErrcode(goodErrcode)
+	}
 	////出库逻辑
 	for _, item := range warehousingOutInfo {
 		// 查询该耗材是否有库存
 
 		// 如果出库数量大于该批次剩余库存数量
 		if item.Count > warehouseOne.StockCount {
+
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      orgId,
+				Errcode:        "出库数量大于该批次剩余库存",
+				GoodId:         0,
+				Status:         0,
+				Ctime:          0,
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  warehouseOne.ID,
+				WarehouseOutId: item.ID,
+			}
+			service.CreateGoodErrcode(goodErrcode)
 			goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
 			this.ServeSuccessJSON(map[string]interface{}{
 				"msg":                "1",
 
 	}
 	for _, item := range warehousingOutInfo {
+
 		creater := this.GetAdminUserInfo().AdminUser.Id
-		service.ConsumablesDeliveryThirty(orgId, item.SysRecordTime, item, &warehouseOut, item.Count, creater)
+
+		//出库
+		err := service.ConsumablesDeliveryThirty(orgId, item.SysRecordTime, item, &warehouseOut, item.Count, creater)
+		if err != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      item.OrgId,
+				Errcode:        "调用出库接口报错",
+				GoodId:         item.GoodId,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
+
+		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
+		var flush_count int64
+		for _, it := range goodList {
+			flush_count += it.StockCount
+		}
+		errs := service.UpdateSumGood(orgId, item.StorehouseId, item.GoodId, flush_count)
+		if errs != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      item.OrgId,
+				Errcode:        "手动出库更新剩余出库失败",
+				GoodId:         item.GoodId,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
 
 		orgId := this.GetAdminUserInfo().CurrentOrgId
 		//查询默认仓库
 			total_count += it.StockCount
 		}
 		//基础库扣减库存
-		service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, orgId)
+		errsum := service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, orgId)
+		if errsum != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      item.OrgId,
+				Errcode:        "基础库扣减库存报错",
+				GoodId:         item.GoodId,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
 	}
 
 	//审核单据
 	err := service.UpdatedWarehouseOut(id)
-
+	if err != nil {
+		goodErrcode := models.XtGoodErrcode{
+			UserOrgId:      orgId,
+			Errcode:        "审核单据报错",
+			GoodId:         0,
+			Status:         1,
+			Ctime:          time.Now().Unix(),
+			Mtime:          0,
+			Count:          0,
+			StockCount:     0,
+			Creater:        creater,
+			BatchNumberId:  0,
+			WarehouseOutId: 0,
+		}
+		service.CreateGoodErrcode(goodErrcode)
+	}
 	if err == nil {
 		this.ServeSuccessJSON(map[string]interface{}{
 			"msg":                "2",
 
 	id, _ := this.GetInt64("id")
 	orgId := this.GetAdminUserInfo().CurrentOrgId
+	creater := this.GetAdminUserInfo().AdminUser.Id
 	// 查询出库数据
 	list, err := service.GetWarehouseOutById(id, orgId)
+	if err != nil {
+		goodErrcode := models.XtGoodErrcode{
+			UserOrgId:      orgId,
+			Errcode:        "反审核查询出库单报错",
+			GoodId:         0,
+			Status:         1,
+			Ctime:          time.Now().Unix(),
+			Mtime:          0,
+			Count:          0,
+			StockCount:     0,
+			Creater:        creater,
+			BatchNumberId:  0,
+			WarehouseOutId: 0,
+		}
+		service.CreateGoodErrcode(goodErrcode)
+	}
 	for _, item := range list {
 		//回退库存
-		service.UpdateaGoodWarehouseInfo(item.Count, item.GoodId, item.OrgId, item.WarehouseInfotId)
-
+		err := service.UpdateaGoodWarehouseInfo(item.Count, item.GoodId, item.OrgId, item.WarehouseInfotId)
+		if err != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      orgId,
+				Errcode:        "反审核回退库存报错",
+				GoodId:         0,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
 		//查询默认仓库
-		storeHouseConfig, _ := service.GetAllStoreHouseConfig(orgId)
-		stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, orgId)
+		storeHouseConfig, errs := service.GetAllStoreHouseConfig(orgId)
+		if errs != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      orgId,
+				Errcode:        "反审核查询默认仓库报错",
+				GoodId:         0,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
+		stockList, errcodes := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, orgId)
+		if errcodes != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      orgId,
+				Errcode:        "反审核查询默认仓库库存报错",
+				GoodId:         0,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
 		var total_count int64
 		for _, it := range stockList {
 			total_count += it.StockCount
 		}
 		//基础库扣减库存
-		service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, orgId)
+		errs = service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, orgId)
+		if errs != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      orgId,
+				Errcode:        "反审核基础库扣减库存报错",
+				GoodId:         0,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
+
+		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
+		var flush_count int64
+		for _, it := range goodList {
+			flush_count += it.StockCount
+		}
+		erros := service.UpdateSumGood(orgId, item.StorehouseId, item.GoodId, flush_count)
+		if erros != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      orgId,
+				Errcode:        "手动出库更新剩余库存报错",
+				GoodId:         0,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
+		//扣减出库数据
+		errcoeds := service.ModifyReduceGoodSumCount(item.StorehouseId, item.Count, orgId, item.GoodId)
+		if errcoeds != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      orgId,
+				Errcode:        "反审核扣减出库数据报错",
+				GoodId:         0,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
+
 	}
 	//删除流水，改变审核状态
-	service.ModifyGoodWarehouseOut(id)
+	errcos := service.ModifyGoodWarehouseOut(id)
+	if errcos != nil {
+		goodErrcode := models.XtGoodErrcode{
+			UserOrgId:      orgId,
+			Errcode:        "反审核删除流水，改变审核状态报错",
+			GoodId:         0,
+			Status:         1,
+			Ctime:          time.Now().Unix(),
+			Mtime:          0,
+			Count:          0,
+			StockCount:     0,
+			Creater:        creater,
+			BatchNumberId:  0,
+			WarehouseOutId: 0,
+		}
+		service.CreateGoodErrcode(goodErrcode)
+	}
 
 	if err == nil {
 		this.ServeSuccessJSON(map[string]interface{}{
 				BuyPrice:                item.Price,
 				StockCount:              "",
 				BatchNumberCount:        item.WarehousingCount,
+				IsCheck:                 1,
 			}
 			//创建出库流水
 			service.CreateStockFlowOne(stockFlow)
+
 			orgId := this.GetAdminUserInfo().CurrentOrgId
 			//查询该耗材剩余库存库
 			stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, orgId)
 			var total_count int64
+			var sum_in_count int64
 			for _, it := range stockList {
 				total_count += it.StockCount
+				sum_in_count += it.WarehousingCount
 			}
 			//基础库插入数据
-			service.UpdateGoodInfoAddSumCount(item.GoodId, total_count, orgId)
+			service.UpdateGoodInfoAddSumCount(item.GoodId, total_count, orgId, sum_in_count)
+
+			//查询该仓库是否有数据
+			_, errcode := service.GetGoodStockCount(orgId, item.StorehouseId, item.GoodId)
+			goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
+			var flush_count int64
+			for _, it := range goodList {
+				flush_count += it.StockCount
+			}
+			if errcode == gorm.ErrRecordNotFound {
+
+				goodCount := models.XtGoodStockCount{
+					UserOrgId:        orgId,
+					GoodId:           item.GoodId,
+					StorehouseId:     item.StorehouseId,
+					Status:           1,
+					Ctime:            time.Now().Unix(),
+					Mtime:            time.Now().Unix(),
+					StockInCount:     item.WarehousingCount,
+					StockOutCount:    0,
+					StockCancelCount: 0,
+					FlushCount:       flush_count,
+					StockActOutCount: 0,
+				}
+				service.CreateGoodCount(goodCount)
+			}
+			if errcode == nil {
+				service.UpdateGoodStockCount(orgId, item.StorehouseId, item.GoodId, item.WarehousingCount, flush_count)
+			}
 		}
 	}
 
 	}
 	for _, item := range list {
 
-		//退库
+		//扣减数量
 		service.UpdateWarehouseInfoByIdListTwo(item.WarehousingCount, item.ID)
+
 		//删除流水
 		service.UpdateWarehouseInfoFlow(item.ID)
 
+		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
+		var flush_count int64
+		for _, it := range goodList {
+			flush_count += it.StockCount
+		}
+
+		//扣减数量
+		service.UpdateGoodInCount(item.WarehousingCount, item.OrgId, item.GoodId, item.StorehouseId, flush_count)
+
 		//查询默认仓库
 		storeHouseConfig, _ := service.GetAllStoreHouseConfig(orgId)
 		//查询该耗材剩余多少库存
 		stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, orgId)
 		var sum_count int64
+		var sum_in_count int64
 		for _, it := range stockList {
 			sum_count += it.StockCount
+			sum_in_count += it.WarehousingCount
 		}
-		service.UpdateGoodInfoAddSumCount(item.GoodId, sum_count, orgId)
+		service.UpdateGoodInfoAddSumCount(item.GoodId, sum_count, orgId, sum_in_count)
 	}
 	err := service.ReturnCheckWarehouseInfo(warehousing_info_id)
 	if err == nil {
 
 		stockFlow := models.VmStockFlow{
 			ID:                        0,
-			WarehousingId:             0,
+			WarehousingId:             item.WarehouseInfoId,
 			GoodId:                    item.GoodId,
 			Number:                    item.Number,
 			LicenseNumber:             "",
 			Ctime:                     time.Now().Unix(),
 			Mtime:                     0,
 			Price:                     item.Price,
-			WarehousingDetailId:       0,
+			WarehousingDetailId:       item.WarehouseInfoId,
 			WarehouseOutDetailId:      0,
 			CancelOutDetailId:         item.ID,
 			ProductDate:               item.ProductDate,
 			StockCount:                "",
 		}
 		service.CreateStockFlowOne(stockFlow)
+		service.ModifyAddCancelCount(item.Count, item.GoodId)
 	}
 
 	cancelStock := models.CancelStock{
 	cancellist, _ := service.GetCancelStockInfoById(cancel_stock_id, orgId)
 	for _, item := range cancellist {
 		service.UpdateCancelStockNumber(item.Count, item.WarehouseInfoId, orgId)
+
 		service.UpdateGoodSumCount(item.Count, item.GoodId, orgId)
+		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
+
+		service.UpdateSumAddCancelCount(orgId, item.GoodId, item.StorehouseId, item.Count)
+		var flush_count int64
+		for _, it := range goodList {
+			flush_count += it.StockCount
+		}
+		errs := service.UpdateSumGood(orgId, item.StorehouseId, item.GoodId, flush_count)
+
+		//出库数量减少
+		service.ModifyAddGoodSumCount(item.StorehouseId, item.Count, orgId, item.GoodId)
+		if errs != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      item.OrgId,
+				Errcode:        "手动退库更新剩余出库失败",
+				GoodId:         item.GoodId,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
+
 	}
 	this.ServeSuccessJSON(map[string]interface{}{
 		"msg":                "1",
 func (this *StockManagerApiController) CheckReturnStockWarehouseInfo() {
 
 	cancel_stock_id, _ := this.GetInt64("cancel_stock_id")
+
 	orgId := this.GetAdminUserInfo().CurrentOrgId
 	cancelStock := models.CancelStock{
 		IsCheck: 2,
 	}
 	list, _ := service.GetCancelStockInfoListById(cancel_stock_id, orgId)
+	creater := this.GetAdminUserInfo().AdminUser.Id
 	for _, item := range list {
 		//回退库存
 		service.UpdateStockNumberWarehouseInfo(item.WarehouseInfoId, item.GoodId, item.OrgId, item.Count)
+
 		service.UpdateStockWarehouseInfoStockFlow(item.ID, orgId, item.GoodId)
+
+		//退库数量增加
+		service.UpdateSumReduceCancelCount(orgId, item.GoodId, item.StorehouseId, item.Count)
+
+		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
+		var flush_count int64
+		for _, it := range goodList {
+			flush_count += it.StockCount
+		}
+		errs := service.UpdateSumGood(orgId, item.StorehouseId, item.GoodId, flush_count)
+
+		//出库数量增加
+		service.UpdateSumAddOutCount(orgId, item.GoodId, item.StorehouseId, item.Count)
+
+		if errs != nil {
+			goodErrcode := models.XtGoodErrcode{
+				UserOrgId:      item.OrgId,
+				Errcode:        "手动退库反审核更新剩余出库失败",
+				GoodId:         item.GoodId,
+				Status:         1,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Count:          0,
+				StockCount:     0,
+				Creater:        creater,
+				BatchNumberId:  0,
+				WarehouseOutId: 0,
+			}
+			service.CreateGoodErrcode(goodErrcode)
+		}
+
 	}
 	err := service.UpdateStockWarehouseInfo(cancel_stock_id, orgId, cancelStock)
 

controllers/supply_order_api_contorller.go

 
 	for _, item := range warehousingInfo {
 		service.CreatedWarehouseingDetail(item)
+
 		//查询该机构默认仓库
 		storeConfig, _ := service.GetAllStoreHouseConfig(item.OrgId)
 		//查询剩余库存
 			sum_in_count += item.WarehousingCount
 		}
 		service.UpdateGoodByGoodId(item.GoodId, sum_count, sum_in_count, item.OrgId)
+		//增加入库数量
+		service.AddGoodSumInCount(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId, item.WarehousingCount)
 
+		//更新剩余库存
+		service.UpdateGoodFlushCount(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId, sum_count)
 		warehousinginfo, _ := service.GetLastWarehousingInfo(item.GoodId)
 		flow := models.VmStockFlow{
 			WarehousingOrder:          item.WarehousingOrder,
 		}
 		service.UpdateMedicalSumCount(items.DrugId, sum_count, sum_in_count, items.OrgId)
 
+		//更新入库数量和剩余库存
+		service.UpdateDrugCount(houseConfig.DrugStorehouseOut, items.OrgId, items.DrugId, sum_in_count, sum_count)
 	}
 	fmt.Println(errs)
 	for _, items := range drugFlow {
 					sum_in_count += it.WarehousingCount
 				}
 				service.UpdateMedicalSumCount(item.DrugId, sum_count, sum_in_count, item.OrgId)
+
+				//更新库存
+				service.UpdateDrugCount(houseConfig.DrugStorehouseOut, item.OrgId, item.DrugId, sum_in_count, sum_count)
 			}
 		} else {
 			for _, it := range goodOrder {
 				service.AutoDrugDeliverInfoNight(orgId, prescribingNumber, &warehouseOut, &drup, warehouseOutInfo, warehouse_out_id, id)
 			}
 
-			//修改原数据
-			/*	orderInfo := models.SpSupplierWarehousingCancelOrder{
-					SourceCount: item.SupplyCount - item.SourceCount,
-				}
-				service.UpdateSupplyCancelById(item.ID, orderInfo)*/
+			//查询默认仓库
+			houseConfig, _ := service.GetAllStoreHouseConfig(orgId)
+			//查询默认仓库剩余多少库存
+			list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgId, drup.ID)
+			var sum_count int64
+			var sum_in_count int64
+			for _, it := range list {
+				baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
+				if it.MaxUnit == baseDrug.MaxUnit {
+					it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
+					it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
+
+				}
+				sum_count += it.StockMaxNumber + it.StockMinNumber
+				sum_in_count += it.WarehousingCount
+			}
+			service.UpdateDrugCountOne(houseConfig.DrugStorehouseOut, orgId, drup.ID, sum_count)
+
 		}
 
 		//耗材
 				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
 				return
 			}
+			//查询该机构默认仓库
+			storeConfig, _ := service.GetAllStoreHouseConfig(orgId)
+			//查询剩余库存
+			goodList, _ := service.GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, item.ProjectId, orgId)
+			var sum_count int64
+			for _, item := range goodList {
+				sum_count += item.StockCount
+			}
+			//更新剩余库存
+			service.UpdateGoodFlushCount(storeConfig.StorehouseOutInfo, item.ProjectId, orgId, sum_count)
+
 		}
 	}
 	cancel := models.SpSupplierWarehouseCancel{
 	//获取退库单据日期
 	cancel, _ := service.GetReturnOrderById(id)
 	orgId := this.GetAdminUserInfo().CurrentOrgId
+
+	houseConfig, _ := service.GetAllStoreHouseConfig(orgId)
 	if err == nil {
 		//获取退库单详情
 		list, _ := service.GetSupplyCancelOrderDetail(id, orgId)
 					var sum_count int64
 					sum_count = item.SupplyCount * base.MinNumber
 					service.ModifyDrugAddInformation(item.ProjectId, sum_count, orgId)
+					//出库数量减少
+					service.ReduceDrugSumOut(houseConfig.DrugStorehouseOut, orgId, item.ProjectId, sum_count)
 				}
 
 				if item.SupplyType == base.MinUnit && base.MaxUnit != base.MinUnit {
 					}
 					service.UpdateDrugWasehousringOne(item.ProjectId, item.SupplyWarehouseDetailInfo, drugInfo)
 					service.ModifyDrugAddInformation(item.ProjectId, item.SupplyCount, orgId)
+					//出库数量减少
+					service.ReduceDrugSumOut(houseConfig.DrugStorehouseOut, orgId, item.ProjectId, item.SupplyCount)
+
 				}
 
 				//删除流水
 				if len(drugOutList) == 0 {
 					service.UpdateDrugWarehouseById(drugOut.ID)
 				}
+
+				//查询默认仓库剩余多少库存
+				list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgId, item.ProjectId)
+				var sum_count int64
+				var sum_in_count int64
+				for _, it := range list {
+					baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
+					if it.MaxUnit == baseDrug.MaxUnit {
+						it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
+						it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
+
+					}
+					sum_count += it.StockMaxNumber + it.StockMinNumber
+					sum_in_count += it.WarehousingCount
+				}
+				service.UpdateDrugCountOne(houseConfig.DrugStorehouseOut, orgId, item.ProjectId, sum_count)
+
 			}
 			//耗材
 			if item.IsSource == 2 {
 
 				//更改库存
 				err := service.UpdateWarehousingInfoById(item.ProjectId, item.SupplyWarehouseDetailInfo, info)
+
 				service.ModifyGoodAddInformation(item.ProjectId, item.SupplyCount, item.UserOrgId)
+
+				//扣减出库数量
+				service.ReduceGoodSumOutCount(houseConfig.StorehouseOutInfo, item.ProjectId, item.UserOrgId, item.SupplyCount)
+
+				//查询剩余库存
+				goodList, _ := service.GetGoodSumCountByStoreId(houseConfig.StorehouseOutInfo, item.ProjectId, item.UserOrgId)
+				var sum_count int64
+				for _, item := range goodList {
+					sum_count += item.StockCount
+				}
+				//更新剩余库存
+				service.UpdateGoodFlushCount(houseConfig.StorehouseOutInfo, item.ProjectId, item.UserOrgId, sum_count)
 				fmt.Println(err)
 				//删除出库记录
 				service.DeleteGoodWarehouseOut(item.ProjectId, item.WarehouseCancelId, orgId)

models/dialysis.go

 	BloodAccessInternalFistula string        `gorm:"column:blood_access_internal_fistula" json:"blood_access_internal_fistula" form:"blood_access_internal_fistula"`
 	Catheter                   string        `gorm:"column:catheter" json:"catheter" form:"catheter"`
 	Cruor                      string        `gorm:"column:cruor" json:"cruor" form:"cruor"`
+	Url                        string        `gorm:"column:url" json:"url" form:"url"`
+	Hash                       string        `gorm:"column:hash" json:"hash" form:"hash"`
 }
 
 func (DialysisOrder) TableName() string {

models/drug.go

 	SumCount              int64                  `gorm:"column:sum_count" json:"sum_count" form:"sum_count"`
 	SumInCount            int64                  `gorm:"column:sum_in_count" json:"sum_in_count" form:"sum_in_count"`
 	IsPharmacy            int64                  `gorm:"column:is_pharmacy" json:"is_pharmacy" form:"is_pharmacy"`
+	TotalCount            int64                  `gorm:"column:total_count" json:"total_count" form:"total_count"`
+	DrugStockLimitCount   int64                  `gorm:"column:drug_stock_limit_count" json:"drug_stock_limit_count" form:"drug_stock_limit_count"`
+	SumOutCount           int64                  `gorm:"column:sum_out_count" json:"sum_out_count" form:"sum_out_count"`
+	SumCancelCount        int64                  `gorm:"column:sum_cancel_count" json:"sum_cancel_count" form:"sum_cancel_count"`
 }
 
 func (BaseDrugLib) TableName() string {
 func (MedicineInsurancePercentage) TableName() string {
 	return "xt_medicine_insurance_percentage"
 }
+
+type BaseDrugLibNight struct {
+	ID                          int64                   `gorm:"column:id" json:"id" form:"id"`
+	DrugName                    string                  `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
+	Pinyin                      string                  `gorm:"column:pinyin" json:"pinyin" form:"pinyin"`
+	Wubi                        string                  `gorm:"column:wubi" json:"wubi" form:"wubi"`
+	DrugAlias                   string                  `gorm:"column:drug_alias" json:"drug_alias" form:"drug_alias"`
+	DrugAliasPinyin             string                  `gorm:"column:drug_alias_pinyin" json:"drug_alias_pinyin" form:"drug_alias_pinyin"`
+	DrugAliasWubi               string                  `gorm:"column:drug_alias_wubi" json:"drug_alias_wubi" form:"drug_alias_wubi"`
+	DrugCategory                int64                   `gorm:"column:drug_category" json:"drug_category" form:"drug_category"`
+	DrugSpec                    string                  `gorm:"column:drug_spec" json:"drug_spec" form:"drug_spec"`
+	DrugType                    int64                   `gorm:"column:drug_type" json:"drug_type" form:"drug_type"`
+	DrugStockLimit              string                  `gorm:"column:drug_stock_limit" json:"drug_stock_limit" form:"drug_stock_limit"`
+	DrugOriginPlace             string                  `gorm:"column:drug_origin_place" json:"drug_origin_place" form:"drug_origin_place"`
+	DrugDosageForm              int64                   `gorm:"column:drug_dosage_form" json:"drug_dosage_form" form:"drug_dosage_form"`
+	MedicalInsuranceLevel       int64                   `gorm:"column:medical_insurance_level" json:"medical_insurance_level" form:"medical_insurance_level"`
+	MaxUnit                     string                  `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinNumber                   int64                   `gorm:"column:min_number" json:"min_number" form:"min_number"`
+	MinUnit                     string                  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	Dose                        string                  `gorm:"column:dose" json:"dose" form:"dose"`
+	DoseUnit                    string                  `gorm:"column:dose_unit" json:"dose_unit" form:"dose_unit"`
+	MinPrice                    float64                 `gorm:"column:min_price" json:"min_price" form:"min_price"`
+	UnitMatrixing               string                  `gorm:"column:unit_matrixing" json:"unit_matrixing" form:"unit_matrixing"`
+	RetailPrice                 float64                 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	LastPrice                   float64                 `gorm:"column:last_price" json:"last_price" form:"last_price"`
+	DrugControl                 int64                   `gorm:"column:drug_control" json:"drug_control" form:"drug_control"`
+	Number                      string                  `gorm:"column:number" json:"number" form:"number"`
+	DrugClassify                string                  `gorm:"column:drug_classify" json:"drug_classify" form:"drug_classify"`
+	DrugDose                    float64                 `gorm:"column:drug_dose" json:"drug_dose" form:"drug_dose"`
+	DrugDoseUnit                int64                   `gorm:"column:drug_dose_unit" json:"drug_dose_unit" form:"drug_dose_unit"`
+	MedicalInsuranceNumber      string                  `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
+	ProvincesCode               string                  `gorm:"column:provinces_code" json:"provinces_code" form:"provinces_code"`
+	Manufacturer                int64                   `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	PharmacologyCategory        int64                   `gorm:"column:pharmacology_category" json:"pharmacology_category" form:"pharmacology_category"`
+	StatisticsCategory          int64                   `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
+	Code                        string                  `gorm:"column:code" json:"code" form:"code"`
+	IsSpecialDiseases           int64                   `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
+	IsRecord                    int64                   `gorm:"column:is_record" json:"is_record" form:"is_record"`
+	Agent                       string                  `gorm:"column:agent" json:"agent" form:"agent"`
+	DrugStatus                  string                  `gorm:"column:drug_status" json:"drug_status" form:"drug_status"`
+	LimitRemark                 string                  `gorm:"column:limit_remark" json:"limit_remark" form:"limit_remark"`
+	DeliveryWay                 string                  `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
+	ExecutionFrequency          string                  `gorm:"column:execution_frequency" json:"execution_frequency" form:"execution_frequency"`
+	SingleDose                  float64                 `gorm:"column:single_dose" json:"single_dose" form:"single_dose"`
+	PrescribingNumber           float64                 `gorm:"column:prescribing_number" json:"prescribing_number" form:"prescribing_number"`
+	Label                       int64                   `gorm:"column:label" json:"label" form:"label"`
+	Sort                        int64                   `gorm:"column:sort" json:"sort" form:"sort"`
+	IsUseDoctorAdvice           int64                   `gorm:"column:is_use_doctor_advice" json:"is_use_doctor_advice" form:"is_use_doctor_advice"`
+	IsDefault                   int64                   `gorm:"column:is_default" json:"is_default" form:"is_default"`
+	IsChargePredict             int64                   `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
+	IsStatisticsWork            int64                   `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
+	IsChargeUse                 int64                   `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
+	Status                      int64                   `gorm:"column:status" json:"status" form:"status"`
+	Ctime                       int64                   `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                       int64                   `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	OrgId                       int64                   `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	DrugCode                    string                  `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
+	Dealer                      int64                   `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	PrescriptionMark            int64                   `gorm:"column:prescription_mark" json:"prescription_mark" form:"prescription_mark"`
+	RecordDate                  int64                   `gorm:"column:record_date" json:"record_date" form:"record_date"`
+	DrugRemark                  string                  `gorm:"column:drug_remark" json:"drug_remark" form:"drug_remark"`
+	SocialSecurityDirectoryCode string                  `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
+	DoseCode                    string                  `gorm:"column:dose_code" json:"dose_code" form:"dose_code"`
+	IsMark                      int64                   `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
+	HospApprFlag                int64                   `gorm:"column:hosp_appr_flag" json:"hosp_appr_flag" form:"hosp_appr_flag"`
+	LmtUsedFlag                 int64                   `gorm:"column:lmt_used_flag" json:"lmt_used_flag" form:"lmt_used_flag"`
+	DrugDay                     string                  `gorm:"column:drug_day" json:"drug_day" form:"drug_day"`
+	Total                       float64                 `gorm:"column:total" json:"total" form:"total"`
+	PrescribingNumberUnit       string                  `gorm:"column:prescribing_number_unit" json:"prescribing_number_unit" form:"prescribing_number_unit"`
+	DrugWarehouseInfo           []*XtDrugWarehouseInfo  `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_info"`
+	XtDrugWarehouseInfo         []*XtDrugWarehouseInfo  `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_info"`
+	DrugWarehouseOutInfo        []*DrugWarehouseOutInfo `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_out"`
+	DrugCancelStockInfo         []*DrugCancelStockInfo  `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_cancel_info"`
+	IsUse                       int64                   `gorm:"column:is_user" json:"is_user" form:"is_user"`
+	BatchRetaiPrice             float64                 `gorm:"column:batch_retai_price" json:"batch_retai_price" form:"batch_retai_price"`
+	SumCount                    int64                   `gorm:"column:sum_count" json:"sum_count" form:"sum_count"`
+	SumInCount                  int64                   `gorm:"column:sum_in_count" json:"sum_in_count" form:"sum_in_count"`
+	IsPharmacy                  int64                   `gorm:"column:is_pharmacy" json:"is_pharmacy" form:"is_pharmacy"`
+}
+
+func (BaseDrugLibNight) TableName() string {
+	return "xt_base_drug"
+}
+
+type BaseDrugLibTwenty struct {
+	ID                  int64  `gorm:"column:id" json:"id" form:"id"`
+	DrugName            string `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
+	Status              int64  `gorm:"column:status" json:"status" form:"status"`
+	OrgId               int64  `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	MaxUnit             string `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinNumber           int64  `gorm:"column:min_number" json:"min_number" form:"min_number"`
+	MinUnit             string `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	DrugStockLimitCount int64  `gorm:"column:drug_stock_limit_count" json:"drug_stock_limit_count" form:"drug_stock_limit_count"`
+}
+
+func (BaseDrugLibTwenty) TableName() string {
+	return "xt_base_drug"
+}

models/drug_stock.go

 	PharmacyId              int64       `gorm:"column:pharmacy_id" json:"pharmacy_id" form:"pharmacy_id"`
 	IsCheck                 int64       `gorm:"column:is_check" json:"is_check" form:"is_check"`
 	BaseDrugLib             BaseDrugLib `gorm:"ForeignKey:ID;AssociationForeignKey:DrugId"json:"drug" `
+	OverCount               int64       `gorm:"column:over_count" json:"over_count" form:"over_count"`
 }
 
 func (DrugWarehouseOutInfo) TableName() string {
 	LastPrice                 float64              `gorm:"column:last_price" json:"last_price" form:"last_price"`
 	StockCount                string               `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
 	PharmacyId                int64                `gorm:"column:pharmacy_id" json:"pharmacy_id" form:"pharmacy_id"`
+	DrugWarehouseInfoOne      DrugWarehouseInfo    `gorm:"ForeignKey:ID;AssociationForeignKey:WarehousingDetailId"json:"xt_drug_warehouse_info" `
+	IsRead                    int64                `gorm:"column:is_read" json:"is_read" form:"is_read"`
+	IsCheck                   int64                `gorm:"column:is_check" json:"is_check" form:"is_check"`
+	OverCount                 int64                `gorm:"column:over_count" json:"over_count" form:"over_count"`
+	RetailPrice               float64              `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
 }
 
 func (DrugFlow) TableName() string {
 func (DrugWarehouseInfoTwenty) TableName() string {
 	return "xt_drug_warehouse_info"
 }
+
+type XtDrugWarehouseFlushInfo struct {
+	ID                      int64  `gorm:"column:id" json:"id" form:"id"`
+	DrugMaxNumber           int64  `gorm:"column:drug_max_number" json:"drug_max_number" form:"drug_max_number"`
+	UserOrgId               int64  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	WarehouseOutId          int64  `gorm:"column:warehouse_out_id" json:"warehouse_out_id" form:"warehouse_out_id"`
+	Type                    int64  `gorm:"column:type" json:"type" form:"type"`
+	SystemTime              int64  `gorm:"column:system_time" json:"system_time" form:"system_time"`
+	PatientId               int64  `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	Ctime                   int64  `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                   int64  `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	BatchNumberId           int64  `gorm:"column:batch_number_id" json:"batch_number_id" form:"batch_number_id"`
+	DrugId                  int64  `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
+	Count                   int64  `gorm:"column:count" json:"count" form:"count"`
+	WarehouseOutOrderNumber string `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number" form:"warehouse_out_order_number"`
+	Creater                 int64  `gorm:"column:creater" json:"creater" form:"creater"`
+	DrugMinNumber           int64  `gorm:"column:drug_min_number" json:"drug_min_number" form:"drug_min_number"`
+	Unit                    string `gorm:"column:unit" json:"unit" form:"unit"`
+	AdviceId                int64  `gorm:"column:advice_id" json:"advice_id" form:"advice_id"`
+	Status                  int64  `gorm:"column:status" json:"status" form:"status"`
+	WarehouseOutDetailId    int64  `gorm:"column:warehouse_out_detail_id" json:"warehouse_out_detail_id" form:"warehouse_out_detail_id"`
+}
+
+func (XtDrugWarehouseFlushInfo) TableName() string {
+	return "xt_drug_warehouse_flush_info"
+}

models/good_models.go

 	MedicalInsuranceNumber string  `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
 	ProvincesCode          string  `gorm:"column:provinces_code" json:"provinces_code" form:"provinces_code"`
 
-	IsSpecialDiseases           int64                `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
-	IsRecord                    int64                `gorm:"column:is_record" json:"is_record" form:"is_record"`
-	StatisticsCategory          int64                `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
-	GoodStatus                  string               `gorm:"column:good_status" json:"good_status" form:"good_status"`
-	DefaultCount                int64                `gorm:"column:default_count" json:"default_count" form:"default_count"`
-	Sign                        int64                `gorm:"column:sign" json:"sign" form:"sign"`
-	IsDefault                   int64                `gorm:"column:is_default" json:"is_default" form:"is_default"`
-	IsChargeUse                 int64                `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
-	IsChargePredict             int64                `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
-	IsStatisticsWork            int64                `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
-	Sort                        int64                `gorm:"column:sort" json:"sort" form:"sort"`
-	IsDoctorUse                 int64                `gorm:"column:is_doctor_use" json:"is_doctor_use" form:"is_doctor_use"`
-	Agent                       string               `gorm:"column:agent" json:"agent" form:"agent"`
-	GoodNumber                  string               `gorm:"column:good_number" json:"good_number" form:"good_number"`
-	GoodsType                   GoodsType            `gorm:"ForeignKey:ID;AssociationForeignKey:GoodTypeId" json:"type"`
-	CommdityCode                string               `gorm:"column:commdity_code" json:"commdity_code" form:"commdity_code"`
-	SocialSecurityDirectoryCode string               `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
-	ProductionType              string               `gorm:"column:production_type" json:"production_type" form:"production_type"`
-	SpecialMedical              string               `gorm:"column:special_medical" json:"special_medical" form:"special_medical"`
-	IsMark                      int64                `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
-	MinNumber                   int64                `gorm:"column:min_number" json:"min_number" form:"min_number"`
-	PackingUnit                 string               `gorm:"column:packing_unit" json:"packing_unit" form:"packing_unit"`
-	PackingPrice                float64              `gorm:"column:packing_price" json:"packing_price" form:"packing_price"`
-	DefaultCountUnit            string               `gorm:"column:default_count_unit" json:"default_count_unit" form:"default_count_unit"`
-	MinUnit                     string               `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
-	Total                       float64              `gorm:"column:total" json:"total" form:"total"`
-	StWarehousingInfo           []*StWarehousingInfo `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"xt_warehouse_info"`
-	CancelStockInfo             []*CancelStockInfo   `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"cancel_stock_info"`
-	RegisterNumber              string               `gorm:"column:register_number" json:"register_number" form:"register_number"`
-	GoodSotckInfo               []*GoodSotckInfo     `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"good_stock_in"`
-	IsUser                      int64                `gorm:"column:is_user" json:"is_user" form:"is_user"`
-	Number                      string               `gorm:"column:number" json:"number" form:"number"`
-	IsWarehouse                 int64                `gorm:"column:is_warehouse" json:"is_warehouse" form:"is_warehouse"`
-	SumCount                    int64                `gorm:"column:sum_count" json:"sum_count" form:"sum_count"`
-	BatchRetaiPrice             float64              `gorm:"column:batch_retai_price" json:"batch_retai_price" form:"batch_retai_price"`
-	SumInCount                  int64                `gorm:"column:sum_in_count" json:"sum_in_count" form:"sum_in_count"`
-	WarehousingInfo             []*WarehousingInfo   `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"warehouse_info"`
-	WarehouseOutInfo            []*WarehouseOutInfo  `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"warehouse_out_info"`
+	IsSpecialDiseases           int64                   `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
+	IsRecord                    int64                   `gorm:"column:is_record" json:"is_record" form:"is_record"`
+	StatisticsCategory          int64                   `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
+	GoodStatus                  string                  `gorm:"column:good_status" json:"good_status" form:"good_status"`
+	DefaultCount                int64                   `gorm:"column:default_count" json:"default_count" form:"default_count"`
+	Sign                        int64                   `gorm:"column:sign" json:"sign" form:"sign"`
+	IsDefault                   int64                   `gorm:"column:is_default" json:"is_default" form:"is_default"`
+	IsChargeUse                 int64                   `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
+	IsChargePredict             int64                   `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
+	IsStatisticsWork            int64                   `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
+	Sort                        int64                   `gorm:"column:sort" json:"sort" form:"sort"`
+	IsDoctorUse                 int64                   `gorm:"column:is_doctor_use" json:"is_doctor_use" form:"is_doctor_use"`
+	Agent                       string                  `gorm:"column:agent" json:"agent" form:"agent"`
+	GoodNumber                  string                  `gorm:"column:good_number" json:"good_number" form:"good_number"`
+	GoodsType                   GoodsType               `gorm:"ForeignKey:ID;AssociationForeignKey:GoodTypeId" json:"type"`
+	CommdityCode                string                  `gorm:"column:commdity_code" json:"commdity_code" form:"commdity_code"`
+	SocialSecurityDirectoryCode string                  `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
+	ProductionType              string                  `gorm:"column:production_type" json:"production_type" form:"production_type"`
+	SpecialMedical              string                  `gorm:"column:special_medical" json:"special_medical" form:"special_medical"`
+	IsMark                      int64                   `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
+	MinNumber                   int64                   `gorm:"column:min_number" json:"min_number" form:"min_number"`
+	PackingUnit                 string                  `gorm:"column:packing_unit" json:"packing_unit" form:"packing_unit"`
+	PackingPrice                float64                 `gorm:"column:packing_price" json:"packing_price" form:"packing_price"`
+	DefaultCountUnit            string                  `gorm:"column:default_count_unit" json:"default_count_unit" form:"default_count_unit"`
+	MinUnit                     string                  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	Total                       float64                 `gorm:"column:total" json:"total" form:"total"`
+	StWarehousingInfo           []*StWarehousingInfo    `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"xt_warehouse_info"`
+	CancelStockInfo             []*CancelStockInfo      `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"cancel_stock_info"`
+	RegisterNumber              string                  `gorm:"column:register_number" json:"register_number" form:"register_number"`
+	GoodSotckInfo               []*GoodSotckInfo        `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"good_stock_in"`
+	IsUser                      int64                   `gorm:"column:is_user" json:"is_user" form:"is_user"`
+	Number                      string                  `gorm:"column:number" json:"number" form:"number"`
+	IsWarehouse                 int64                   `gorm:"column:is_warehouse" json:"is_warehouse" form:"is_warehouse"`
+	SumCount                    int64                   `gorm:"column:sum_count" json:"sum_count" form:"sum_count"`
+	BatchRetaiPrice             float64                 `gorm:"column:batch_retai_price" json:"batch_retai_price" form:"batch_retai_price"`
+	SumInCount                  int64                   `gorm:"column:sum_in_count" json:"sum_in_count" form:"sum_in_count"`
+	WarehousingInfoOne          []*StartWarehousingInfo `gorm:"json:"warehouse_info"` //期间增加
+
+	WarehousingInfoStart []*StartWarehousingInfo `gorm:"json:"warehouse_info_start"`
+
+	WarehousingInfoEnd []*StartWarehousingInfo `gorm:"json:"warehouse_info_end"`
+	WarehousingInfo    []*WarehousingInfo      `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"warehouse_info"`
+	WarehouseOutInfo   []*WarehouseOutInfo     `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"warehouse_out_info"`
+
+	WarehouseOutInfoEnd   []*VmStockFlow
+	WarehouseOutInfoStart []*VmStockFlow
+	WarehouseInfoEnd      []*VmStockFlow //期末入库量
+
+	StartFlowWarehouseInfo []*VmStockFlow //本期增加
+
+	//期初结余
+	StartFlowInfo    []*VmStockFlow
+	StartOutFlowInfo []*VmStockFlow
+
+	//期末结余
+	EndFlowInfo    []*VmStockFlow
+	EndFlowOutInfo []*VmStockFlow
+
+	//期初退库
+	StartCancelFlowInfo []*VmStockFlow
+	//期末退库
+	EndCancelFLowInfo []*VmStockFlow
+
+	StartEndCancelFLowInfo []*VmStockFlow
+
+	WareStartStockInventoryProfit []*VmStockFlow //期初盘盈
+	WareStartStockInventoryLosses []*VmStockFlow //期初盘亏
+
+	WareEndStockInventoryProfit []*VmStockFlow //期末盘盈
+	WareEndStockInventoryLosses []*VmStockFlow //期末盘亏
+
+	WareStartEndStockInventoryProfit []*VmStockFlow //期间盘盈
+	WareStartEndStockInventoryLosses []*VmStockFlow //期间盘亏
+	SumOutCount                      int64          `gorm:"column:sum_out_count" json:"sum_out_count" form:"sum_out_count"`
+	SumCancelCount                   int64          `gorm:"column:sum_cancel_count" json:"sum_cancel_count" form:"sum_cancel_count"`
+	TotalCount                       int64          `gorm:"column:total_count" json:"total_count" form:"total_count"`
 }
 
 func (GoodInfo) TableName() string {

models/new_stock_models.go

+package models
+
+type XtGoodStockCount struct {
+	ID               int64 `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId        int64 `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	GoodId           int64 `gorm:"column:good_id" json:"good_id" form:"good_id"`
+	StorehouseId     int64 `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	Status           int64 `gorm:"column:status" json:"status" form:"status"`
+	Ctime            int64 `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime            int64 `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	StockInCount     int64 `gorm:"column:stock_in_count" json:"stock_in_count" form:"stock_in_count"`
+	StockOutCount    int64 `gorm:"column:stock_out_count" json:"stock_out_count" form:"stock_out_count"`
+	StockCancelCount int64 `gorm:"column:stock_cancel_count" json:"stock_cancel_count" form:"stock_cancel_count"`
+	FlushCount       int64 `gorm:"column:flush_count" json:"flush_count" form:"flush_count"`
+	StockActOutCount int64 `gorm:"column:stock_act_out_count" json:"stock_act_out_count" form:"stock_act_out_count"`
+}
+
+func (XtGoodStockCount) TableName() string {
+	return "xt_good_stock_count"
+}
+
+type XtGoodErrcode struct {
+	ID             int64  `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId      int64  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	Errcode        string `gorm:"column:errcode" json:"errcode" form:"errcode"`
+	GoodId         int64  `gorm:"column:good_id" json:"good_id" form:"good_id"`
+	Status         int64  `gorm:"column:status" json:"status" form:"status"`
+	Ctime          int64  `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime          int64  `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Count          int64  `gorm:"column:count" json:"count" form:"count"`
+	StockCount     int64  `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
+	Creater        int64  `gorm:"column:creater" json:"creater" form:"creater"`
+	BatchNumberId  int64  `gorm:"column:batch_number_id" json:"batch_number_id" form:"batch_number_id"`
+	WarehouseOutId int64  `gorm:"column:warehouse_out_id" json:"warehouse_out_id" form:"warehouse_out_id"`
+	PatientId      int64  `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	Code           string `gorm:"column:code" json:"code" form:"code"`
+}
+
+func (XtGoodErrcode) TableName() string {
+	return "xt_good_errcode"
+}
+
+type XtDrugStockCount struct {
+	ID             int64 `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId      int64 `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	StorehouseId   int64 `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	SumInCount     int64 `gorm:"column:sum_in_count" json:"sum_in_count" form:"sum_in_count"`
+	SumOutCount    int64 `gorm:"column:sum_out_count" json:"sum_out_count" form:"sum_out_count"`
+	SumCancelCount int64 `gorm:"column:sum_cancel_count" json:"sum_cancel_count" form:"sum_cancel_count"`
+	DrugId         int64 `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
+	Ctime          int64 `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime          int64 `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Status         int64 `gorm:"column:status" json:"status" form:"status"`
+	FlushCount     int64 `gorm:"column:flush_count" json:"flush_count" form:"flush_count"`
+	SumActOutCount int64 `gorm:"column:sum_act_out_count" json:"sum_act_out_count" form:"sum_act_out_count"`
+}
+
+func (XtDrugStockCount) TableName() string {
+	return "xt_drug_stock_count"
+}
+
+type NewBaseDrug struct {
+	ID                     int64   `gorm:"column:id" json:"id" form:"id"`
+	DrugName               string  `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
+	Pinyin                 string  `gorm:"column:pinyin" json:"pinyin" form:"pinyin"`
+	Wubi                   string  `gorm:"column:wubi" json:"wubi" form:"wubi"`
+	DrugAlias              string  `gorm:"column:drug_alias" json:"drug_alias" form:"drug_alias"`
+	DrugAliasPinyin        string  `gorm:"column:drug_alias_pinyin" json:"drug_alias_pinyin" form:"drug_alias_pinyin"`
+	DrugAliasWubi          string  `gorm:"column:drug_alias_wubi" json:"drug_alias_wubi" form:"drug_alias_wubi"`
+	DrugCategory           int64   `gorm:"column:drug_category" json:"drug_category" form:"drug_category"`
+	DrugSpec               string  `gorm:"column:drug_spec" json:"drug_spec" form:"drug_spec"`
+	DrugType               int64   `gorm:"column:drug_type" json:"drug_type" form:"drug_type"`
+	DrugStockLimit         string  `gorm:"column:drug_stock_limit" json:"drug_stock_limit" form:"drug_stock_limit"`
+	DrugOriginPlace        string  `gorm:"column:drug_origin_place" json:"drug_origin_place" form:"drug_origin_place"`
+	DrugDosageForm         int64   `gorm:"column:drug_dosage_form" json:"drug_dosage_form" form:"drug_dosage_form"`
+	MedicalInsuranceLevel  int64   `gorm:"column:medical_insurance_level" json:"medical_insurance_level" form:"medical_insurance_level"`
+	MaxUnit                string  `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinNumber              int64   `gorm:"column:min_number" json:"min_number" form:"min_number"`
+	MinUnit                string  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	Dose                   string  `gorm:"column:dose" json:"dose" form:"dose"`
+	DoseUnit               string  `gorm:"column:dose_unit" json:"dose_unit" form:"dose_unit"`
+	UnitMatrixing          string  `gorm:"column:unit_matrixing" json:"unit_matrixing" form:"unit_matrixing"`
+	RetailPrice            float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	MinPrice               float64 `gorm:"column:min_price" json:"min_price" form:"min_price"`
+	LastPrice              float64 `gorm:"column:last_price" json:"last_price" form:"last_price"`
+	DrugControl            int64   `gorm:"column:drug_control" json:"drug_control" form:"drug_control"`
+	Number                 string  `gorm:"column:number" json:"number" form:"number"`
+	DrugClassify           string  `gorm:"column:drug_classify" json:"drug_classify" form:"drug_classify"`
+	DrugDose               float64 `gorm:"column:drug_dose" json:"drug_dose" form:"drug_dose"`
+	DrugDoseUnit           int64   `gorm:"column:drug_dose_unit" json:"drug_dose_unit" form:"drug_dose_unit"`
+	MedicalInsuranceNumber string  `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
+	ProvincesCode          string  `gorm:"column:provinces_code" json:"provinces_code" form:"provinces_code"`
+
+	Manufacturer                int64                  `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	PharmacologyCategory        int64                  `gorm:"column:pharmacology_category" json:"pharmacology_category" form:"pharmacology_category"`
+	StatisticsCategory          int64                  `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
+	Code                        string                 `gorm:"column:code" json:"code" form:"code"`
+	IsSpecialDiseases           int64                  `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
+	IsRecord                    int64                  `gorm:"column:is_record" json:"is_record" form:"is_record"`
+	Agent                       string                 `gorm:"column:agent" json:"agent" form:"agent"`
+	DrugStatus                  string                 `gorm:"column:drug_status" json:"drug_status" form:"drug_status"`
+	LimitRemark                 string                 `gorm:"column:limit_remark" json:"limit_remark" form:"limit_remark"`
+	DeliveryWay                 string                 `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
+	ExecutionFrequency          string                 `gorm:"column:execution_frequency" json:"execution_frequency" form:"execution_frequency"`
+	SingleDose                  float64                `gorm:"column:single_dose" json:"single_dose" form:"single_dose"`
+	PrescribingNumber           float64                `gorm:"column:prescribing_number" json:"prescribing_number" form:"prescribing_number"`
+	Label                       int64                  `gorm:"column:label" json:"label" form:"label"`
+	Sort                        int64                  `gorm:"column:sort" json:"sort" form:"sort"`
+	IsUseDoctorAdvice           int64                  `gorm:"column:is_use_doctor_advice" json:"is_use_doctor_advice" form:"is_use_doctor_advice"`
+	IsDefault                   int64                  `gorm:"column:is_default" json:"is_default" form:"is_default"`
+	IsChargePredict             int64                  `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
+	IsStatisticsWork            int64                  `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
+	IsChargeUse                 int64                  `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
+	Status                      int64                  `gorm:"column:status" json:"status" form:"status"`
+	Ctime                       int64                  `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                       int64                  `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	OrgId                       int64                  `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	DrugCode                    string                 `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
+	Dealer                      int64                  `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	PrescriptionMark            int64                  `gorm:"column:prescription_mark" json:"prescription_mark" form:"prescription_mark"`
+	RecordDate                  int64                  `gorm:"column:record_date" json:"record_date" form:"record_date"`
+	DrugRemark                  string                 `gorm:"column:drug_remark" json:"drug_remark" form:"drug_remark"`
+	SocialSecurityDirectoryCode string                 `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
+	DoseCode                    string                 `gorm:"column:dose_code" json:"dose_code" form:"dose_code"`
+	IsMark                      int64                  `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
+	HospApprFlag                int64                  `gorm:"column:hosp_appr_flag" json:"hosp_appr_flag" form:"hosp_appr_flag"`
+	LmtUsedFlag                 int64                  `gorm:"column:lmt_used_flag" json:"lmt_used_flag" form:"lmt_used_flag"`
+	DrugDay                     string                 `gorm:"column:drug_day" json:"drug_day" form:"drug_day"`
+	Total                       float64                `gorm:"column:total" json:"total" form:"total"`
+	PrescribingNumberUnit       string                 `gorm:"column:prescribing_number_unit" json:"prescribing_number_unit" form:"prescribing_number_unit"`
+	DrugWarehouseInfo           []*VsDrugWarehouseInfo `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_info"`
+	XtDrugStockCount            []*XtDrugStockCount    `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_stock_count"`
+	DrugStockCount              []*XtDrugStockCount    `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_stock_info"`
+	TotalCount                  int64                  `gorm:"column:total_count" json:"total_count" form:"total_count"`
+	IsUser                      int64                  `gorm:"column:is_user" json:"is_user" form:"is_user"`
+	BatchRetaiPrice             float64                `gorm:"column:batch_retai_price" json:"batch_retai_price" form:"batch_retai_price"`
+	DrugStockLimitCount         int64                  `gorm:"column:drug_stock_limit_count" json:"drug_stock_limit_count" form:"drug_stock_limit_count"`
+	SumCount                    int64                  `gorm:"column:sum_count" json:"sum_count" form:"sum_count"`
+	SumInCount                  int64                  `gorm:"column:sum_in_count" json:"sum_in_count" form:"sum_in_count"`
+	IsPharmacy                  int64                  `gorm:"column:is_pharmacy" json:"is_pharmacy" form:"is_pharmacy"`
+}
+
+func (NewBaseDrug) TableName() string {
+	return "xt_base_drug"
+}
+
+type XtDialysisSetting struct {
+	ID                    int64 `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId             int64 `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	Status                int64 `gorm:"column:status" json:"status" form:"status"`
+	DeviceNumber          int64 `gorm:"column:device_number" json:"device_number" form:"device_number"`
+	DeviceType            int64 `gorm:"column:device_type" json:"device_type" form:"device_type"`
+	Name                  int64 `gorm:"column:name" json:"name" form:"name"`
+	AdmissionNumber       int64 `gorm:"column:admission_number" json:"admission_number" form:"admission_number"`
+	DialysisNo            int64 `gorm:"column:dialysis_no" json:"dialysis_no" form:"dialysis_no"`
+	WeightBefor           int64 `gorm:"column:weight_befor" json:"weight_befor" form:"weight_befor"`
+	DryWeight             int64 `gorm:"column:dry_weight" json:"dry_weight" form:"dry_weight"`
+	BloodPressure         int64 `gorm:"column:blood_pressure" json:"blood_pressure" form:"blood_pressure"`
+	UltrafiltrationVolume int64 `gorm:"column:ultrafiltration_volume" json:"ultrafiltration_volume" form:"ultrafiltration_volume"`
+	InternalFistula       int64 `gorm:"column:internal_fistula" json:"internal_fistula" form:"internal_fistula"`
+	BloodFlowVolume       int64 `gorm:"column:blood_flow_volume" json:"blood_flow_volume" form:"blood_flow_volume"`
+	Anticoagulant         int64 `gorm:"column:anticoagulant" json:"anticoagulant" form:"anticoagulant"`
+	SealingFluidDispose   int64 `gorm:"column:sealing_fluid_dispose" json:"sealing_fluid_dispose" form:"sealing_fluid_dispose"`
+	ModeId                int64 `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	DialysisTime          int64 `gorm:"column:dialysis_time" json:"dialysis_time" form:"dialysis_time"`
+	DialysisDialyszers    int64 `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
+	DialysisIrrigation    int64 `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
+	Gaijiliang            int64 `gorm:"column:gaijiliang" json:"gaijiliang" form:"gaijiliang"`
+	Kalium                int64 `gorm:"column:kalium" json:"kalium" form:"kalium"`
+	DisplaceLiquiValue    int64 `gorm:"column:displace_liqui_value" json:"displace_liqui_value" form:"displace_liqui_value"`
+	Bicarbonate           int64 `gorm:"column:bicarbonate" json:"bicarbonate" form:"bicarbonate"`
+	Glucose               int64 `gorm:"column:glucose" json:"glucose" form:"glucose"`
+	Ctime                 int64 `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                 int64 `gorm:"column:mtime" json:"mtime" form:"mtime"`
+}
+
+func (XtDialysisSetting) TableName() string {
+	return "xt_dialysis_setting"
+}

models/patient_models.go

 	EpoCount                   float64 `gorm:"column:epo_count" json:"epo_count" form:"epo_count"`
 	MaxUltrafiltrationRate     float64 `gorm:"column:max_ultrafiltration_rate" json:"max_ultrafiltration_rate" form:"max_ultrafiltration_rate"`
 	PreImpulse                 float64 `gorm:"column:pre_impulse" json:"pre_impulse" form:"pre_impulse"`
+	SolutionStatus             int64   `gorm:"column:solution_status" json:"solution_status" form:"solution_status"`
 }
 
 func (DialysisSolution) TableName() string {

models/schedule_models.go

 func (VmBloodPatients) TableName() string {
 	return "xt_patients"
 }
+
+type VmBloodSchedule struct {
+	ID               int64                      `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId        int64                      `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PartitionId      int64                      `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
+	BedId            int64                      `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
+	PatientId        int64                      `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	ScheduleDate     int64                      `gorm:"column:schedule_date" json:"schedule_date" form:"schedule_date"`
+	ScheduleType     int64                      `gorm:"column:schedule_type" json:"schedule_type" form:"schedule_type"`
+	ScheduleWeek     int64                      `gorm:"column:schedule_week" json:"schedule_week" form:"schedule_week"`
+	ModeId           int64                      `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	Status           int64                      `gorm:"column:status" json:"status" form:"status"`
+	CreatedTime      int64                      `gorm:"column:created_time" json:"created_time" form:"created_time"`
+	UpdatedTime      int64                      `gorm:"column:updated_time" json:"updated_time" form:"updated_time"`
+	IsExport         int64                      `gorm:"column:is_export" json:"is_export" form:"is_export"`
+	DeviceNumber     *NewMDeviceNumberVM        `gorm:"ForeignKey:BedId" json:"device_number"`
+	SchedualPatient  *NewMSchedualPatientVMList `gorm:"ForeignKey:PatientId" json:"patient"`
+	DialysisSolution DialysisSolution           `gorm:"ForeignKey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId" json:"dialysis_solution"`
+}
+
+func (VmBloodSchedule) TableName() string {
+	return "xt_schedule"
+}
+
+type NewMDeviceNumberVM struct {
+	DeviceNumber
+
+	Zone *DeviceZone `gorm:"ForeignKey:ZoneID" json:"zone"`
+}
+
+func (NewMDeviceNumberVM) TableName() string {
+	return "xt_device_number"
+}
+
+type NewMSchedualPatientVMList struct {
+	ID                 int64  `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId          int64  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	UserId             int64  `gorm:"column:user_id" json:"user_id" form:"user_id"`
+	PatientType        int64  `gorm:"column:patient_type" json:"patient_type" form:"patient_type"`
+	DialysisNo         string `gorm:"column:dialysis_no" json:"dialysis_no" form:"dialysis_no"`
+	Avatar             string `gorm:"column:avatar" json:"avatar" form:"avatar"`
+	Gender             int64  `gorm:"column:gender" json:"gender" form:"gender"`
+	Birthday           int64  `gorm:"column:birthday" json:"birthday" form:"birthday"`
+	Age                int64  `gorm:"column:age" json:"age"`
+	Name               string `gorm:"column:name" json:"name" form:"name"`
+	IdCardNo           string `gorm:"column:id_card_no" json:"id_card_no" form:"id_card_no"`
+	UserSysBeforeCount int64  `gorm:"column:user_sys_before_count" json:"user_sys_before_count" form:"user_sys_before_count"`
+	TrobleShoot        int64  `gorm:"column:troble_shoot" json:"troble_shoot" form:"troble_shoot"`
+}
+
+func (NewMSchedualPatientVMList) TableName() string {
+	return "xt_patients"
+}

models/self_drug_models.go

 	BatchNumber             string     `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
 	XtBaseDrug              XtBaseDrug `gorm:"ForeignKey:ID;AssociationForeignKey:DrugId" `
 	StorehouseId            int64      `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	AdviceId                int64      `gorm:"column:advice_id" json:"advice_id" form:"advice_id"`
 }
 
 func (XtDrugWarehouseOutInfo) TableName() string {
 	CancelStockInfo             []*CancelStockInfo  `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"cancel_stock_info"`
 	WarehousingInfo             []*WarehousingInfo  `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"warehouse_info"`
 	WarehouseOutInfo            []*WarehouseOutInfo `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"warehouse_out_info"`
+	FlowOutInfo                 []*VmStockFlow      `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"stock_flow_out_info"`
+	FlowCancelInfo              []*VmStockFlow      `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"stock_flow_cancel_info"`
 }
 
 func (NewGoodInformation) TableName() string {
 	return "xt_good_information"
 }
+
+type GoodInformation struct {
+	ID                          int64               `gorm:"column:id" json:"id" form:"id"`
+	GoodCode                    string              `gorm:"column:good_code" json:"good_code" form:"good_code"`
+	SpecificationName           string              `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
+	GoodTypeId                  int64               `gorm:"column:good_type_id" json:"good_type_id" form:"good_type_id"`
+	GoodUnit                    int64               `gorm:"column:good_unit" json:"good_unit" form:"good_unit"`
+	BuyPrice                    float64             `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
+	SellPrice                   float64             `gorm:"column:sell_price" json:"sell_price" form:"sell_price"`
+	Remark                      string              `gorm:"column:remark" json:"remark" form:"remark"`
+	Ctime                       int64               `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                       int64               `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Manufacturer                int64               `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	Dealer                      int64               `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	ExpiryDateWarnDayCount      int64               `gorm:"column:expiry_date_warn_day_count" json:"expiry_date_warn_day_count" form:"expiry_date_warn_day_count"`
+	StockWarnCount              int64               `gorm:"column:stock_warn_count" json:"stock_warn_count" form:"stock_warn_count"`
+	IsReuse                     int64               `gorm:"column:is_reuse" json:"is_reuse" form:"is_reuse"`
+	Status                      int64               `gorm:"column:status" json:"status" form:"status"`
+	FilmArea                    string              `gorm:"column:film_area" json:"film_area" form:"film_area"`
+	IsUse                       int64               `gorm:"column:is_use" json:"is_use" form:"is_use"`
+	FilmMaterialQuality         string              `gorm:"column:film_material_quality" json:"film_material_quality" form:"film_material_quality"`
+	OrgId                       int64               `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	Modifier                    int64               `gorm:"column:modifier" json:"modifier" form:"modifier"`
+	Creater                     int64               `gorm:"column:creater" json:"creater" form:"creater"`
+	GoodName                    string              `gorm:"column:good_name" json:"good_name" form:"good_name"`
+	Pinyin                      string              `gorm:"column:pinyin" json:"pinyin" form:"pinyin"`
+	Wubi                        string              `gorm:"column:wubi" json:"wubi" form:"wubi"`
+	GoodKind                    int64               `gorm:"column:good_kind" json:"good_kind" form:"good_kind"`
+	MedicalInsuranceLevel       int64               `gorm:"column:medical_insurance_level" json:"medical_insurance_level" form:"medical_insurance_level"`
+	RetailPrice                 float64             `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	MedicalInsuranceNumber      string              `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
+	IsSpecialDiseases           int64               `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
+	IsRecord                    int64               `gorm:"column:is_record" json:"is_record" form:"is_record"`
+	StatisticsCategory          int64               `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
+	GoodStatus                  string              `gorm:"column:good_status" json:"good_status" form:"good_status"`
+	DefaultCount                int64               `gorm:"column:default_count" json:"default_count" form:"default_count"`
+	IsDefault                   int64               `gorm:"column:is_default" json:"is_default" form:"is_default"`
+	IsChargeUse                 int64               `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
+	IsChargePredict             int64               `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
+	IsStatisticsWork            int64               `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
+	Sign                        int64               `gorm:"column:sign" json:"sign" form:"sign"`
+	Sort                        int64               `gorm:"column:sort" json:"sort" form:"sort"`
+	IsDoctorUse                 int64               `gorm:"column:is_doctor_use" json:"is_doctor_use" form:"is_doctor_use"`
+	Agent                       string              `gorm:"column:agent" json:"agent" form:"agent"`
+	GoodNumber                  string              `gorm:"column:good_number" json:"good_number" form:"good_number"`
+	CommdityCode                string              `gorm:"column:commdity_code" json:"commdity_code" form:"commdity_code"`
+	SocialSecurityDirectoryCode string              `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
+	ProductionType              string              `gorm:"column:production_type" json:"production_type" form:"production_type"`
+	SpecialMedical              string              `gorm:"column:special_medical" json:"special_medical" form:"special_medical"`
+	IsMark                      int64               `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
+	Total                       float64             `gorm:"column:total" json:"total" form:"total"`
+	MinNumber                   int64               `gorm:"column:min_number" json:"min_number" form:"min_number"`
+	PackingUnit                 string              `gorm:"column:packing_unit" json:"packing_unit" form:"packing_unit"`
+	PackingPrice                float64             `gorm:"column:packing_price" json:"packing_price" form:"packing_price"`
+	DefaultCountUnit            string              `gorm:"column:default_count_unit" json:"default_count_unit" form:"default_count_unit"`
+	MinUnit                     string              `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	RegisterNumber              string              `gorm:"column:register_number" json:"register_number" form:"register_number"`
+	ProvincesCode               string              `gorm:"column:provinces_code" json:"provinces_code" form:"provinces_code"`
+	IsUser                      int64               `gorm:"column:is_user" json:"is_user" form:"is_user"`
+	Number                      string              `gorm:"column:number" json:"number" form:"number"`
+	IsWarehouse                 string              `gorm:"column:is_warehouse" json:"is_warehouse" form:"is_warehouse"`
+	BatchRetaiPrice             float64             `gorm:"column:batch_retai_price" json:"batch_retai_price" form:"batch_retai_price"`
+	SumCount                    int64               `gorm:"column:sum_count" json:"sum_count" form:"sum_count"`
+	SumInCount                  int64               `gorm:"column:sum_in_count" json:"sum_in_count" form:"sum_in_count"`
+	ManufacturerName            string              `gorm:"column:manufacturer_name" json:"manufacturer_name" form:"manufacturer_name"`
+	XtGoodStockCount            []*XtGoodStockCount `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"xt_good_stock"`
+	GoodStockCount              []*XtGoodStockCount `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"xt_good_stock_info"`
+	WarehousingInfo             []*WarehousingInfo  `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"xt_warehouse_info"`
+}
+
+func (GoodInformation) TableName() string {
+	return "xt_good_information"
+}

models/stock_models.go

 }
 
 type WarehouseOutInfo struct {
-	ID                      int64        `gorm:"column:id" json:"id"`
-	WarehouseOutId          int64        `gorm:"column:warehouse_out_id" json:"warehouse_out_id"`
-	WarehouseInfotId        int64        `gorm:"column:warehouse_info_id" json:"warehouse_info_id"`
-	GoodId                  int64        `gorm:"column:good_id" json:"good_id"`
-	GoodTypeId              int64        `gorm:"column:good_type_id" json:"good_type_id"`
-	WarehousingOutTarget    int64        `gorm:"column:warehousing_out_target" json:"warehousing_out_target"`
-	Count                   int64        `gorm:"column:count" json:"count"`
-	Price                   float64      `gorm:"column:price" json:"price"`
-	TotalPrice              float64      `gorm:"column:total_price" json:"total_price"`
-	ProductDate             int64        `gorm:"column:product_date" json:"product_date"`
-	ExpiryDate              int64        `gorm:"column:expiry_date" json:"expiry_date"`
-	Mtime                   int64        `gorm:"column:mtime" json:"mtime"`
-	Ctime                   int64        `gorm:"column:ctime" json:"ctime"`
-	Status                  int64        `gorm:"column:status" json:"status"`
-	OrgId                   int64        `gorm:"column:org_id" json:"org_id"`
-	Remark                  string       `gorm:"column:remark" json:"remark"`
-	IsCancel                int64        `gorm:"column:is_cancel" json:"is_cancel"`
-	WarehouseOut            WarehouseOut `ForeignKey:WarehouseOutId json:"WarehouseOut"`
-	WarehouseOutOrderNumber string       `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number"`
-	GoodInfo                GoodInfo     `gorm:"ForeignKey:ID;AssociationForeignKey:GoodId" `
-	Type                    int64        `gorm:"column:type" json:"type"`
-	Dealer                  int64        `gorm:"column:dealer" json:"dealer"`
-	Manufacturer            int64        `gorm:"column:manufacturer" json:"manufacturer"`
-	IsSys                   int64        `gorm:"column:is_sys" json:"is_sys"`
-	SysRecordTime           int64        `gorm:"column:sys_record_time" json:"sys_record_time"`
-	PatientId               int64        `gorm:"column:patient_id" json:"patient_id"`
-	Number                  string       `gorm:"column:number" json:"number" form:"number"`
-	LicenseNumber           string       `gorm:"column:license_number" json:"license_number" form:"license_number"`
-	ConsumableType          int64        `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
-	ProjectId               int64        `gorm:"column:project_id" json:"project_id" form:"project_id"`
-	SupplyCancelOutId       int64        `gorm:"column:supply_cancel_out_id" json:"supply_cancel_out_id" form:"supply_cancel_out_id"`
-	SupplyWarehouseId       int64        `gorm:"column:supply_warehouse_id" json:"supply_warehouse_id" form:"supply_warehouse_id"`
-	IsSource                int64        `gorm:"column:is_source" json:"is_source" form:"is_source"`
-	StorehouseId            int64        `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
-	SecondWarehouseInfoId   int64        `gorm:"column:second_warehouse_info_id" json:"second_warehouse_info_id" form:"second_warehouse_info_id"`
-	AdminUserId             int64        `gorm:"column:admin_user_id" json:"admin_user_id" form:"admin_user_id"`
-	BuyPrice                float64      `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
-	StockCount              string       `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
-	IsCheck                 int64        `gorm:"column:is_check" json:"is_check" form:"is_check"`
-	RegisterNumber          string       `gorm:"column:register_number" json:"register_number" form:"register_number"`
+	ID                      int64           `gorm:"column:id" json:"id"`
+	WarehouseOutId          int64           `gorm:"column:warehouse_out_id" json:"warehouse_out_id"`
+	WarehouseInfotId        int64           `gorm:"column:warehouse_info_id" json:"warehouse_info_id"`
+	GoodId                  int64           `gorm:"column:good_id" json:"good_id"`
+	GoodTypeId              int64           `gorm:"column:good_type_id" json:"good_type_id"`
+	WarehousingOutTarget    int64           `gorm:"column:warehousing_out_target" json:"warehousing_out_target"`
+	Count                   int64           `gorm:"column:count" json:"count"`
+	Price                   float64         `gorm:"column:price" json:"price"`
+	TotalPrice              float64         `gorm:"column:total_price" json:"total_price"`
+	ProductDate             int64           `gorm:"column:product_date" json:"product_date"`
+	ExpiryDate              int64           `gorm:"column:expiry_date" json:"expiry_date"`
+	Mtime                   int64           `gorm:"column:mtime" json:"mtime"`
+	Ctime                   int64           `gorm:"column:ctime" json:"ctime"`
+	Status                  int64           `gorm:"column:status" json:"status"`
+	OrgId                   int64           `gorm:"column:org_id" json:"org_id"`
+	Remark                  string          `gorm:"column:remark" json:"remark"`
+	IsCancel                int64           `gorm:"column:is_cancel" json:"is_cancel"`
+	WarehouseOut            WarehouseOut    `ForeignKey:WarehouseOutId json:"WarehouseOut"`
+	WarehouseOutOrderNumber string          `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number"`
+	GoodInfo                GoodInfo        `gorm:"ForeignKey:ID;AssociationForeignKey:GoodId" `
+	Type                    int64           `gorm:"column:type" json:"type"`
+	Dealer                  int64           `gorm:"column:dealer" json:"dealer"`
+	Manufacturer            int64           `gorm:"column:manufacturer" json:"manufacturer"`
+	IsSys                   int64           `gorm:"column:is_sys" json:"is_sys"`
+	SysRecordTime           int64           `gorm:"column:sys_record_time" json:"sys_record_time"`
+	PatientId               int64           `gorm:"column:patient_id" json:"patient_id"`
+	Number                  string          `gorm:"column:number" json:"number" form:"number"`
+	LicenseNumber           string          `gorm:"column:license_number" json:"license_number" form:"license_number"`
+	ConsumableType          int64           `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
+	ProjectId               int64           `gorm:"column:project_id" json:"project_id" form:"project_id"`
+	SupplyCancelOutId       int64           `gorm:"column:supply_cancel_out_id" json:"supply_cancel_out_id" form:"supply_cancel_out_id"`
+	SupplyWarehouseId       int64           `gorm:"column:supply_warehouse_id" json:"supply_warehouse_id" form:"supply_warehouse_id"`
+	IsSource                int64           `gorm:"column:is_source" json:"is_source" form:"is_source"`
+	StorehouseId            int64           `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	SecondWarehouseInfoId   int64           `gorm:"column:second_warehouse_info_id" json:"second_warehouse_info_id" form:"second_warehouse_info_id"`
+	AdminUserId             int64           `gorm:"column:admin_user_id" json:"admin_user_id" form:"admin_user_id"`
+	BuyPrice                float64         `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
+	StockCount              string          `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
+	IsCheck                 int64           `gorm:"column:is_check" json:"is_check" form:"is_check"`
+	RegisterNumber          string          `gorm:"column:register_number" json:"register_number" form:"register_number"`
+	WarehousingInfo         WarehousingInfo `gorm:"ForeignKey:ID;AssociationForeignKey:WarehouseInfotId" `
+	VmStockFlow             VmStockFlow     `gorm:"ForeignKey:ID;AssociationForeignKey:WarehouseOutDetailId" json:"stock_flow"`
+	OverCount               int64           `gorm:"column:over_count" json:"over_count" form:"over_count"`
 }
 
 func (WarehouseOutInfo) TableName() string {
 }
 
 type WarehouseOutInfoNight struct {
-	ID               int64 `gorm:"column:id" json:"id"`
-	Count            int64 `gorm:"column:count" json:"count"`
-	GoodId           int64 `gorm:"column:good_id" json:"good_id"`
-	SysRecordTime    int64 `gorm:"column:sys_record_time" json:"sys_record_time"`
-	PatientId        int64 `gorm:"column:patient_id" json:"patient_id"`
-	ProjectId        int64 `gorm:"column:project_id" json:"project_id" form:"project_id"`
-	WarehouseInfotId int64 `gorm:"column:warehouse_info_id" json:"warehouse_info_id"`
-	IsSys            int64 `gorm:"column:is_sys" json:"is_sys"`
-	Status           int64 `gorm:"column:status" json:"status"`
-	OrgId            int64 `gorm:"column:org_id" json:"org_id"`
+	ID                      int64   `gorm:"column:id" json:"id"`
+	Count                   int64   `gorm:"column:count" json:"count"`
+	GoodId                  int64   `gorm:"column:good_id" json:"good_id"`
+	SysRecordTime           int64   `gorm:"column:sys_record_time" json:"sys_record_time"`
+	PatientId               int64   `gorm:"column:patient_id" json:"patient_id"`
+	ProjectId               int64   `gorm:"column:project_id" json:"project_id" form:"project_id"`
+	WarehouseInfotId        int64   `gorm:"column:warehouse_info_id" json:"warehouse_info_id"`
+	IsSys                   int64   `gorm:"column:is_sys" json:"is_sys"`
+	Status                  int64   `gorm:"column:status" json:"status"`
+	OrgId                   int64   `gorm:"column:org_id" json:"org_id"`
+	WarehouseOutOrderNumber string  `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number" form:"warehouse_out_order_number"`
+	StorehouseId            int64   `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	Price                   float64 `gorm:"column:price" json:"price" form:"price"`
+	Dealer                  int64   `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	Manufacturer            int64   `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	GoodTypeId              int64   `gorm:"column:good_type_id" json:"good_type_id" form:"good_type_id"`
+	ProductDate             int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
+	ExpiryDate              int64   `gorm:"column:expiry_date" json:"expiry_date" form:"expiry_date"`
+	Number                  string  `gorm:"column:number" json:"number" form:"number"`
+	LicenseNumber           string  `gorm:"column:license_number" json:"license_number" form:"license_number"`
 }
 
 func (WarehouseOutInfoNight) TableName() string {
 }
 
 type WarehouseOutInfoSeven struct {
-	ID    int64 `gorm:"column:id" json:"id"`
-	Count int64 `gorm:"column:count" json:"count"`
+	ID            int64 `gorm:"column:id" json:"id"`
+	Count         int64 `gorm:"column:count" json:"count"`
+	SysRecordTime int64 `gorm:"column:sys_record_time" json:"sys_record_time"`
+	PatientId     int64 `gorm:"column:patient_id" json:"patient_id"`
+	GoodId        int64 `gorm:"column:good_id" json:"good_id"`
 }
 
 func (WarehouseOutInfoSeven) TableName() string {
 }
 
 type VmStockFlow struct {
-	ID                        int64   `gorm:"column:id" json:"id" form:"id"`
-	WarehousingId             int64   `gorm:"column:warehousing_id" json:"warehousing_id" form:"warehousing_id"`
-	GoodId                    int64   `gorm:"column:good_id" json:"good_id" form:"good_id"`
-	Number                    string  `gorm:"column:number" json:"number" form:"number"`
-	LicenseNumber             string  `gorm:"column:license_number" json:"license_number" form:"license_number"`
-	Count                     int64   `gorm:"column:count" json:"count" form:"count"`
-	UserOrgId                 int64   `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
-	PatientId                 int64   `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
-	SystemTime                int64   `gorm:"column:system_time" json:"system_time" form:"system_time"`
-	ConsumableType            int64   `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
-	IsSys                     int64   `gorm:"column:is_sys" json:"is_sys" form:"is_sys"`
-	WarehousingOrder          string  `gorm:"column:warehousing_order" json:"warehousing_order" form:"warehousing_order"`
-	WarehouseOutId            int64   `gorm:"column:warehouse_out_id" json:"warehouse_out_id" form:"warehouse_out_id"`
-	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         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"`
-	UpdateCreator             int64   `gorm:"column:update_creator" json:"update_creator" form:"update_creator"`
-	Status                    int64   `gorm:"column:status" json:"status" form:"status"`
-	Ctime                     int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
-	Mtime                     int64   `gorm:"column:mtime" json:"mtime" form:"mtime"`
-	Price                     float64 `gorm:"column:price" json:"price" form:"price"`
-	WarehousingDetailId       int64   `gorm:"column:warehousing_detail_id" json:"warehousing_detail_id" form:"warehousing_detail_id"`
-	WarehouseOutDetailId      int64   `gorm:"column:warehouse_out_detail_id" json:"warehouse_out_detail_id" form:"warehouse_out_detail_id"`
-	CancelOutDetailId         int64   `gorm:"column:cancel_out_detail_id" json:"cancel_out_detail_id" form:"cancel_out_detail_id"`
-	ProductDate               int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
-	ExpireDate                int64   `gorm:"column:expire_date" json:"expire_date" form:"expire_date"`
-	ReturnCount               int64   `gorm:"column:return_count" json:"return_count" form:"return_count"`
-	ProjectId                 int64   `gorm:"column:project_id" json:"project_id" form:"project_id"`
-	SupplyWarehouseId         int64   `gorm:"column:supply_warehouse_id" json:"supply_warehouse_id" form:"supply_warehouse_id"`
-	SupplyCancelOutId         int64   `gorm:"column:supply_cancel_out_id" json:"supply_cancel_out_id" form:"supply_cancel_out_id"`
-	SupplyWarehouseDetailInfo int64   `gorm:"column:supply_warehouse_detail_info" json:"supply_warehouse_detail_info" form:"supply_warehouse_detail_info"`
-	StorehouseId              int64   `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
-	SecondWarehouseInfoId     int64   `gorm:"column:second_warehouse_info_id" json:"second_warehouse_info_id" form:"second_warehouse_info_id"`
-	AdminUserId               int64   `gorm:"column:admin_user_id" json:"admin_user_id" form:"admin_user_id"`
-	BuyPrice                  float64 `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
-	StockCount                string  `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
-	RegisterNumber            string  `gorm:"column:register_number" json:"register_number" form:"register_number"`
-	BatchNumberCount          int64   `gorm:"column:batch_number_count" json:"batch_number_count" form:"batch_number_count"`
+	ID                        int64           `gorm:"column:id" json:"id" form:"id"`
+	WarehousingId             int64           `gorm:"column:warehousing_id" json:"warehousing_id" form:"warehousing_id"`
+	GoodId                    int64           `gorm:"column:good_id" json:"good_id" form:"good_id"`
+	Number                    string          `gorm:"column:number" json:"number" form:"number"`
+	LicenseNumber             string          `gorm:"column:license_number" json:"license_number" form:"license_number"`
+	Count                     int64           `gorm:"column:count" json:"count" form:"count"`
+	UserOrgId                 int64           `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PatientId                 int64           `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	SystemTime                int64           `gorm:"column:system_time" json:"system_time" form:"system_time"`
+	ConsumableType            int64           `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
+	IsSys                     int64           `gorm:"column:is_sys" json:"is_sys" form:"is_sys"`
+	WarehousingOrder          string          `gorm:"column:warehousing_order" json:"warehousing_order" form:"warehousing_order"`
+	WarehouseOutId            int64           `gorm:"column:warehouse_out_id" json:"warehouse_out_id" form:"warehouse_out_id"`
+	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         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"`
+	UpdateCreator             int64           `gorm:"column:update_creator" json:"update_creator" form:"update_creator"`
+	Status                    int64           `gorm:"column:status" json:"status" form:"status"`
+	Ctime                     int64           `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                     int64           `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Price                     float64         `gorm:"column:price" json:"price" form:"price"`
+	WarehousingDetailId       int64           `gorm:"column:warehousing_detail_id" json:"warehousing_detail_id" form:"warehousing_detail_id"`
+	WarehouseOutDetailId      int64           `gorm:"column:warehouse_out_detail_id" json:"warehouse_out_detail_id" form:"warehouse_out_detail_id"`
+	CancelOutDetailId         int64           `gorm:"column:cancel_out_detail_id" json:"cancel_out_detail_id" form:"cancel_out_detail_id"`
+	ProductDate               int64           `gorm:"column:product_date" json:"product_date" form:"product_date"`
+	ExpireDate                int64           `gorm:"column:expire_date" json:"expire_date" form:"expire_date"`
+	ReturnCount               int64           `gorm:"column:return_count" json:"return_count" form:"return_count"`
+	ProjectId                 int64           `gorm:"column:project_id" json:"project_id" form:"project_id"`
+	SupplyWarehouseId         int64           `gorm:"column:supply_warehouse_id" json:"supply_warehouse_id" form:"supply_warehouse_id"`
+	SupplyCancelOutId         int64           `gorm:"column:supply_cancel_out_id" json:"supply_cancel_out_id" form:"supply_cancel_out_id"`
+	SupplyWarehouseDetailInfo int64           `gorm:"column:supply_warehouse_detail_info" json:"supply_warehouse_detail_info" form:"supply_warehouse_detail_info"`
+	StorehouseId              int64           `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	SecondWarehouseInfoId     int64           `gorm:"column:second_warehouse_info_id" json:"second_warehouse_info_id" form:"second_warehouse_info_id"`
+	AdminUserId               int64           `gorm:"column:admin_user_id" json:"admin_user_id" form:"admin_user_id"`
+	BuyPrice                  float64         `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
+	StockCount                string          `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
+	RegisterNumber            string          `gorm:"column:register_number" json:"register_number" form:"register_number"`
+	BatchNumberCount          int64           `gorm:"column:batch_number_count" json:"batch_number_count" form:"batch_number_count"`
+	WarehousingInfo           WarehousingInfo `gorm:"ForeignKey:ID;AssociationForeignKey:WarehousingId" json:"xt_warehouse_info"`
+	IsRead                    int64           `gorm:"column:is_read" json:"is_read" form:"is_read"`
+	IsCheck                   int64           `gorm:"column:is_check" json:"is_check" form:"is_check"`
+	OverCount                 int64           `gorm:"column:over_count" json:"over_count" form:"over_count"`
 }
 
 func (VmStockFlow) TableName() string {
 	MedicalInsuranceNumber string  `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
 	ProvincesCode          string  `gorm:"column:provinces_code" json:"provinces_code" form:"provinces_code"`
 
-	Manufacturer                int64                     `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
-	PharmacologyCategory        int64                     `gorm:"column:pharmacology_category" json:"pharmacology_category" form:"pharmacology_category"`
-	StatisticsCategory          int64                     `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
-	Code                        string                    `gorm:"column:code" json:"code" form:"code"`
-	IsSpecialDiseases           int64                     `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
-	IsRecord                    int64                     `gorm:"column:is_record" json:"is_record" form:"is_record"`
-	Agent                       string                    `gorm:"column:agent" json:"agent" form:"agent"`
-	DrugStatus                  string                    `gorm:"column:drug_status" json:"drug_status" form:"drug_status"`
-	LimitRemark                 string                    `gorm:"column:limit_remark" json:"limit_remark" form:"limit_remark"`
-	DeliveryWay                 string                    `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
-	ExecutionFrequency          string                    `gorm:"column:execution_frequency" json:"execution_frequency" form:"execution_frequency"`
-	SingleDose                  float64                   `gorm:"column:single_dose" json:"single_dose" form:"single_dose"`
-	PrescribingNumber           float64                   `gorm:"column:prescribing_number" json:"prescribing_number" form:"prescribing_number"`
-	Label                       int64                     `gorm:"column:label" json:"label" form:"label"`
-	Sort                        int64                     `gorm:"column:sort" json:"sort" form:"sort"`
-	IsUseDoctorAdvice           int64                     `gorm:"column:is_use_doctor_advice" json:"is_use_doctor_advice" form:"is_use_doctor_advice"`
-	IsDefault                   int64                     `gorm:"column:is_default" json:"is_default" form:"is_default"`
-	IsChargePredict             int64                     `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
-	IsStatisticsWork            int64                     `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
-	IsChargeUse                 int64                     `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
-	Status                      int64                     `gorm:"column:status" json:"status" form:"status"`
-	Ctime                       int64                     `gorm:"column:ctime" json:"ctime" form:"ctime"`
-	Mtime                       int64                     `gorm:"column:mtime" json:"mtime" form:"mtime"`
-	OrgId                       int64                     `gorm:"column:org_id" json:"org_id" form:"org_id"`
-	DrugCode                    string                    `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
-	Dealer                      int64                     `gorm:"column:dealer" json:"dealer" form:"dealer"`
-	PrescriptionMark            int64                     `gorm:"column:prescription_mark" json:"prescription_mark" form:"prescription_mark"`
-	RecordDate                  int64                     `gorm:"column:record_date" json:"record_date" form:"record_date"`
-	DrugRemark                  string                    `gorm:"column:drug_remark" json:"drug_remark" form:"drug_remark"`
-	SocialSecurityDirectoryCode string                    `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
-	DoseCode                    string                    `gorm:"column:dose_code" json:"dose_code" form:"dose_code"`
-	IsMark                      int64                     `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
-	HospApprFlag                int64                     `gorm:"column:hosp_appr_flag" json:"hosp_appr_flag" form:"hosp_appr_flag"`
-	LmtUsedFlag                 int64                     `gorm:"column:lmt_used_flag" json:"lmt_used_flag" form:"lmt_used_flag"`
-	DrugDay                     string                    `gorm:"column:drug_day" json:"drug_day" form:"drug_day"`
-	Total                       float64                   `gorm:"column:total" json:"total" form:"total"`
-	PrescribingNumberUnit       string                    `gorm:"column:prescribing_number_unit" json:"prescribing_number_unit" form:"prescribing_number_unit"`
-	DrugWarehouseInfo           []*VsDrugWarehouseInfo    `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_info"`
-	DrugWarehouse               []*DrugWarehouseInfo      `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse"`
-	DrugCancelStockInfo         []*VsDrugCancelStockInfo  `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_cancel_stock_info"`
-	DrugWarehouseOutInfo        []*VsDrugWarehouseOutInfo `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_out"`
+	Manufacturer                     int64                     `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	PharmacologyCategory             int64                     `gorm:"column:pharmacology_category" json:"pharmacology_category" form:"pharmacology_category"`
+	StatisticsCategory               int64                     `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
+	Code                             string                    `gorm:"column:code" json:"code" form:"code"`
+	IsSpecialDiseases                int64                     `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
+	IsRecord                         int64                     `gorm:"column:is_record" json:"is_record" form:"is_record"`
+	Agent                            string                    `gorm:"column:agent" json:"agent" form:"agent"`
+	DrugStatus                       string                    `gorm:"column:drug_status" json:"drug_status" form:"drug_status"`
+	LimitRemark                      string                    `gorm:"column:limit_remark" json:"limit_remark" form:"limit_remark"`
+	DeliveryWay                      string                    `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
+	ExecutionFrequency               string                    `gorm:"column:execution_frequency" json:"execution_frequency" form:"execution_frequency"`
+	SingleDose                       float64                   `gorm:"column:single_dose" json:"single_dose" form:"single_dose"`
+	PrescribingNumber                float64                   `gorm:"column:prescribing_number" json:"prescribing_number" form:"prescribing_number"`
+	Label                            int64                     `gorm:"column:label" json:"label" form:"label"`
+	Sort                             int64                     `gorm:"column:sort" json:"sort" form:"sort"`
+	IsUseDoctorAdvice                int64                     `gorm:"column:is_use_doctor_advice" json:"is_use_doctor_advice" form:"is_use_doctor_advice"`
+	IsDefault                        int64                     `gorm:"column:is_default" json:"is_default" form:"is_default"`
+	IsChargePredict                  int64                     `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
+	IsStatisticsWork                 int64                     `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
+	IsChargeUse                      int64                     `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
+	Status                           int64                     `gorm:"column:status" json:"status" form:"status"`
+	Ctime                            int64                     `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                            int64                     `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	OrgId                            int64                     `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	DrugCode                         string                    `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
+	Dealer                           int64                     `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	PrescriptionMark                 int64                     `gorm:"column:prescription_mark" json:"prescription_mark" form:"prescription_mark"`
+	RecordDate                       int64                     `gorm:"column:record_date" json:"record_date" form:"record_date"`
+	DrugRemark                       string                    `gorm:"column:drug_remark" json:"drug_remark" form:"drug_remark"`
+	SocialSecurityDirectoryCode      string                    `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
+	DoseCode                         string                    `gorm:"column:dose_code" json:"dose_code" form:"dose_code"`
+	IsMark                           int64                     `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
+	HospApprFlag                     int64                     `gorm:"column:hosp_appr_flag" json:"hosp_appr_flag" form:"hosp_appr_flag"`
+	LmtUsedFlag                      int64                     `gorm:"column:lmt_used_flag" json:"lmt_used_flag" form:"lmt_used_flag"`
+	DrugDay                          string                    `gorm:"column:drug_day" json:"drug_day" form:"drug_day"`
+	Total                            float64                   `gorm:"column:total" json:"total" form:"total"`
+	PrescribingNumberUnit            string                    `gorm:"column:prescribing_number_unit" json:"prescribing_number_unit" form:"prescribing_number_unit"`
+	DrugWarehouseInfo                []*VsDrugWarehouseInfo    `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_info"`
+	DrugWarehouse                    []*DrugWarehouseInfo      `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse"`
+	DrugCancelStockInfo              []*VsDrugCancelStockInfo  `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_cancel_stock_info"`
+	DrugWarehouseOutInfo             []*VsDrugWarehouseOutInfo `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_out"`
+	TotalCount                       int64                     `gorm:"column:total_count" json:"total_count" form:"total_count"`
+	IsUser                           int64                     `gorm:"column:is_user" json:"is_user" form:"is_user"`
+	BatchRetaiPrice                  float64                   `gorm:"column:batch_retai_price" json:"batch_retai_price" form:"batch_retai_price"`
+	DrugStockLimitCount              int64                     `gorm:"column:drug_stock_limit_count" json:"drug_stock_limit_count" form:"drug_stock_limit_count"`
+	SumCount                         int64                     `gorm:"column:sum_count" json:"sum_count" form:"sum_count"`
+	SumInCount                       int64                     `gorm:"column:sum_in_count" json:"sum_in_count" form:"sum_in_count"`
+	IsPharmacy                       int64                     `gorm:"column:is_pharmacy" json:"is_pharmacy" form:"is_pharmacy"`
+	DrugFlowWarehouseInfo            []*DrugFlow               `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_flow_info"`
+	DrugActFlowWarehouseInfo         []*DrugFlow               `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_act_flow_info"`
+	DrugWarehouseInfoStart           []*DrugFlow               //期初入库结余
+	DrugWarehouseOutInfoStart        []*DrugFlow               //期初出库结余
+	DrugWarehouseOutInfoEnd          []*DrugFlow               //期末出库结余
+	DrugWarehouseInfoEnd             []*DrugFlow               //期末入库结余
+	DrugWarehouseInfoStartEnd        []*DrugFlow               //期中增加
+	DrugWarehouseOutInfoStartEnd     []*DrugFlow               //  期中减少
+	WareStartStockInventoryProfit    []*DrugFlow               //期初盘盈
+	WareStartStockInventoryLosses    []*DrugFlow               //期初盘亏
+	WareEndStockInventoryProfit      []*DrugFlow               //期末盘盈
+	WareEndStockInventoryLosses      []*DrugFlow               //期末盘亏
+	WareStartEndStockInventoryProfit []*DrugFlow               //期间盘盈
+	WareStartEndStockInventoryLosses []*DrugFlow               //期间盘亏
+	WareStartStockCancelInfo         []*DrugFlow               //期初结余退库
+	WareEndStockCancelInfo           []*DrugFlow               //期末结余退库
+	WareStartEndStockCancelInfo      []*DrugFlow               //期中减少退库
+
 }
 
 func (VmBaseDrug) TableName() string {
 	Remark           string      `gorm:"column:remark" json:"remark" form:"remark"`
 	BatchNumber      string      `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
 	MaxUnit          string      `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	StorehouseId     int64       `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
 	BaseDrugLib      BaseDrugLib `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" `
 }
 
 	RetailPrice             float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
 	RetailTotalPrice        float64 `gorm:"column:retail_total_price" json:"retail_total_price" form:"retail_total_price"`
 	CountUnit               string  `gorm:"column:count_unit" json:"count_unit" form:"count_unit"`
+	StorehouseId            int64   `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
 }
 
 func (VsDrugWarehouseOutInfo) TableName() string {
 	PackingUnit             string  `gorm:"column:packing_unit" json:"packing_unit" form:"packing_unit"`
 	Ctime                   int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
 	Name                    string  `gorm:"column:name" json:"name" form:"name"`
+	IsRead                  int64   `gorm:"column:is_read" json:"is_read" form:"is_read"`
+	ConsumableType          int64   `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
 }
 
 type BloodWarehouseInfo struct {
 func (VmWarehousingInfoSix) TableName() string {
 	return "xt_warehouse_info"
 }
+
+type WarehousingInfoTen struct {
+	ID         int64 `gorm:"column:id" json:"id"`
+	GoodId     int64 `gorm:"column:good_id" json:"good_id"`
+	Status     int64 `gorm:"column:status" json:"status"`
+	OrgId      int64 `gorm:"column:org_id" json:"org_id"`
+	StockCount int64 `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
+	IsCheck    int64 `gorm:"column:is_check" json:"is_check" form:"is_check"`
+}
+
+func (WarehousingInfoTen) TableName() string {
+	return "xt_warehouse_info"
+}
+
+type XtWarehouseFlushInfo struct {
+	ID                      int64   `gorm:"column:id" json:"id" form:"id"`
+	FlushCount              int64   `gorm:"column:flush_count" json:"flush_count" form:"flush_count"`
+	UserOrgId               int64   `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	WarehouseOutId          int64   `gorm:"column:warehouse_out_id" json:"warehouse_out_id" form:"warehouse_out_id"`
+	Type                    int64   `gorm:"column:type" json:"type" form:"type"`
+	SystemTime              int64   `gorm:"column:system_time" json:"system_time" form:"system_time"`
+	PatientId               int64   `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	Ctime                   int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                   int64   `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	BatchNumberId           int64   `gorm:"column:batch_number_id" json:"batch_number_id" form:"batch_number_id"`
+	GoodId                  int64   `gorm:"column:good_id" json:"good_id" form:"good_id"`
+	Count                   int64   `gorm:"column:count" json:"count" form:"count"`
+	WarehouseOutOrderNumber string  `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number" form:"warehouse_out_order_number"`
+	Creater                 int64   `gorm:"column:creater" json:"creater" form:"creater"`
+	Status                  int64   `gorm:"column:status" json:"status" form:"status"`
+	WarehouseOutDetailId    int64   `gorm:"column:warehouse_out_detail_id" json:"warehouse_out_detail_id" form:"warehouse_out_detail_id"`
+	PackingPrice            float64 `gorm:"column:packing_price" json:"packing_price" form:"packing_price"`
+	BuyPrice                float64 `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
+}
+
+func (XtWarehouseFlushInfo) TableName() string {
+	return "xt_warehouse_flush_info"
+}
+
+type StartWarehousingInfo struct {
+	GoodId           int64   `gorm:"column:good_id" json:"good_id"`
+	StockCount       int64   `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
+	Ctime            int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	UserOrgId        int64   `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	IsCheck          int64   `gorm:"column:is_check" json:"is_check" form:"is_check"`
+	Price            float64 `gorm:"column:price" json:"price" form:"price"`
+	WarehousingCount int64   `gorm:"column:warehousing_count" json:"warehousing_count" form:"warehousing_count"`
+	WarehousingUnit  string  `gorm:"column:warehousing_unit" json:"warehousing_unit" form:"warehousing_unit"`
+	PackingPrice     float64 `gorm:"column:packing_price" json:"packing_price" form:"packing_price"`
+}
+
+func (StartWarehousingInfo) TableName() string {
+	return "xt_warehouse_info"
+}
+
+type StartDrugWarehouseInfo struct {
+	ID               int64   `gorm:"column:id" json:"id" form:"id"`
+	DrugId           int64   `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
+	Number           string  `gorm:"column:number" json:"number" form:"number"`
+	MaxUnit          string  `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinUnit          string  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	StockMaxNumber   int64   `gorm:"column:stock_max_number" json:"stock_max_number" form:"stock_max_number"`
+	StockMinNumber   int64   `gorm:"column:stock_min_number" json:"stock_min_number" form:"stock_min_number"`
+	Price            float64 `gorm:"column:price" json:"price" form:"price"`
+	RetailPrice      float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	IsCheck          int64   `gorm:"column:is_check" json:"is_check" form:"is_check"`
+	WarehousingCount int64   `gorm:"column:warehousing_count" json:"warehousing_count" form:"warehousing_count"`
+}
+
+func (StartDrugWarehouseInfo) TableName() string {
+	return "xt_drug_warehouse_info"
+}

service/admin_service.go

 	return &es, nil
 }
 
+func GetPatientSignature(orgID int64, patientid int64, dialysis_date int64) (*models.DialysisOrder, error) {
+	var es models.DialysisOrder
+	err := XTReadDB().Model(&models.DialysisOrder{}).Where("user_org_id=? and patient_id=? and dialysis_date=? and status=1", orgID, patientid, dialysis_date).First(&es).Error
+
+	if err == gorm.ErrRecordNotFound {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &es, nil
+}
+
 func GetPatinentHead(orgid int64, appid int64, userid int64) (*models.SgjUserAdminPatientHead, error) {
 	var es models.SgjUserAdminPatientHead
 	err := readUserDb.Model(&models.SgjUserAdminPatientHead{}).Where("org_id = ? and app_id = ? and creator=? and status =1", orgid, appid, userid).First(&es).Error

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
 	}
 	return &follow, nil
 }
+
+func UpdatePatientSign(patient_id int64, dialysis_date int64, order models.DialysisOrder, orgid int64) error {
+
+	err := XTWriteDB().Model(&order).Where("patient_id = ? and dialysis_date= ? and status = 1 and user_org_id = ?", patient_id, dialysis_date, orgid).Update(map[string]interface{}{"url": order.Url, "hash": order.Hash}).Error
+	return err
+}
+
+func GetPatientSign(patient_id int64, dialysis_date int64, orgid int64) (models.DialysisOrder, error) {
+	order := models.DialysisOrder{}
+	err := XTReadDB().Where("patient_id=? and dialysis_date = ? and user_org_id = ? and status = 1", patient_id, dialysis_date, orgid).Find(&order).Error
+	return order, err
+}

service/dialysis_solution_service.go

+package service
+
+import (
+	"XT_New/models"
+)
+
+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
+	}
+
+	return schedule, total, err
+}
+
+func GetDialysisAdviceTemplateList(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).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).Find(&schedule).Error
+	}
+
+	return schedule, total, err
+}
+
+func GetAllLongAdviceList(user_org_id int64) (advice []*models.DoctorAdvice, err error) {
+
+	err = XTReadDB().Where("user_org_id = ? and advice_type = 1 and status = 1", user_org_id).Find(&advice).Error
+	return advice, err
+}
+
+func GetAllHisAdviceTemplateList(user_org_id int64) (advice []*models.HisPrescriptionAdviceTemplate, err error) {
+
+	err = XTReadDB().Where("user_org_id = ? and status = 1", user_org_id).Find(&advice).Error
+	return advice, err
+}
+
+func SaveDialysisSetting(setting models.XtDialysisSetting) error {
+
+	err := XTWriteDB().Create(&setting).Error
+	return err
+}
+
+func GetDialysisSetting(orgid int64) (models.XtDialysisSetting, error) {
+
+	setting := models.XtDialysisSetting{}
+	err := XTReadDB().Where("user_org_id = ? and status = 1", orgid).Find(&setting).Error
+	return setting, 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

 
 	// cur_date := time.Now().Format("2006-01-02")
 	key := strconv.FormatInt(orgID, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate, 10) + ":doctor_advices"
-
+	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

 
 func GetAllDevicetByListSix(orgID int64) (devices []*models.MDeviceNumberForList, err error) {
 
-	err = readDb.Model(&models.MDeviceNumberForList{}).Preload("Zone", "status = 1 AND org_id = ?", orgID).Where("org_id=? and status=1 ", orgID).Find(&devices).Error
+	err = readDb.Model(&models.MDeviceNumberForList{}).Preload("Zone", "status = 1 AND org_id = ?", orgID).Where("org_id=?", orgID).Find(&devices).Error
 	return devices, err
 }
 
 	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/pharmacy_service.go

 	minmunber := t.MinNumber                               //拆零数量
 	terrUnit := ""
 	for _, v := range tmp {
+		fmt.Println("v2332233232322323", v.Quantity)
 		switch v.Unit {
 		case t.MaxUnit:
 			maxunit = maxunit + v.Quantity

service/secondary_service.go

 
 func GetDrugSumCountByStorehouseId(storehouse_id int64, orgid int64, drug_id int64) (info []*models.DrugWarehouseInfo, err error) {
 
-	err = XTReadDB().Where("storehouse_id = ? and org_id = ? and status = 1 and (stock_max_number >0 or stock_min_number>0) and drug_id =? and is_check = 1", storehouse_id, orgid, drug_id).Find(&info).Error
+	err = XTReadDB().Where("storehouse_id = ? and org_id = ? and status = 1  and drug_id =? and is_check = 1", storehouse_id, orgid, drug_id).Find(&info).Error
 	return info, 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 GetOrderDetailStockFlowByStorehouseById(id []string, orgid int64) (list []*models.VmStockFlow, err error) {
+	db := XTReadDB().Model(&list).Where("status = 1 and (consumable_type = 2 or consumable_type = 3)")
+	if len(id) > 0 {
+		db = db.Where("warehouse_out_id in (?)", id)
+	}
+	if orgid > 0 {
+		db = db.Where("user_org_id = ?", orgid)
+	}
+	err = db.Group("warehousing_id").Find(&list).Error
+	return list, err
+}
+
+func GetOrderDetailStockFlow(id []string, orgid int64) (list []*models.VmStockFlow, err error) {
+
+	db := XTReadDB().Model(&list).Where("status = 1 and (consumable_type = 2 or consumable_type = 3)")
+	if len(id) > 0 {
+		db = db.Where("warehouse_out_id in (?)", id)
+	}
+	if orgid > 0 {
+		db = db.Where("user_org_id = ?", orgid)
+	}
+	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&list).Error
+	return list, err
+}
+
+func GetOrderStockFlow(id []string, orgid int64) (list []*models.VmStockFlow, err error) {
+
+	db := XTReadDB().Model(&list).Where("status = 1 and consumable_type = 7 and patient_id > 0")
+	if len(id) > 0 {
+		db = db.Where("warehouse_out_id in (?)", id)
+	}
+	if orgid > 0 {
+		db = db.Where("user_org_id = ?", orgid)
+	}
+	err = db.Preload("WarehousingInfo", "org_id = ? and status = 1", orgid).Find(&list).Error
+	return list, err
+}
+
 func GetLastWarehouseOutInfo(ids []string, orgId int64) (info []*models.WarehouseOutInfoSix, err error) {
 
 	db := XTReadDB().Model(&info)
 
 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
 }
 
 	if len(warehouse_out_id) > 0 {
 		db = db.Where("x.warehouse_out_id in(?)", warehouse_out_id)
 	}
-	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.count,x.max_unit as count_unit,x.price,x.product_date,x.expire_date,x.warehouse_out_order_number,x.dealer,x.manufacturer,x.is_sys,x.number,x.batch_number,x.patient_id,x.ctime,b.dose,b.dose_unit,b.min_number,b.min_unit,b.max_unit,b.drug_name,b.drug_type,b.min_price").Joins("left join xt_base_drug as b on b.id = x.drug_id").Scan(&out).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.count,x.max_unit as count_unit,x.price,x.retail_price,x.product_date,x.expire_date,x.warehouse_out_order_number,x.dealer,x.manufacturer,x.is_sys,x.number,x.batch_number,x.patient_id,x.ctime,b.dose,b.dose_unit,b.min_number,b.min_unit,b.max_unit,b.drug_name,b.drug_type,b.min_price").Joins("left join xt_base_drug as b on b.id = x.drug_id").Scan(&out).Error
 	return out, 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
 }
 
 
 	err = XTWriteDB().Model(&info).Where("id = ? and org_id = ? and status = 1", drug_id, orgid).UpdateColumn("sum_count", gorm.Expr("sum_count - ?", sum_count)).Error
 	err = XTWriteDB().Model(&info).Where("id=? and org_id = ? and status = 1", drug_id, orgid).Update(map[string]interface{}{"batch_retai_price": batch_retai_price}).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 {
 }
 
 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 {
 }
 
 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 {
 }
 
 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 {
 }
 
 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 AddDrugWarehouseStockMinNumber(count int64, id int64) error {
 	tx := XTWriteDB().Begin()
-	err := XTWriteDB().Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_min_number", gorm.Expr("stock_min_number + ?", count)).Error
+	err := XTWriteDB().Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", count)).Error
 	if err != nil {
 		tx.Rollback()
 		return err
 	return err
 }
 
+func UpdateGoodInfoSumCountSix(goodid int64, sum_count int64, orgid int64) error {
+
+	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
+}
+
 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
 }
 
-func UpdateGoodInfoAddSumCount(goodid int64, sum_count int64, orgid int64) error {
+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}).Error
 	if err != nil {
 		tx.Rollback()
 		return err
 	}
+	err = tx.Model(&models.GoodInfo{}).Where("id = ? and org_id = ? and status = 1", goodid, orgid).Update(map[string]interface{}{"sum_in_count": sum_in_count}).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
 	tx.Commit()
 	return err
 }
 }
 
 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 {
-	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
+	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 {
-		tx.Rollback()
+		ut.Rollback()
 		return err
 	}
-	err = tx.Model(&models.BaseDrugLib{}).Where("id = ? and status = 1 and org_id = ?", drugid, orgid).Update(map[string]interface{}{"sum_in_count": sum_in_count}).Error
+	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 {
-		tx.Rollback()
+		ut.Rollback()
 		return err
 	}
-	tx.Commit()
+	ut.Commit()
 	return err
 }
 
 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
+}
+
+func AddGoodSumInCount(storehouse_id int64, good_id int64, user_org_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_in_count", gorm.Expr("stock_in_count + ?", count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
+	return err
+}
+
+func ReduceGoodSumInCount(storehouse_id int64, good_id int64, user_org_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_in_count", gorm.Expr("stock_in_count - ?", count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
+	return err
+}
+
+func UpdateGoodFlushCount(storehouse_id int64, good_id int64, user_org_id int64, flush_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).Update(map[string]interface{}{"flush_count": flush_count}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
+	return err
+}
+
+func UpdateDrugCount(storehouse_id int64, user_org_id int64, drug_id int64, sum_in_count int64, flush_count int64) error {
+
+	ut := XTWriteDB().Begin()
+	err := ut.Model(&models.XtDrugStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and drug_id =?", storehouse_id, user_org_id, drug_id).Update(map[string]interface{}{"sum_in_count": sum_in_count}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	err = ut.Model(&models.XtDrugStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and drug_id =?", storehouse_id, user_org_id, drug_id).Update(map[string]interface{}{"flush_count": flush_count}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+
+	ut.Commit()
+	return err
+}
+
+func UpdateDrugCountOne(storehouse_id int64, user_org_id int64, drug_id int64, flush_count int64) error {
+
+	ut := XTWriteDB().Begin()
+	err = ut.Model(&models.XtDrugStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and drug_id =?", storehouse_id, user_org_id, drug_id).Update(map[string]interface{}{"flush_count": flush_count}).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+
+	ut.Commit()
+	return err
+}
+
+func AddDrugSumOutCount(storehouse_id int64, sum_out_count int64, user_org_id int64, drug_id int64) error {
+
+	ut := XTWriteDB().Begin()
+	err := ut.Model(&models.XtDrugStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and drug_id =?", storehouse_id, user_org_id, drug_id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count + ?", sum_out_count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	err = ut.Model(&models.XtDrugStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and drug_id =?", storehouse_id, user_org_id, drug_id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count + ?", sum_out_count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
+	return err
+}
+
+func ReduceDrugSumOut(storehouse_id int64, user_org_id int64, drug_id int64, sum_out_count int64) error {
+	ut := XTWriteDB().Begin()
+	err := ut.Model(&models.XtDrugStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and drug_id =?", storehouse_id, user_org_id, drug_id).UpdateColumn("sum_act_out_count", gorm.Expr("sum_act_out_count + ?", sum_out_count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+	ut.Commit()
+	return err
+}
+
+func AddGoodSumOutCount(storehouse_id int64, good_id int64, user_org_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
+	}
+	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("sum_act_out_count", gorm.Expr("sum_act_out_count + ?", count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+
+	ut.Commit()
+	return err
+}
+
+func ReduceGoodSumOutCount(storehouse_id int64, good_id int64, user_org_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
+	}
+	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("sum_act_out_count", gorm.Expr("sum_act_out_count - ?", count)).Error
+	if err != nil {
+		ut.Rollback()
+		return err
+	}
+
+	ut.Commit()
+	return err
+}