耗材参数

conf/app.conf

 sessionon = true
 #sessiongcmaxlifetime = 64800
 
-tokencookiemaxlifetime = 7200
+tokencookiemaxlifetime = 64800
 enablexsrf = false
 xsrfkey = 61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o
 xsrfexpire = 3600
 writesgjpatientmysqlpass = 1Q2W3e4r!@#$
 writesgjpatientmysqlname = sgj_patient
 
-
+readmysqlhost2 = rm-wz9rg531npf61q03tro.mysql.rds.aliyuncs.com
+readmysqlport2 = 3306
+readmysqluser2 = root
+readmysqlpass2 = 1Q2W3e4r!@#$
+readmysqlname2 = sgj_xt
 
 
 

controllers/drug_stock_api_contorller.go

 	"encoding/json"
 	"fmt"
 	"github.com/astaxie/beego"
+	"github.com/jinzhu/gorm"
 	"reflect"
 	"strconv"
 	"strings"
 
 		errs = service.CreateDrugWarehousingInfo(warehousingInfo)
 		if errs == nil {
-			service.CreateDrugFlow(drugFlow)
 			//更改库存
 			service.UpdateDrugInfo(warehousingInfo)
-
+			for _, it := range warehousingInfo {
+				info, _ := service.GetLastDrugWarehouseInfSix(it.DrugId)
+				flows := models.DrugFlow{
+					WarehousingOrder: info.WarehousingOrder,
+					WarehousingId:    info.ID,
+					DrugId:           info.DrugId,
+					Number:           info.Number,
+					ProductDate:      info.ProductDate,
+					ExpireDate:       info.ExpiryDate,
+					Count:            info.WarehousingCount,
+					Price:            info.Price,
+					Status:           1,
+					Ctime:            ctime,
+					UserOrgId:        adminUserInfo.CurrentOrgId,
+					Manufacturer:     info.Manufacturer,
+					Dealer:           info.Dealer,
+					BatchNumber:      info.BatchNumber,
+					MaxUnit:          info.MaxUnit,
+					MinUnit:          "",
+					ConsumableType:   1,
+					IsEdit:           1,
+					Creator:          adminUserInfo.AdminUser.Id,
+					IsSys:            0,
+				}
+				_, existerrcodes := service.GetDrugFlowIsExist(info.ID, info.DrugId)
+				fmt.Println("23323232232323我的时间232332332232332322323232", existerrcodes)
+				if existerrcodes == gorm.ErrRecordNotFound {
+					service.CreateDrugFlowOne(flows)
+				}
+			}
 		}
 
 	}
 		var total int64
 		var minNumber float64
 		var allTotal int64
+		var chaTotal int64
 		for _, item := range upDateWarehousingInfo {
 			//查询修改的记录
 			orderInfo, _ := service.GetDrugWarehouseOrderOne(id, item.DrugId)
 
+			fmt.Println("hh23323232323232332233232", orderInfo)
+
 			info, _ := service.FindeDrugInfo(item.DrugId)
 
+			//历史入库总数
 			total = orderInfo.StockMaxNumber * info.MinNumber
 
-			allTotal = item.WarehousingCount*info.MinNumber - total
+			//当前入库总数
+			allTotal = item.WarehousingCount * info.MinNumber
 
-			str := strconv.FormatInt(allTotal, 10)
-			minFloat, _ := strconv.ParseFloat(str, 64)
+			//如果历史的入库总数 大于当前入库总数 则需要扣减
+			if total > allTotal {
+				chaTotal = total - allTotal
+				str := strconv.FormatInt(chaTotal, 10)
+				minFloat, _ := strconv.ParseFloat(str, 64)
 
-			minNumber = info.Total + minFloat
+				minNumber = info.Total - minFloat
 
-			lib := models.BaseDrugLib{
-				Total: minNumber,
+				lib := models.BaseDrugLib{
+					Total: minNumber,
+				}
+				service.UpdateBaseDrug(&lib, item.DrugId)
 			}
-			service.UpdateBaseDrug(&lib, item.DrugId)
+			//如果历史的入库总数 小于当前入库总数 则需增加库存
+			if total < allTotal {
+				chaTotal = allTotal - total
+				str := strconv.FormatInt(chaTotal, 10)
+				minFloat, _ := strconv.ParseFloat(str, 64)
+
+				minNumber = info.Total + minFloat
+
+				lib := models.BaseDrugLib{
+					Total: minNumber,
+				}
+				service.UpdateBaseDrug(&lib, item.DrugId)
+			}
+
 			warehouseInfo, _ := service.FindeLastWarehouseInfo(item.ID)
 			fmt.Println("hhhhh23hh32h232332323223", warehouseInfo)
 			var total int64
+
 			//比较大小(加)
+			// 如果当前的入库数量 大于 历史入库数量
 			if item.WarehousingCount > warehouseInfo.WarehousingCount {
 				total = item.WarehousingCount - warehouseInfo.WarehousingCount
+				item.StockMaxNumber = warehouseInfo.StockMaxNumber + total
+				fmt.Println("我的世界hhh23323232333232323", item.StockMaxNumber)
+				errs = service.UpDateDrugWarehousingInfo(item)
+				if len(drugFlow) > 0 {
+					for _, it := range drugFlow {
+						fmt.Println(it)
+						flow := models.DrugFlow{
+							Count: item.StockMaxNumber,
+						}
+						parseDateErr := service.UpdateDrugFlow(flow, item.DrugId, warehouseInfo.WarehousingId)
+						fmt.Println(parseDateErr)
+					}
+				}
 			}
-			item.StockMaxNumber = warehouseInfo.StockMaxNumber + total
+
+			// 如果当前的入库数量 小于 历史入库数量
 			if item.WarehousingCount < warehouseInfo.WarehousingCount {
 				total = warehouseInfo.WarehousingCount - item.WarehousingCount
+				item.StockMaxNumber = warehouseInfo.StockMaxNumber - total
+				errs = service.UpDateDrugWarehousingInfo(item)
+				if len(drugFlow) > 0 {
+					for _, it := range drugFlow {
+						fmt.Println(it)
+						flow := models.DrugFlow{
+							Count: item.StockMaxNumber,
+						}
+						parseDateErr := service.UpdateDrugFlow(flow, item.DrugId, warehouseInfo.WarehousingId)
+						fmt.Println(parseDateErr)
+					}
+				}
 			}
-			item.StockMaxNumber = warehouseInfo.StockMaxNumber - total
-			if item.WarehousingCount == warehouseInfo.StockMaxNumber {
-
-				item.StockMaxNumber = item.WarehousingCount
-			}
-			errs = service.UpDateDrugWarehousingInfo(item)
-
-		}
-	}
-
-	if len(drugFlow) > 0 {
-		for _, item := range drugFlow {
-			flow := models.DrugFlow{
-				Count: item.Count,
-			}
-			parseDateErr := service.UpdateDrugFlow(flow, item.DrugId, item.WarehousingId)
-			fmt.Println(parseDateErr)
 		}
 	}
 
 					}
 
 				}
-				fmt.Println("孟子", warehouseOut.ID)
+
 				warehouseOutInfo := &models.DrugWarehouseOutInfo{
 
 					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 					WarehouseInfoId:         warehouse_info_id,
 				}
 				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
-				fmt.Println("hhhhhhhhhhhhhhhh", warehouseOut.ID)
 
 				drugflow := &models.DrugFlow{
 					WarehouseOutId:          warehouseOut.ID,
 			}
 		}
 	}
-	var total_count int64
-	var prescribing_number_total int64
+
+	var total_count int64              //总库存
+	var prescribing_number_total int64 //出库数据
 	//调用出库逻辑
 	for _, item := range warehousingOutInfo {
 		//获取药品库存
-		info, _ := service.GetDrugTotalCountOne(item.DrugId, item.OrgId, item.WarehouseInfoId)
+		info, _ := service.GetDrugTotalCountTwo(item.DrugId)
+
+		for _, it := range info {
+			total_count += it.StockMaxNumber*it.MinNumber + it.StockMinNumber
+		}
 		//查询改药品信息
 		medical, _ := service.GetBaseDrugMedical(item.DrugId)
-		total_count = info.StockMaxNumber*medical.MinNumber + info.StockMinNumber
-		//for _, it := range info{
-		//  if medical.MaxUnit == it.MaxUnit{
-		//    it.Count = it.StockMaxNumber * medical.MinNumber
-		//  }
-		//  if medical.MinUnit == it.MinUnit{
-		//    it.Count = it.StockMinNumber
-		//  }
-		//  total_count += it.Count
-		//}
-		fmt.Println("总库存23232323232232332232332223", total_count)
+
 		//判断单位是否相等
 		if medical.MaxUnit == item.CountUnit {
 			//转化为最小单位
 			}
 
 			all_number = info.Count*medical.MinNumber + info.StockMinNumber
-			fmt.Println("总库存223232", all_number)
-			fmt.Println("当前库存00000000000000000000000000000000000000000", max_number)
+
 			////比较当前出库数量 和 最后一次出库数量,正常出库
 			if max_number <= min_number {
 				errs = service.UpDateDrugWarehouseOutInfo(item)
 				cha_number = min_number - max_number
-				fmt.Println("差库存", cha_number)
-				fmt.Println("最后一次库存0000000000000000000000000000000000000000", min_number)
+
 				if item.CountUnit == medical.MaxUnit {
 					maxNumber = cha_number / medical.MinNumber
 					parseDateErr := service.UpdateWarehouseInfo(maxNumber, item.DrugId, item.OrgId)
 				}
 
 			}
-
-			fmt.Println("当前出库", max_number)
-			fmt.Println("最后一次232233", min_number)
 			//退库操作
 			if max_number > min_number {
 
 				if all_number >= cha_number {
 
 					errs = service.UpDateDrugWarehouseOutInfo(item)
-					fmt.Println("232322332233232", item.CountUnit, medical.MaxUnit)
+
 					if item.CountUnit == medical.MaxUnit {
 						maxNumber = cha_number / medical.MinNumber
-						fmt.Println("maxNumber232323232323232232", maxNumber)
+
 						parseDateErr := service.UpdateWarehouseInfo(maxNumber, item.DrugId, item.OrgId)
-						fmt.Println("parseDateErr9999999999999999999999", parseDateErr)
+						fmt.Println("parseDateErr", parseDateErr)
 						if parseDateErr != nil {
 							utils.ErrorLog(errs.Error())
 							c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockOutFail)
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 	}
-	fmt.Println("cancelStockDate232323223233223", cancelStockDate.Unix())
-
 	adminUserInfo := c.GetAdminUserInfo()
 	operation_time := time.Now().Unix()
 	creater := adminUserInfo.AdminUser.Id
 		Type:         types,
 	}
 	service.AddSigleDrugCancelStock(&cancelStock)
-	fmt.Println("hh232323232323232323232323232322332", parseDateErr)
+
 	dataBody := make(map[string]interface{}, 0)
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
 	if err != nil {
 						dealer_id = item.ID
 					}
 				}
-				fmt.Println("99999999999999999999", batch_number_id)
+
 				cancelStockInfo := &models.DrugCancelStockInfo{
 					OrderNumber:      cancelStock.OrderNumber,
 					CancelStockId:    cancelStock.ID,
 		if item.MaxUnit == medical.MinUnit {
 			total_number = item.Count
 		}
-		fmt.Println("当前库存", total_number)
+		fmt.Println("当前退库数量", total_number)
 		//查询当前药品退库的批次号的总入库数
 		infoWareInfo, _ := service.GetDrugWarehouseInfo(item.BatchNumberId)
 		fmt.Println("hhh2h3h2hh3233", item.MaxUnit, medical.MaxUnit, infoWareInfo.StockMaxNumber, infoWareInfo.StockMinNumber)
 
 		//查询该批次的出库数量
 		outInfo, _ := service.GetDrugWarehouseOutInfo(item.BatchNumberId, item.DrugId)
-		//查询该批次总的退库数量
 
+		//查询该批次总的退库数量
 		canInfo, _ := service.GetCancelDrugStockOutInfo(item.BatchNumberId, item.DrugId)
+
 		for _, item := range canInfo {
 			if item.MaxUnit == medical.MaxUnit {
 				item.Count = item.Count * medical.MinNumber
 		for _, item := range outInfo {
 			out_number += item.Count
 		}
+		fmt.Println("当前退库数量", total_number)
 		fmt.Println("出库数量23232232323222332", out_number)
 		if out_number == 0 {
+			service.UpdateDrugCancel(item.CancelStockId)
 			c.ServeSuccessJSON(map[string]interface{}{
 				"msg": "2",
 			})
 		if total_number > out_number {
 			service.UpdateDrugCancel(item.CancelStockId)
 			c.ServeSuccessJSON(map[string]interface{}{
-				"msg": "4",
+				"msg": "2",
 			})
 			return
 		}
 
 		//判断总退库数量是否大于出库数量
-		fmt.Println("hhhhhhhhhhh", can_number+total_number)
+		fmt.Println("该批次总退库数量", can_number+total_number)
+		fmt.Println("总出口数量", out_number)
 		if can_number+total_number > out_number {
+			//清空退库单
 			service.UpdateDrugCancel(item.CancelStockId)
 			c.ServeSuccessJSON(map[string]interface{}{
 				"msg": "2",
 			errs = service.CreateDrugFlow(drugFlow)
 
 			var total int64
-			////退库到当前批次,获取当前退库批次的库存
-			//info, _ := service.GetDrugWarehouseInfoById(item.BatchNumberId)
 
 			if medical.MaxUnit == item.MaxUnit {
 				total = item.Count
 				})
 			}
 			if medical.MinUnit == item.MaxUnit {
-				fmt.Println("hhhhhh2323323232322332232332999999999进来", item.Count)
 				total = item.Count
 				warehouseInfo := models.XtDrugWarehouseInfo{
 					StockMinNumber: total,
 			}
 		}
 	}
-	fmt.Println("cancelStockInfos232323223323223322323223", cancelStockInfos)
-	fmt.Println("cancelStockInfos232323223323223322323223", upDateCancelStockInfos)
 
 	var errs error
 	if len(cancelStockInfos) > 0 {
 				//创建退库详情
 				errs := service.CreateDrugCancelStockInfo(cancelStockInfos)
 				//创建库存明细
-				errs = service.CreateDrugFlow(drugFlow)
+				//查询这个药品这个订单是否已存在流水
+				for _, items := range drugFlow {
+					_, errsId := service.GetCancelStockId(items.CancelStockId, items.DrugId)
+					if errsId == gorm.ErrRecordNotFound {
+						errs = service.CreateDrugFlowTwo(items)
+					}
+				}
 
 				//获取该批次最后一条退库详情
 				lastCancel, _ := service.GetLastCancelStockInfo(id)
 				if lastCancel.MaxUnit == medical.MinUnit {
 					cancel_number = lastCancel.Count
 				}
-				fmt.Println("999999232323232232232323232323", lastCancel)
+				fmt.Println("999999232323232232232323232323", item.Count, cancel_number)
 				var total int64
 
 				if medical.MaxUnit == item.MaxUnit {
 		}
 	}
 	if len(drugFlow) > 0 {
-		parseDateErr := service.CreateDrugFlow(drugFlow)
-		fmt.Println(parseDateErr)
+		for _, items := range drugFlow {
+			_, errsId := service.GetCancelStockId(items.CancelStockId, items.DrugId)
+			if errsId == gorm.ErrRecordNotFound {
+				errs = service.CreateDrugFlowTwo(items)
+			}
+		}
 	}
 
 	if len(upDateCancelStockInfos) > 0 {
 		var total int64
 		var out_count int64
+		var cancel_count int64
+		var now_count int64
+		var all_count int64
 		for _, item := range upDateCancelStockInfos {
+			//查询最后一条退库记录
+			info, _ := service.GetLastCancelStockInfoOne(id, item.DrugId)
 			errs = service.UpDateDrugCancelStockInfo(item)
-			//查询该批次最后一条退库记录
-			info, _ := service.GetLastCancelStockInfo(id)
+			fmt.Println("hh23232oooooooo2o3o2o32o23oo23o23o23", info)
 			//查询该药品的信息
 			medical, _ := service.GetBaseDrugMedical(item.DrugId)
 			//统计该批次的总出库数
 			outInfo, _ := service.GetDrugWarehouseOutInfo(item.BatchNumberId, item.DrugId)
+			//查询该批次的总退库数量
+			cancelInfo, _ := service.GetTotalDrugCancelInfo(item.BatchNumberId, item.DrugId, item.ID)
 			for _, item := range outInfo {
 				if item.CountUnit == medical.MaxUnit {
 					item.Count = item.Count * medical.MinNumber
 				out_count += item.Count
 			}
 
+			for _, item := range cancelInfo {
+				if item.MaxUnit == medical.MaxUnit {
+					item.Count = item.Count * medical.MinNumber
+				}
+				if item.MaxUnit == medical.MinUnit {
+					item.Count = item.Count
+				}
+			}
+
+			for _, item := range cancelInfo {
+				cancel_count += item.Count
+			}
+
 			fmt.Println("out_count232233332232323223", out_count)
 
 			if item.MaxUnit == medical.MaxUnit {
-				item.Count = item.Count * medical.MinNumber
+				now_count = item.Count * medical.MinNumber
+			}
+			if item.MaxUnit == medical.MinUnit {
+				now_count = item.Count
+			}
+			fmt.Println("hhhhhh2323322323", now_count+cancel_count)
+			//总退库批次
+			all_count = now_count + cancel_count
+
+			//该批次的总出库数小与退库数报错返回
+			if all_count > out_count {
+				c.ServeSuccessJSON(map[string]interface{}{
+					"msg": "4",
+				})
+				return
+			}
+
+			if item.MaxUnit == medical.MaxUnit {
 				//更新库存
 				total = item.Count - info.Count
-				fmt.Println("total232323232323232232323", total)
-				service.UpdatedDrugInfo(item.BatchNumberId, total)
+				parseDateErr := service.UpdatedDrugInfo(item.BatchNumberId, total)
+				fmt.Println("parseDateErr", parseDateErr)
+
+				flow := models.DrugFlow{
+					Count: item.Count,
+				}
+				service.UpdatedDrugFlow(info.CancelStockId, item.DrugId, flow)
 				break
+
 			}
 
 			if item.MaxUnit == medical.MinUnit {
 				item.Count = item.Count
 				total = item.Count - info.Count
 				service.UpdatedDrugInfoOne(item.BatchNumberId, total)
+				flow := models.DrugFlow{
+					Count: item.Count,
+				}
+				service.UpdatedDrugFlow(info.CancelStockId, item.DrugId, flow)
 				break
 			}
 		}

controllers/manage_api_controller.go

 	id, _ := this.GetInt64("id")
 	fmt.Println("id", id)
 	patientid, _ := this.GetInt64("patientid")
-	device, err := service.GetUserInformation(id)
+	device, _ := service.GetUserInformation(id)
 	//获取初次使用记录
-	macher, err := service.GetUserTotalByMacher(device.EquimentId)
-	count, err := service.GetUserTotalCount(orgId, device.BedNumber)
-	patients, err := service.GetPatientInfoMation(patientid)
-	if err != nil {
-		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询失败:（"+err.Error()+"）")
-		return
-	}
+	macher, _ := service.GetUserTotalByMacher(device.EquimentId)
+	count, _ := service.GetUserTotalCount(orgId, device.BedNumber)
+	patients, _ := service.GetPatientInfoMation(patientid)
+
 	this.ServeSuccessJSON(map[string]interface{}{
 		"device":   device,
 		"patients": patients,

controllers/mobile_api_controllers/dialysis_api_controller.go

 		tempassessmentAfterDislysis.ActualDisplacement = endmonitorRecords.DisplacementQuantity
 
 	}
-	if adminUserInfo.Org.Id == 10101 || adminUserInfo.Org.Id == 9671 || adminUserInfo.Org.Id == 3877 || adminUserInfo.Org.Id == 10215 || adminUserInfo.Org.Id == 10233 {
+	if adminUserInfo.Org.Id == 10101 || adminUserInfo.Org.Id == 9671 || adminUserInfo.Org.Id == 3877 || adminUserInfo.Org.Id == 10215 || adminUserInfo.Org.Id == 10233 || adminUserInfo.Org.Id == 10223 {
 		evaluation, _ := service.MobileGetPredialysisEvaluation(adminUserInfo.Org.Id, id, recordDate.Unix())
 		if evaluation.SystolicBloodPressure == 0 {
 			evaluation.SystolicBloodPressure = fmonitorRecords.SystolicBloodPressure
 				}
 			}
 
-			//出库
-			//err = service.ConsumablesDeliveryTotal(adminUser.Org.Id, patient_id, record_time, beforePrepares, newBeforePrepares, adminUser.AdminUser.Id)
-			//fmt.Println("err", err)
-			////查询今日出库数据
-			//list, _ := service.GetAutoReduceRecordInfoByPatientId(adminUser.Org.Id, patient_id, record_time)
-			//
-			//if len(list) == 0 {
-			//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
-			//	return
-			//}
-			//
-			//for _, item := range list {
-			//	prepare := models.DialysisBeforePrepare{
-			//		UserOrgId:  item.OrgId,
-			//		PatientId:  patient_id,
-			//		RecordDate: item.RecordTime,
-			//		GoodId:     item.GoodId,
-			//		GoodTypeId: item.GoodTypeId,
-			//		Count:      item.Count,
-			//		Ctime:      time.Now().Unix(),
-			//		Creater:    adminUser.AdminUser.Id,
-			//		Status:     1,
-			//	}
-			//	//删除准备表数据
-			//	service.DeleteDialysisBefor(adminUser.Org.Id, patient_id, record_time, item.GoodId, item.GoodTypeId)
-			//	service.CreateDialysisBeforePrepareOne(&prepare)
-			//}
-
 		}
 	}
 
 				}
 
 				for _, item := range beforePrepares {
-					fmt.Println("23232323232323为什么99999999999999999999999999999999", item.GoodId)
 
 					//1.查看该患者该耗材型号最后一次出库数量
 					goodInfo, _ := service.GetLastGoodListByPatientIdOne(record_time, patient_id, item.GoodId, item.GoodTypeId)
 
 						//查询该批次剩余库存
 						lastInfo, _ := service.GetLastStockOut(goodInfo.WarehouseInfotId)
+						fmt.Println("剩余库存333333333333333", lastInfo)
 						if lastInfo.StockCount == 0 {
 							//查询该耗材的总库存
 							wareinfo, _ := service.GetStockGoodCount(item.GoodId)
 							}
 
 						}
+
 						//比较剩余库存 和 当前相差的数量,库存剩余量大于则正常出库
 						fmt.Println("剩余库存", lastInfo.StockCount)
 						fmt.Println("差", last_total)
-						if lastInfo.StockCount >= last_total {
+						//查询该耗材的总库存
+						wareinfo, _ := service.GetStockGoodCount(item.GoodId)
+						// 如果库存差大于剩余库存则提示库存不足
+						if last_total > wareinfo.StockCount {
+							goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
+							c.ServeSuccessJSON(map[string]interface{}{
+								"message":            "1",
+								"good_name":          goodObj.GoodName,
+								"specification_name": goodObj.SpecificationName,
+							})
+							return
+						} else {
 							err = ConsumablesDeliveryTotalSix(adminInfo.Org.Id, patient_id, record_time, beforePrepares, newBeforePrepares, adminInfo.AdminUser.Id)
 							break
 						}
 
-						//如果库存不够，则出库到下一个批次
-						if lastInfo.StockCount < last_total {
-
-							err = ConsumablesDeliveryTotalSix(adminInfo.Org.Id, patient_id, record_time, beforePrepares, newBeforePrepares, adminInfo.AdminUser.Id)
-							break
-						}
+						//if lastInfo.StockCount >= last_total {
+						//	err = ConsumablesDeliveryTotalSix(adminInfo.Org.Id, patient_id, record_time, beforePrepares, newBeforePrepares, adminInfo.AdminUser.Id)
+						//	break
+						//}
+						//
+						////如果库存不够，则出库到下一个批次
+						//if lastInfo.StockCount < last_total {
+						//
+						//	err = ConsumablesDeliveryTotalSix(adminInfo.Org.Id, patient_id, record_time, beforePrepares, newBeforePrepares, adminInfo.AdminUser.Id)
+						//	break
+						//}
 					}
 				}
 
 	// goods 这个数据就是需要出库的耗材的数据(新增的数据)
 	fmt.Println("goods222222222222", goods)
 	fmt.Println("goodsy999999999999", goods_yc)
+
 	if len(goods) > 0 {
 		out, err := service.FindStockOutByIsSys(orgID, 1, record_time)
 		if err == gorm.ErrRecordNotFound {

controllers/mobile_api_controllers/patient_api_controller.go

 
 		//自备药信息
 		privateDrugConfig, _ := service.GetDrugSetByUserOrgId(adminUserInfo.Org.Id)
-		fmt.Println("2323232323232323232开关", drugStockConfig.IsOpen)
+
 		if drugStockConfig.IsOpen == 1 {
 			if groupno > 0 {
 				advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
 					var prescribing_number_total int64
 					for _, item := range advices {
 						if item.Way == 1 {
-							//查询该药品是否有库存
+							//查询该药品的剩余库存
 							list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId)
-							fmt.Println("list23232323232232323232323232", list)
+
 							//查询改药品信息
 							medical, _ := service.GetBaseDrugMedical(item.DrugId)
 							//判断单位是否相等
 								prescribing_number_total = count
 							}
 
-							fmt.Println("数量一", prescribing_number_total)
-							fmt.Println("数量二", total)
+							fmt.Println("开医嘱数量", prescribing_number_total)
+							fmt.Println("剩余库存", total)
 
 							if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
 								c.ServeSuccessJSON(map[string]interface{}{
 						isHasWay = true
 					}
 				}
-				fmt.Println("hh2h32323232323232323", isHasWay)
+
 				if isHasWay {
 					var total int64
 					var prescribing_number_total int64
 					for _, item := range advices {
-						fmt.Println("hhh23h2h3h232323", item.Way)
+
 						if item.Way == 1 {
-							//查询该药品是否有库存
+							//查询该药品的剩余库存
 							list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId)
 
 							//查询改药品信息
 							medical, _ := service.GetBaseDrugMedical(item.DrugId)
+
 							//判断单位是否相等
 							if medical.MaxUnit == item.PrescribingNumberUnit {
 								prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
 								count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
 								//转化为最小单位
-								total = list.Count * medical.MinNumber
+								total = list.Count*medical.MinNumber + list.StockMinNumber
+								fmt.Println("美国疫情2332323233232323232332323232233232323232", total)
 								prescribing_number_total = count * medical.MinNumber
 							}
+
 							if medical.MinUnit == item.PrescribingNumberUnit {
 								prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
 								count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
 								prescribing_number_total = count
 							}
 
-							fmt.Println("数量一", prescribing_number_total)
-							fmt.Println("数量二", total)
+							fmt.Println("开医嘱数量", prescribing_number_total)
+							fmt.Println("剩余库存", total)
 
 							if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
 								c.ServeSuccessJSON(map[string]interface{}{
 								})
 								return
 							}
+
 							if prescribing_number_total <= total {
 								service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, &item)
 								c.ServeSuccessJSON(map[string]interface{}{
 				for _, item := range advices {
 
 					advice, _ := service.FindHisDoctorAdviceById(adminInfo.Org.Id, item.ID)
-					//查询该药品是否有库存
-					//  list, _ := service.GetDrugTotalCount(advice.DrugId, advice.UserOrgId)
-					//  prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
-					//  count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
-					//  if list.Count == 0 {
-					//    c.ServeSuccessJSON(map[string]interface{}{
-					//      "msg":    "1",
-					//      "advice": advice,
-					//      "ids":    ids,
-					//    })
-					//    return
-					//  }
-					//  if count > list.Count {
-					//    c.ServeSuccessJSON(map[string]interface{}{
-					//      "msg":    "2",
-					//      "advice": advice,
-					//      "ids":    ids,
-					//    })
-					//    return
-					//}
+
 					var total int64
 					var prescribing_number_total int64
 					//查询该药品是否有库存
 						prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
 						count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
 						//转化为最小单位
-						total = list.Count * medical.MinNumber
+						total = list.Count*medical.MinNumber + list.StockMinNumber
 						prescribing_number_total = count * medical.MinNumber
 					}
+					fmt.Println("医嘱开的数量", total)
 					if medical.MinUnit == advice.PrescribingNumberUnit {
 						prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
 						count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)

controllers/patient_api_controller.go

 					prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
 					count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
 					//转化为最小单位
-					total = list.Count * medical.MinNumber
+					total = list.Count*medical.MinNumber + list.StockMinNumber
 					prescribing_number_total = count * medical.MinNumber
 				}
 				if medical.MinUnit == item.PrescribingNumberUnit {
 					return
 				}
 
-				////查询该药品是否有库存
-				//list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId)
-				//prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
-				//count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
-				//if list.Count == 0 {
-				//	c.ServeSuccessJSON(map[string]interface{}{
-				//		"msg":    "1",
-				//		"advice": advice,
-				//	})
-				//	return
-				//}
-				//if count > list.Count {
-				//	c.ServeSuccessJSON(map[string]interface{}{
-				//		"msg":    "2",
-				//		"advice": advice,
-				//	})
-				//	return
-				//}
-				////调用药品出库接口
-				//service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
-
 			}
 		}
 
 		}
 
 		executionStaff := adminUserInfo.AdminUser.Id
-		// checker := adminUserInfo.AdminUser.Id
 
 		timeLayout := "2006-01-02 15:04:05"
 		loc, _ := time.LoadLocation("Local")
 					prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
 					count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
 					//转化为最小单位
-					total = list.Count * medical.MinNumber
+					total = list.Count*medical.MinNumber + list.StockMinNumber
 					prescribing_number_total = count * medical.MinNumber
 				}
 				fmt.Println("单位1", medical.MinUnit)
 					prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
 					count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
 					total = list.Count*medical.MinNumber + list.StockMinNumber
-					fmt.Println("23232322323322323233223", total)
+
 					prescribing_number_total = count
-					fmt.Println("7777777777777777", prescribing_number_total)
+
 				}
 
 				fmt.Println("数量一", prescribing_number_total)
 					return
 				}
 			}
-			//	//查询该药品是否有库存
-			//	list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId)
-			//	prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
-			//	count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
-			//	if list.Count == 0 {
-			//		c.ServeSuccessJSON(map[string]interface{}{
-			//			"msg":    "1",
-			//			"advice": advice,
-			//		})
-			//		return
-			//	}
-			//	if count > list.Count {
-			//		c.ServeSuccessJSON(map[string]interface{}{
-			//			"msg":    "2",
-			//			"advice": advice,
-			//		})
-			//		return
-			//	}
-			//	service.HisDrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
-			//}
+
 		}
 		c.ServeSuccessJSON(map[string]interface{}{
 			"msg":    "1",

controllers/self_drug_api_congtroller.go

 	fmt.Println(err)
 
 	tableData, _ := dataBody["tableData"].([]interface{})
-	fmt.Println("999939433443", tableData)
+
 	if len(tableData) > 0 {
 		for _, item := range tableData {
 			items := item.(map[string]interface{})
 				consumable_type = 10
 				consumable_count = new_total - ord_total
 			}
+			fmt.Println("ord_total", ord_total)
+			fmt.Println("new_total23323232323223", new_total)
+			fmt.Println("consumable_count", consumable_count)
 
 			//改变库存
 			info := models.DrugWarehouseInfo{
 				MaxUnit:                 max_unit,
 				MinUnit:                 min_unit,
 			}
-
-			service.CreateDrugFlowOne(flow)
-
+			if ord_total != new_total {
+				service.CreateDrugFlowOne(flow)
+			}
 			if err != nil {
 				this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新设备失败")
 				return

controllers/stock_in_api_controller.go

 	beego.Router("/api/stock/proofinventory", &StockManagerApiController{}, "Get:ProofInventory")
 	beego.Router("/api/stock/getwarehousetotal", &StockManagerApiController{}, "Get:GetWarehouseTotal")
 	beego.Router("/api/stock/getgoodinventorywarehouselist", &StockManagerApiController{}, "Get:GetGoodInventoryWarehouseList")
-
+	beego.Router("/api/stock/savestockinentorylist", &StockManagerApiController{}, "Post:SaveStockInventoryList")
+	beego.Router("/api/sotck/getdamagedetailbygoodid", &StockManagerApiController{}, "Get:GetDamageDetailByGoodId")
 }
 
 func (c *StockManagerApiController) CreateWarehouse() {
 					}
 					warehousingInfo = append(warehousingInfo, warehouseInfo)
 
-					flow := &models.VmStockFlow{
-						WarehousingOrder:    warehousing.WarehousingOrder,
-						WarehousingId:       warehousing.ID,
-						GoodId:              good_id,
-						Number:              number,
-						ProductDate:         productDates,
-						ExpireDate:          expiryDates,
-						Count:               warehousing_count,
-						Price:               price,
-						Status:              1,
-						Ctime:               ctime,
-						UserOrgId:           adminUserInfo.CurrentOrgId,
-						Manufacturer:        manufacturer,
-						Dealer:              dealer,
-						LicenseNumber:       license_number,
-						IsEdit:              1,
-						Creator:             adminUserInfo.AdminUser.Id,
-						SystemTime:          ctime,
-						ConsumableType:      1,
-						WarehousingDetailId: warehouseInfo.ID,
-					}
-
-					stockFlow = append(stockFlow, flow)
-
 				} else {
-					fmt.Println("id23233232323232323232323223", id)
+
 					warehouseInfo := &models.WarehousingInfo{
 						ID:               id,
 						WarehousingOrder: warehouse.WarehousingOrder,
 	var errs error
 	if len(warehousingInfo) > 0 {
 		errs = service.CreateWarehousingInfo(warehousingInfo)
-		service.CreateStockFlow(stockFlow)
+
+		for _, its := range warehousingInfo {
+			//查询
+			info, _ := service.GetLastGoodWarehouseInfo(its.GoodId)
+			fmt.Println("hh23323232323233232323322323", info)
+			flows := models.VmStockFlow{
+				WarehousingOrder:    info.WarehousingOrder,
+				WarehousingId:       info.ID,
+				GoodId:              info.GoodId,
+				Number:              info.Number,
+				ProductDate:         info.ProductDate,
+				ExpireDate:          info.ExpiryDate,
+				Count:               info.WarehousingCount,
+				Price:               info.Price,
+				Status:              1,
+				Ctime:               ctime,
+				UserOrgId:           adminUserInfo.CurrentOrgId,
+				Manufacturer:        info.Manufacturer,
+				Dealer:              info.Dealer,
+				LicenseNumber:       info.LicenseNumber,
+				IsEdit:              1,
+				Creator:             adminUserInfo.AdminUser.Id,
+				SystemTime:          ctime,
+				ConsumableType:      1,
+				WarehousingDetailId: info.ID,
+			}
+			_, errcodescode := service.GetGoodStockFlowInfo(info.ID, info.GoodId)
+			fmt.Println("wodeshijehh23322333223233223323232", errcodescode)
+			if errcodescode == gorm.ErrRecordNotFound {
+				service.CreateStockFlowOne(flows)
+			}
+
+			//改变库存
+			good, _ := service.GetLastInfoMationById(info.GoodId)
+			warhouseCount := strconv.FormatInt(info.WarehousingCount, 10)
+			total, _ := strconv.ParseFloat(warhouseCount, 64)
+			goodInfo := models.GoodInfo{
+				Total: good.Total + total,
+			}
+			errcodescode = service.UpdateGoodInfoMation(info.GoodId, goodInfo)
+			fmt.Println(errcodescode)
+		}
 	}
 
 	if len(upDateWarehousingInfo) > 0 {
 
 		for _, item := range upDateWarehousingInfo {
-
 			var total int64
-			var all_total int64
 			//获取该批次该型号的库存
 			info, _ := service.GetLastWarehousingByIdOne(item.ID, item.GoodId)
-			fmt.Println("oooooooooo", info.WarehousingCount)
-			//判断 该批次的入库数量
-			total = item.WarehousingCount - info.WarehousingCount
-			fmt.Println("total232323322332232332", total)
-			all_total = info.StockCount + total
 
-			item.StockCount = all_total
-			fmt.Println("hhhhhhhhhhhhh", item.StockCount)
+			//判断 该批次的库存数量 和 编辑库存数量
+			fmt.Println("库存11111111111111", item.WarehousingCount)
+			fmt.Println("库存22222222222222", info.WarehousingCount)
+			//增加库存
+			if item.WarehousingCount > info.WarehousingCount {
+
+				total = item.WarehousingCount - info.WarehousingCount
+				goodinfo := models.WarehousingInfo{
+					WarehousingCount: item.WarehousingCount,
+					StockCount:       info.StockCount + total,
+				}
 
-			errs = service.UpDateWarehousingInfo(item)
+				service.UpdateWarehouseInfoByGoodId(goodinfo, item.ID)
+				//改变库存
+				good, _ := service.GetLastInfoMationById(info.GoodId)
+				warhouseCount := strconv.FormatInt(total, 10)
+				all_total, _ := strconv.ParseFloat(warhouseCount, 64)
+				goodInfo := models.GoodInfo{
+					Total: good.Total + all_total,
+				}
+				service.UpdateGoodInfoMation(info.GoodId, goodInfo)
+
+			}
+
+			if item.WarehousingCount < info.WarehousingCount {
+
+				total = info.WarehousingCount - item.WarehousingCount
+				goodinfo := models.WarehousingInfo{
+					WarehousingCount: item.WarehousingCount,
+					StockCount:       info.StockCount - total,
+				}
+				service.UpdateWarehouseInfoByGoodId(goodinfo, item.ID)
+				//改变库存
+				good, _ := service.GetLastInfoMationById(info.GoodId)
+				warhouseCount := strconv.FormatInt(total, 10)
+				all_total, _ := strconv.ParseFloat(warhouseCount, 64)
+				goodInfo := models.GoodInfo{
+					Total: good.Total - all_total,
+				}
+				service.UpdateGoodInfoMation(info.GoodId, goodInfo)
+			}
 		}
 	}
 
 
 	//出库逻辑
 	for _, item := range warehousingOutInfo {
-		//查询库存
-		//warehouse, _ := service.FindFirstWarehousingInfoByStockTwo(item.GoodId, item.GoodTypeId)
-		//查询该批次的库存
 
-		warehouseOne, _ := service.FindWarehousingInfoByIdSeven(item.WarehouseInfotId)
-		fmt.Println("数据232323232323232323323232", warehouseOne)
-		fmt.Println("库存查询23322332233232233232322323232323", warehouseOne.StockCount)
+		// 查询该耗材是否有库存
+		warehouseOne, _ := service.FindWarehousingInfoTen(item.GoodId)
+		// 如果出库数量大于该批次剩余库存数量
 		if item.Count > warehouseOne.StockCount {
 			goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
 			c.ServeSuccessJSON(map[string]interface{}{
 			return
 
 		} else {
-
+			//查询是否生成出库单
 			_, errcodes := service.FindStockOutByIsSys(adminUserInfo.CurrentOrgId, 0, operation_time)
 			if errcodes == gorm.ErrRecordNotFound {
 				service.AddSigleWarehouseOut(&warehouseOut)
 			}
+			//出库逻辑
 			parseDateErr := service.ConsumablesDeliveryOne(adminUserInfo.CurrentOrgId, warehousingOutDate.Unix(), item, &warehouseOut, item.Count, creater)
 			if parseDateErr != nil {
 				utils.ErrorLog(parseDateErr.Error())
 		}
 
 	}
-
-	//errs := service.CreateWarehousingOutInfo(warehousingOutInfo)
-	//info, _ := service.FindLastWarehousingOutInfo(warehouseOut.WarehouseOutOrderNumber)
-
 }
 func (c *StockManagerApiController) GetWarehouseOutList() {
 	page, _ := c.GetInt64("page", -1)
 }
 func (c *StockManagerApiController) EditWarehouseOut() {
 	warehouse_out_time := c.GetString("warehouse_out_time")
-
 	id, _ := c.GetInt64("id", 0)
 	types, _ := c.GetInt64("type", 0)
 
 		}
 	}
 	var errs error
+	//新增出库
 	if len(warehousingOutInfo) > 0 {
 
-		errs = service.CreateWarehousingOutInfo(warehousingOutInfo)
+		warehousingOutDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", warehouse_out_time)
+		if parseDateErr != nil {
+			c.ErrorLog("日期(%v)解析错误：%v", warehousingOutDate, parseDateErr)
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		creater := adminUserInfo.AdminUser.Id
+
+		for _, item := range warehousingOutInfo {
+			// 查询该耗材是否有库存
+			warehouseOne, _ := service.FindWarehousingInfoTen(item.GoodId)
+			// 如果出库数量大于该批次剩余库存数量
+			if item.Count > warehouseOne.StockCount {
+				goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
+				c.ServeSuccessJSON(map[string]interface{}{
+					"msg":                "7",
+					"good_name":          goodObj.GoodName,
+					"specification_name": goodObj.SpecificationName,
+				})
+				return
+
+			} else {
+
+				warehouseOut, _ := service.GetWarehouseById(id)
+
+				//出库逻辑
+				parseDateErr := service.ConsumablesDeliveryOne(adminUserInfo.CurrentOrgId, warehousingOutDate.Unix(), item, &warehouseOut, item.Count, creater)
+				if parseDateErr != nil {
+					utils.ErrorLog(parseDateErr.Error())
+					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
+					return
+				}
+			}
+		}
 	}
 
 	if len(upDateWarehouseOutInfos) > 0 {
 		for _, item := range upDateWarehouseOutInfos {
 
 			//1.查询该耗材该批次的最后一次出库记录
-			lastGood, _ := service.GetLastGoodInformationByGoodId(item.GoodId, item.WarehouseInfotId, adminUserInfo.CurrentOrgId)
-			fmt.Println("lastGood", lastGood.Count)
-			fmt.Println("item2323232", item.Count)
+			lastGood, _ := service.GetLastGoodInformationByGoodId(item.GoodId, item.WarehouseInfotId)
 
 			// 退库的库存和该耗材该批次最后一次出库数量进行比较
 			//如果退库数量大于 最后一次批次的数量(要么要进行出库)
 
 				//查询该耗材是否还有库存
 				warehouseinfo, _ := service.GetTotalCountByGoodId(item.GoodId)
-				fmt.Println("hhhhhh23h2323232", warehouseinfo.StockCount)
+
 				//无库存
 				if warehouseinfo.StockCount <= 0 {
 					c.ServeSuccessJSON(map[string]interface{}{
 					var total_count int64
 					//计算和最后一次出库数据的差
 					total = item.Count - lastGood.Count
-					fmt.Println("total22323232", total)
+
 					//获取该耗材该批次的剩余库存量
 					info, _ := service.GetLastGoodCountById(item.GoodId, item.WarehouseInfotId)
-					fmt.Println("info2232323232323", info)
+
 					//判断该批次的剩余库存 和出库的库存进行比较
 					//如果出库的库存大于该批次的剩余库存,那么需要出库下一批次的库存
 
 						//清空本批次次库存
 						service.DeleteWarehouseInfo(item.WarehouseInfotId)
 						//调用出库逻辑
-						service.ConsumablesDeliveryTwo(item.OrgId, item, total_count)
+						parseDateErr := service.ConsumablesDeliveryTwo(item.OrgId, item, total_count)
+						if parseDateErr != nil {
+							utils.ErrorLog(errs.Error())
+							c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
+							return
+						}
+						c.ServeSuccessJSON(map[string]interface{}{
+							"msg": "1",
+						})
 					}
 					//如果出库的库存小于或等于于该批次的剩余库存,那么需要该批次出库
 					if item.Count <= info.StockCount {
 						stock_cout = lastGood.Count + total
-						fmt.Println("232323223232323232323232", stock_cout)
+						fmt.Println(stock_cout)
 						//扣减库存
 						warehouse := models.WarehousingInfo{
 							StockCount: info.StockCount - total,
 							c.ServeSuccessJSON(map[string]interface{}{
 								"msg": "1",
 							})
+							return
 						} else if errcode == nil {
 							service.UpDateWarehouseOutInfo(item)
+							c.ServeSuccessJSON(map[string]interface{}{
+								"msg": "1",
+							})
+							return
 						}
 
 					}
 			var stock_total int64
 			//如果退库数量小于最后一次批次的数量(要么要进行退库)
 			if item.Count < lastGood.Count {
-				fmt.Println("hh232323h2h3hh23hh23hh2h3h23")
+
 				//退库数量和最后一次出库数据进行计算
 				last_count = lastGood.Count - item.Count
-				fmt.Println("last_count", last_count)
+
 				//获取该耗材该批次的剩余库存量
 				infoInfo, _ := service.GetLastGoodCountById(item.GoodId, item.WarehouseInfotId)
 
 				//退库数量和最后一次出库数据进行计算的差 加上 剩余库存的数量与 该批次的入库数量进行比较
 				all_total = last_count + infoInfo.StockCount
-				fmt.Println("all_total", all_total)
+
 				//如果库存大于总数量，则退回到这个批次
-				fmt.Println("inf232323", infoInfo.WarehousingCount)
 
 				if infoInfo.WarehousingCount > all_total {
 					stock_total = last_count + infoInfo.StockCount
-					fmt.Println("经历323232323232232", last_count, stock_total)
+
 					//退回该批次,计算数量
 					warehousingInfoOne := models.WarehousingInfo{
 						StockCount: stock_total,
 						ID:         item.WarehouseInfotId,
 						OrgId:      item.OrgId,
 					}
-					fmt.Println("********************", warehousingInfoOne, item.WarehouseInfotId)
+
 					parseDateErr := service.UpdateWarehousingInfo(warehousingInfoOne, item.WarehouseInfotId)
-					fmt.Println("parseDateErr2323232322323", parseDateErr)
+					fmt.Println("parseDateErr", parseDateErr)
 					//插入一条新纪录
 					warehouseOutInfoThree := &models.WarehouseOutInfo{
 						WarehouseOutOrderNumber: item.WarehouseOutOrderNumber,
 						c.ServeSuccessJSON(map[string]interface{}{
 							"msg": "1",
 						})
+						return
 					} else if errcode == nil {
 						service.UpDateWarehouseOutInfo(item)
+						return
 					}
 				}
 
 			}
 
 			if item.Count == lastGood.Count {
+
 				errs = service.UpDateWarehouseOutInfo(item)
 				if errs != nil {
 					utils.ErrorLog(errs.Error())
 				c.ServeSuccessJSON(map[string]interface{}{
 					"msg": "1",
 				})
+				return
 			}
 
 		}
 	orgId := adminUserInfo.CurrentOrgId
 
 	list, total, _ := service.GetAllGoodInfoStockList(page, limit, startTime, endTime, types, keywords, orgId)
-	fmt.Println("耗材总计23323232232323232323", total)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
 	this.ServeSuccessJSON(map[string]interface{}{
 		"list":             list,
 	ids := this.GetString("id")
 	idsArray := strings.Split(ids, ",")
 	orgId := this.GetAdminUserInfo().CurrentOrgId
-	order, _ := service.GetWarehouseOutOrder(idsArray, orgId)
 	list, _ := service.GetOrderDetialByOrderIdOne(idsArray, orgId)
-	//获取该耗材的最后一条数据
-	info, _ := service.GetLastWarehouseOutInfo(idsArray, orgId)
-	fmt.Println("info323e2342342342432342342432", info)
 	this.ServeSuccessJSON(map[string]interface{}{
-		"order": order,
-		"list":  list,
-		"info":  info,
+		"list": list,
 	})
 }
 
 	orgId := this.GetAdminUserInfo().CurrentOrgId
 	keyword := this.GetString("keyword")
 	fmt.Println("startTime", startTime, "endTime", endTime)
-	list, total, _ := service.GetReportStockList(startTime, endTime, orgId, keyword, page, limit)
+	//list, total, _ := service.GetReportStockList(startTime, endTime, orgId, keyword, page, limit)
+
+	list, total, _ := service.GetStockDamagedList(orgId, keyword, page, limit)
+	damageList, _ := service.GetStockDamagedCount(orgId)
 	doctorlist, _ := service.GetAllDoctorThree(orgId)
 
 	this.ServeSuccessJSON(map[string]interface{}{
 		"list":       list,
 		"total":      total,
 		"doctorlist": doctorlist,
+		"damageList": damageList,
 	})
 }
 
 		"list": list,
 	})
 }
+
+func (this *StockManagerApiController) SaveStockInventoryList() {
+
+	dataBody := make(map[string]interface{}, 0)
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
+	fmt.Println(err)
+
+	tableData, _ := dataBody["tableData"].([]interface{})
+
+	if len(tableData) > 0 {
+		for _, item := range tableData {
+			items := item.(map[string]interface{})
+			good_name := items["good_name"].(string)
+			if items["good_name"] == nil || reflect.TypeOf(items["good_name"]).String() != "string" {
+				utils.ErrorLog("good_name")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			specification_name := items["specification_name"].(string)
+			if items["specification_name"] == nil || reflect.TypeOf(items["specification_name"]).String() != "string" {
+				utils.ErrorLog("specification_name")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			warehousing_unit := items["warehousing_unit"].(string)
+			if items["warehousing_unit"] == nil || reflect.TypeOf(items["warehousing_unit"]).String() != "string" {
+				utils.ErrorLog("warehousing_unit")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			stock_count := int64(items["stock_count"].(float64))
+			if items["stock_count"] == nil || reflect.TypeOf(items["stock_count"]).String() != "float64" {
+				utils.ErrorLog("stock_count")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			price := items["price"].(float64)
+			if items["price"] == nil || reflect.TypeOf(items["price"]).String() != "float64" {
+				utils.ErrorLog("price")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			manufacturer_name := items["manufacturer_name"].(string)
+			if items["manufacturer_name"] == nil || reflect.TypeOf(items["manufacturer_name"]).String() != "string" {
+				utils.ErrorLog("manufacturer_name")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			good_id := int64(items["good_id"].(float64))
+			if items["good_id"] == nil || reflect.TypeOf(items["good_id"]).String() != "float64" {
+				utils.ErrorLog("good_id")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			manufacturer := int64(items["manufacturer"].(float64))
+			if items["manufacturer"] == nil || reflect.TypeOf(items["manufacturer"]).String() != "float64" {
+				utils.ErrorLog("manufacturer")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			warehousing_order := items["warehousing_order"].(string)
+			if items["warehousing_order"] == nil || reflect.TypeOf(items["warehousing_order"]).String() != "string" {
+				utils.ErrorLog("warehousing_order")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			number := items["number"].(string)
+			if items["number"] == nil || reflect.TypeOf(items["number"]).String() != "string" {
+				utils.ErrorLog("number")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			id := int64(items["id"].(float64))
+			if items["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
+				utils.ErrorLog("id")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "float64" {
+				utils.ErrorLog("expiry_date")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+			expiry_date := int64(items["expiry_date"].(float64))
+
+			if items["product_date"] == nil || reflect.TypeOf(items["product_date"]).String() != "float64" {
+				utils.ErrorLog("product_date")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+			product_date := int64(items["product_date"].(float64))
+
+			orgId := this.GetAdminUserInfo().CurrentOrgId
+			adminId := this.GetAdminUserInfo().AdminUser.Id
+
+			stock_type := int64(items["type"].(float64))
+			if items["type"] == nil || reflect.TypeOf(items["type"]).String() != "float64" {
+				utils.ErrorLog("type")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+
+			last_stock_count := int64(items["last_stock_count"].(float64))
+			if items["last_stock_count"] == nil || reflect.TypeOf(items["last_stock_count"]).String() != "float64" {
+				utils.ErrorLog("last_stock_count")
+				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+				return
+			}
+			var total_count int64
+			var inventory_type int64
+			fmt.Println("盘点前", stock_count)
+			fmt.Println("盘点后", last_stock_count)
+			if stock_count > last_stock_count {
+				total_count = stock_count - last_stock_count
+				inventory_type = 11
+			}
+			if stock_count < last_stock_count {
+				total_count = last_stock_count - stock_count
+				inventory_type = 10
+			}
+
+			creater := this.GetAdminUserInfo().AdminUser.Id
+			inventory := models.XtStockInventory{
+				GoodName:          good_name,
+				SpecificationName: specification_name,
+				WarehousingUnit:   warehousing_unit,
+				Count:             total_count,
+				BuyPrice:          price,
+				PackingPrice:      price,
+				NewPrice:          0,
+				Manufacturer:      manufacturer_name,
+				Dealer:            "",
+				Remark:            "",
+				GoodId:            good_id,
+				UserOrgId:         orgId,
+				Ctime:             time.Now().Unix(),
+				Mtime:             0,
+				Status:            1,
+				WarehousingOrder:  warehousing_order,
+				LicenseNumber:     number,
+				StartTime:         time.Now().Unix(),
+				Creater:           adminId,
+				Checker:           0,
+				CheckerStatus:     0,
+				CheckerTime:       0,
+				Total:             0,
+				Number:            number,
+				WarehousingInfoId: id,
+				ExpireDate:        expiry_date,
+				ProductDate:       product_date,
+				GoodOriginPlace:   "",
+				Type:              10,
+				InventoryType:     stock_type,
+				LastStockCount:    last_stock_count,
+				StockCount:        stock_count,
+			}
+			service.CreateInentory(inventory)
+
+			stockFlow := models.VmStockFlow{
+				WarehousingId:           0,
+				GoodId:                  good_id,
+				Number:                  number,
+				LicenseNumber:           "",
+				Count:                   total_count,
+				UserOrgId:               orgId,
+				PatientId:               0,
+				SystemTime:              0,
+				ConsumableType:          inventory_type,
+				IsSys:                   0,
+				WarehousingOrder:        "",
+				WarehouseOutId:          0,
+				WarehouseOutOrderNumber: warehousing_order,
+				IsEdit:                  0,
+				CancelStockId:           0,
+				CancelOrderNumber:       "",
+				Manufacturer:            manufacturer,
+				Dealer:                  0,
+				Creator:                 creater,
+				UpdateCreator:           0,
+				Status:                  1,
+				Ctime:                   time.Now().Unix(),
+				Mtime:                   0,
+				Price:                   price,
+				WarehousingDetailId:     0,
+				WarehouseOutDetailId:    0,
+				CancelOutDetailId:       0,
+				ProductDate:             product_date,
+				ExpireDate:              expiry_date,
+				ReturnCount:             0,
+			}
+
+			info := models.WarehousingInfo{
+				StockCount: last_stock_count,
+			}
+			//更改库存
+			service.UpdatedWarehousingInfo(info, id)
+			if stock_count != last_stock_count {
+				service.CreateStockFlowOne(stockFlow)
+			}
+			this.ServeSuccessJSON(map[string]interface{}{
+				"inventory": inventory,
+			})
+		}
+	}
+}
+
+func (this *StockManagerApiController) GetDamageDetailByGoodId() {
+
+	good_id, _ := this.GetInt64("good_id")
+	list, _ := service.GetDamageDetailByGoodId(good_id)
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	damageList, _ := service.GetStockDamagedCount(orgId)
+	this.ServeSuccessJSON(map[string]interface{}{
+		"list":       list,
+		"damageList": damageList,
+	})
+}

models/drug_stock.go

 	CountUnit      string `gorm:"column:count_unit" json:"count_unit" form:"count_unit"`
 	StockMinNumber int64  `gorm:"column:stock_min_number" json:"stock_min_number" form:"stock_min_number"`
 	StockMaxNumber int64  `gorm:"column:stock_max_number" json:"stock_max_number" form:"stock_max_number"`
+	MinNumber      int64  `gorm:"column:min_number" json:"min_number" form:"min_number"`
 }
 
 type StDrugWarehouseOutInfo struct {

models/good_models.go

 	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"`
+	GoodSotckInfo               []*GoodSotckInfo     `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"good_stock_in"`
 }
 
 func (GoodInfo) TableName() string {

models/schedule_models.go

 func (VmSchedulesRemind) TableName() string {
 	return "xt_schedule"
 }
+
+type WeekScheduleSix 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"`
+
+	Patient                    string                     `gorm:"-" json:"patient" form:"patient"`
+	DeviceZone                 DeviceZone                 `json:"zone" gorm:"foreignkey:ID;AssociationForeignKey:PartitionId;"`
+	DeviceNumber               DeviceNumber               `json:"number" gorm:"foreignkey:ID;AssociationForeignKey:BedId;"`
+	DialysisPrescription       DialysisSolution           `json:"prescription" gorm:"foreignkey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId"`
+	DoctorAdvice               []*DoctorAdvice            `json:"doctoradvice" gorm:"foreignkey:AdviceDate,PatientId;AssociationForeignKey:ScheduleDate,PatientId;"`
+	HisDoctorAdviceInfo        []*HisDoctorAdviceInfo     `json:"hisdoctoradviceinfo" gorm:"foreignkey:AdviceDate,PatientId;AssociationForeignKey:ScheduleDate,PatientId;"`
+	Solution                   []*DialysisSolution        `json:"solution" gorm:"foreignkey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId"`
+	DialysisSolution           DialysisSolution           `json:"dialysissolution" gorm:"foreignkey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId"`
+	XtAssessmentBeforeDislysis XtAssessmentBeforeDislysis `json:"assessmentbefor" gorm:"foreignkey:PatientId,AssessmentDate;AssociationForeignKey:PatientId,ScheduleDate"`
+}
+
+func (WeekScheduleSix) TableName() string {
+	return "xt_schedule"
+}

models/self_drug_models.go

 	MinPrice                float64 `json:"min_price"`
 	DrugName                string  `json:"drug_name"`
 	Number                  string  `gorm:"column:number" json:"number" form:"number"`
+	WarehouseInfoId         int64   `gorm:"column:warehouse_info_id" json:"warehouse_info_id" form:"warehouse_info_id"`
 }
 
 type XtDrugAdjustPrice struct {

models/stock_models.go

 	ExpireDate        int64   `gorm:"column:expire_date" json:"expire_date" form:"expire_date"`
 	ProductDate       int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
 	GoodOriginPlace   string  `gorm:"column:good_origin_place" json:"good_origin_place" form:"good_origin_place"`
+	Type              int64   `gorm:"column:type" json:"type" form:"type"`
+	InventoryType     int64   `gorm:"column:inventory_type" json:"inventory_type" form:"inventory_type"`
+	LastStockCount    int64   `gorm:"column:last_stock_count" json:"last_stock_count" form:"last_stock_count"`
+	StockCount        int64   `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
 }
 
 func (XtStockInventory) TableName() string {
 	Number            string  `gorm:"column:number" json:"number" form:"number"`
 	ExpireDate        int64   `gorm:"column:expire_date" json:"expire_date" form:"expire_date"`
 	ProductDate       int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
+	Type              int64   `gorm:"column:type" json:"type" form:"type"`
+	InventoryType     int64   `gorm:"column:inventory_type" json:"inventory_type" form:"inventory_type"`
+	LastStockCount    int64   `gorm:"column:last_stock_count" json:"last_stock_count" form:"last_stock_count"`
+	StockCount        int64   `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
 }
 
 type XtStockCorrectRecord struct {
 	RetailPrice       float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
 	PackingPrice      float64 `gorm:"column:packing_price" json:"packing_price" form:"packing_price"`
 }
+
+type GoodSotckInfo struct {
+	GoodId            int64  `gorm:"column:good_id" json:"good_id" form:"good_id"`
+	StockCount        int64  `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
+	GoodName          string `gorm:"column:good_name" json:"good_name"`
+	SpecificationName string `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
+}
+
+func (GoodSotckInfo) TableName() string {
+	return "xt_warehouse_info"
+}

service/dialysis_service.go

 
 func GetGoodInfoMation(orgid int64) (goodinfo []*models.GoodInfo, err error) {
 
-	err = XTReadDB().Model(&goodinfo).Where("org_id = ? and status = 1 AND  find_in_set('停用',good_status) = 0", orgid).Find(&goodinfo).Error
+	err = XTReadDB().Model(&goodinfo).Where("org_id = ? and status = 1 AND  find_in_set('停用',good_status) = 0", orgid).Preload("GoodSotckInfo", "stock_count >0").Find(&goodinfo).Error
 	return goodinfo, err
 }
 

service/gobal_config_service.go

 func GetAllBaseDurgListCount(page int64, limit int64, keyword string, drugcategory int64, startime int64, endtime int64, orgid int64) (drug []*models.VmBaseDrug, total int64, err error) {
 
 	offset := (page - 1) * limit
-	db := XTReadDB().Table("xt_base_drug").Where("status = 1")
+	db := readDb2.Table("xt_base_drug").Where("status = 1")
 	likeKey := "%" + keyword + "%"
 	if orgid > 0 {
 		db = db.Where("org_id = ?", orgid)
 }
 
 func GetMinCountList(startime int64, endtime int64, orgid int64) (info []*models.DrugWarehouseInfo, err error) {
-	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
+	db := readDb2.Table("xt_drug_warehouse_info as x").Where("x.status = 1")
 
 	if startime > 0 {
 		db = db.Where("x.ctime >=?", startime)
 }
 
 func GetOutDrugCountList(startime int64, endtime int64, orgid int64) (info []*models.VmDrugWarehouseInfo, err error) {
-	db := XTReadDB().Table("xt_drug_warehouse_out_info as x").Where("x.status = 1")
+	db := readDb2.Table("xt_drug_warehouse_out_info as x").Where("x.status = 1")
 
 	if startime > 0 {
 		db = db.Where("x.ctime >=?", startime)
 }
 
 func GetAutoDrugCountList(startime int64, endtime int64, orgid int64) (info []*models.DrugAutomaticReduceDetail, err error) {
-	db := XTReadDB().Table("xt_drug_automatic_reduce_detail as x").Where("x.status = 1")
+	db := readDb2.Table("xt_drug_automatic_reduce_detail as x").Where("x.status = 1")
 
 	if startime > 0 {
 		db = db.Where("x.record_time >=?", startime)
 
 func GetCancelDrugCountList(startime int64, endtime int64, orgid int64) (info []*models.DrugCancelStockInfo, err error) {
 
-	db := XTReadDB().Table(" xt_drug_cancel_stock_info as x").Where("x.status = 1")
+	db := readDb2.Table(" xt_drug_cancel_stock_info as x").Where("x.status = 1")
 
 	if startime > 0 {
 		db = db.Where("x.ctime >=?", startime)
 		db = db.Where("x.warehouse_out_id = ?", id)
 	}
 
-	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,sum(x.count) as count,x.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,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").Group("x.drug_id").Scan(&info).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,sum(x.count) as count,x.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,x.number,x.batch_number,t.dose,t.dose_unit,t.last_price,t.min_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
 }
 

service/his_service.go

 	WarehousingCount int64 `gorm:"column:warehousing_count" json:"warehousing_count" form:"warehousing_count"`
 	Status           int64 `gorm:"column:status" json:"status" form:"status"`
 	OrgId            int64 `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	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"`
 }
 
 func (OtherDrugWarehouseInfo) TableName() string {
 }
 
 func GetAllDrugLibList(org_id int64) (list []*BaseDrugLib, err error) {
-	err = readDb.Model(&BaseDrugLib{}).Where("org_id = ?  AND status = 1 AND  find_in_set('停用',drug_status) = 0", org_id).Find(&list).Error
+	err = readDb.Model(&BaseDrugLib{}).Where("org_id = ?  AND status = 1 AND  find_in_set('停用',drug_status) = 0", org_id).Preload("OtherDrugWarehouseInfo", "status = 1 and (stock_max_number > 0 or stock_min_number >0)").Find(&list).Error
 	return
 }
 

service/schedule_service.go

 	}).Preload("HisDoctorAdviceInfo", "status = 1").Preload("DialysisPrescription", "status = 1").Preload("DialysisSolution", func(db *gorm.DB) *gorm.DB {
 		return db.Where("status =1").Order("id asc")
 	}).Preload("Solution", func(db *gorm.DB) *gorm.DB {
-		return db.Where("status =1").Group("patient_id,mode_id").Order("id desc")
+		return db.Where("status =1").Group("patient_id,mode_id").Order("id asc")
 	}).Find(&list).Error
 
 	return list, err
 	return
 }
 
-func GetNextWeekDaySchedule(weektype int64, weektime int64, startime int64, endtime int64, orgID int64, zone []string) (schedules []*models.WeekSchedule, err error) {
+func GetNextWeekDaySchedule(weektype int64, weektime int64, startime int64, endtime int64, orgID int64, zone []string) (schedules []*models.WeekScheduleSix, err error) {
 
 	db := readDb.Table("xt_schedule as s ").Where("s.status =1")
 	if orgID > 0 {
 		}).Preload("DialysisSolution", func(db *gorm.DB) *gorm.DB {
 		return db.Where("status = 1").Order("id asc")
 	}).Preload("Solution", func(db *gorm.DB) *gorm.DB {
-		return db.Where("status = 1").Group("patient_id,mode_id").Order("id desc")
+		return db.Where("status = 1").Group("patient_id,mode_id").Order("id asc")
 	}).Preload("DoctorAdvice", func(db *gorm.DB) *gorm.DB {
 		return db.Where("status =1 and parent_id = 0").Preload("ChildDoctorAdvice", "status = 1")
 	}).Preload("HisDoctorAdviceInfo", "status = 1").Joins("JOIN xt_patients as p ON p.id = s.patient_id").

service/self_drug_service.go

 	return info, err
 }
 
-func GetLastDrugWarehouseInfo(drugid int64) (models.XtDrugWarehouseInfo, error) {
+func GetLastDrugWarehouseInfSix(drugid int64) (models.XtDrugWarehouseInfo, error) {
 
 	info := models.XtDrugWarehouseInfo{}
-	err := XTReadDB().Model(&info).Where("id=? and status = 1", drugid).Last(&info).Error
+	err := XTReadDB().Model(&info).Where("drug_id=? and status = 1", drugid).Last(&info).Error
 	return info, err
 }
 

service/stock_service.go

 }
 
 func FindAllGoodType(org_id int64) (goodType []*models.GoodsType, err error) {
-	err = readDb.Model(&models.GoodsType{}).Where("org_id = ? AND status = 1", org_id).Find(&goodType).Error
+	err = readDb2.Model(&models.GoodsType{}).Where("org_id = ? AND status = 1", org_id).Find(&goodType).Error
 	return goodType, err
 }
 
 }
 
 func FindAllGoodInfo(org_id int64) (goodInfo []*models.GoodInfo, err error) {
-	err = readDb.Model(&models.GoodInfo{}).Where("org_id = ? AND status = 1", org_id).Find(&goodInfo).Error
+	err = readDb2.Model(&models.GoodInfo{}).Where("org_id = ? AND status = 1", org_id).Find(&goodInfo).Error
 	return goodInfo, err
 }
 
 	return
 }
 
+func GetDrugFlowIsExist(warhouseing int64, drug_id int64) (*models.DrugFlow, error) {
+
+	info := models.DrugFlow{}
+	err = XTReadDB().Where("warehousing_id = ? and drug_id = ? and status = 1", warhouseing, drug_id).Find(&info).Error
+
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &info, nil
+}
+
 func GetDrugByWarehouseInfo(id int64) (models.XtDrugWarehouseInfo, error) {
 
 	info := models.XtDrugWarehouseInfo{}
 	return err
 }
 
+func CreateDrugFlowTwo(flow *models.DrugFlow) error {
+
+	err := XTWriteDB().Create(&flow).Error
+	return err
+}
 func FindLastWarehousingInfo(order string) (info models.WarehousingInfo, err error) {
 	err = readDb.Model(&models.WarehousingInfo{}).Where("warehousing_order = ? AND status = 1", order).Last(&info).Error
 
 	return info, err
 }
 
+func FindWarehousingInfoTen(goodId int64) (models.WarehousingInfo, error) {
+	info := models.WarehousingInfo{}
+	err := XTReadDB().Select(" good_id,sum(stock_count) as stock_count").Where("good_id = ? and status = 1", goodId).Find(&info).Error
+	return info, err
+}
+
 //药品先进先出,找出最先入库的批次
 
 func FindLastDrugWarehousingInfoByID(drug_id int64) (info models.XtDrugWarehouseInfo, err error) {
 
 func FindAllStockInfo(orgId int64, page int64, limit int64, keyword string, startime int64, endtime int64, type_name int64) (list []*models.StockInfo, total int64, err error) {
 
-	db := readDb.Model(&models.StockInfo{})
+	db := readDb2.Model(&models.StockInfo{})
 	if startime > 0 {
 
 		db = db.Preload("QueryWarehouseOutInfo", func(db *gorm.DB) *gorm.DB {
 
 func GetCoutWareseOutInfo(startime int64, endtime int64, orgid int64) (houseOutInfo []*models.VmWarehouseOutInfo, err error) {
 
-	db := XTReadDB().Table("xt_warehouse_out_info as x").Where("x.status  =1")
+	db := readDb2.Table("xt_warehouse_out_info as x").Where("x.status  =1")
 	err = db.Select("x.good_id,Sum(x.count) as count,x.remark,x.price,x.org_id").Where("x.ctime >=? and x.ctime<=? and x.org_id = ?", startime, endtime, orgid).Group("x.good_id").Scan(&houseOutInfo).Error
 	return houseOutInfo, err
 }
 func GetGoodInfomationList(orgid int64, keyword string) (goodInfo []*models.GoodInfo, err error) {
 	key := "%" + keyword + "%"
 	if len(keyword) == 0 {
-		err = XTReadDB().Where("org_id = ? and status = 1 AND  find_in_set('停用',good_status) = 0", orgid).Find(&goodInfo).Error
+		err = readDb2.Where("org_id = ? and status = 1 AND  find_in_set('停用',good_status) = 0", orgid).Find(&goodInfo).Error
 
 	} else {
-		err = XTReadDB().Where("org_id = ? and status = 1 AND good_name like ? AND  find_in_set('停用',good_status) = 0", orgid, key).Find(&goodInfo).Error
+		err = readDb2.Where("org_id = ? and status = 1 AND good_name like ? AND  find_in_set('停用',good_status) = 0", orgid, key).Find(&goodInfo).Error
 
 	}
 	return goodInfo, err
 
 func GetAllManufacturerList(orgid int64) (list []*models.Manufacturer, err error) {
 
-	err = XTReadDB().Where("org_id = ? and status = 1", orgid).Find(&list).Error
+	err = readDb2.Where("org_id = ? and status = 1", orgid).Find(&list).Error
 	return list, err
 }
 
 
 func GetSearchDrugList(keywords string, orgid int64) (drug []*models.BaseDrugLib, err error) {
 
-	db := XTReadDB().Model(&drug).Where("org_id=? and status=1 ", orgid)
+	db := XTReadDB().Model(&drug).Where("org_id=? and status=1  and drug_status<>'停用'", orgid)
 	if len(keywords) > 0 {
 		likekey := "%" + keywords + "%"
 		err = db.Where("(drug_name LIKE ?)", likekey).Find(&drug).Error
 
 func GetSearchGoodList(keywords string, orgid int64) (good []*models.GoodInfo, err error) {
 
-	db := XTReadDB().Model(&good).Where("org_id =? and status = 1", orgid)
+	db := XTReadDB().Model(&good).Where("org_id =? and status = 1 and good_status <> '停用'", orgid)
 	if len(keywords) > 0 {
 		likekey := "%" + keywords + "%"
 		err = db.Where("(good_name Like ?)", likekey).Preload("StWarehousingInfo", func(db *gorm.DB) *gorm.DB {
 func GetAllGoodInfoStockList(page int64, limit int64, startime int64, endtime int64, good_type int64, keyword string, orgid int64) (info []*models.GoodInfo, total int64, err error) {
 
 	offset := (page - 1) * limit
-	db := XTReadDB().Table("xt_good_information as x").Where("x.status= 1")
+	db := readDb2.Table("xt_good_information as x").Where("x.status= 1")
 
 	likeKey := "%" + keyword + "%"
 	if len(likeKey) > 0 {
 
 func GetStockDrugCount(startime int64, endtime int64, orgid int64) (info []*models.VmWarehouseInfo, err error) {
 
-	db := XTReadDB().Table("xt_warehouse_info as x").Where("x.status = 1")
+	db := readDb2.Table("xt_warehouse_info as x").Where("x.status = 1")
 	if startime > 0 {
 		db = db.Where("x.ctime >=?", startime)
 	}
 }
 
 func GetAutoDiallysisBefor(startime int64, endtime int64, orgid int64) (info []*models.VmWarehouseInfo, err error) {
-	db := XTReadDB().Table("xt_warehouse_out_info as x").Where("x.status = 1")
+	db := readDb2.Table("xt_warehouse_out_info as x").Where("x.status = 1")
 	if startime > 0 {
 		db = db.Where("x.ctime >=?", startime)
 	}
 func GetOutStockTotalCountFour(startime int64, endtime int64, orgid int64) (autoMatic []*models.NewXtAutomaticReduceDetail, err error) {
 
 	if endtime > 0 {
-		err = XTReadDB().Raw("SELECT good_id,SUM(b.count) as count FROM (SELECT DISTINCT x.patient_id,x.good_id,x.count,x.record_time FROM xt_automatic_reduce_detail as x WHERE x.org_id = ? and x.record_time >= ? and x.record_time <=?  and `status` = 1)  as b GROUP BY good_id", orgid, startime, endtime).Scan(&autoMatic).Error
+		err = readDb2.Raw("SELECT good_id,SUM(b.count) as count FROM (SELECT DISTINCT x.patient_id,x.good_id,x.count,x.record_time FROM xt_automatic_reduce_detail as x WHERE x.org_id = ? and x.record_time >= ? and x.record_time <=?  and `status` = 1)  as b GROUP BY good_id", orgid, startime, endtime).Scan(&autoMatic).Error
 	}
 	if endtime == 0 {
 		err = XTReadDB().Raw("SELECT good_id,SUM(b.count) as count FROM (SELECT DISTINCT x.patient_id,x.good_id,x.count,x.record_time FROM xt_automatic_reduce_detail as x WHERE x.org_id = ? and `status` = 1)  as b GROUP BY good_id", orgid).Scan(&autoMatic).Error
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	}
-	err = db.Select("x.id,x.warehouse_out_id,x.warehouse_info_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.number,x.remark,x.license_number,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.good_id").Order("x.ctime desc").Scan(&out).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.warehouse_info_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.number,x.remark,x.license_number,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.good_id,x.warehouse_info_id").Order("x.ctime desc").Scan(&out).Error
 	return out, err
 }
 
 
 func GetDrugWarehouOrderInfo(startime int64, endtime int64, orgid int64) (info []*models.VmDrugWarehouseOutInfo, err error) {
 
-	db := XTReadDB().Table("xt_drug_warehouse_out_info as x").Where("x.status = 1")
-	table := XTReadDB().Table("xt_base_drug as t").Where("t.status = 1")
+	db := readDb2.Table("xt_drug_warehouse_out_info as x").Where("x.status = 1")
+	table := readDb2.Table("xt_base_drug as t").Where("t.status = 1")
 	fmt.Println(table)
 	if startime > 0 {
 		db = db.Where("x.ctime>=?", startime)
 	return info, err
 }
 
+func GetDrugTotalCountTwo(drugid int64) (list []*models.VmDrugWarehouseInfo, err error) {
+
+	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
+	table := XTReadDB().Table("xt_base_drug as d").Where("d.status = 1")
+	fmt.Println(table)
+	if drugid > 0 {
+		db = db.Where("x.drug_id = ?", drugid)
+	}
+	err = db.Select("x.drug_id,x.stock_max_number,x.stock_min_number,d.min_number").Joins("left join xt_base_drug as d on d.id = x.drug_id").Scan(&list).Error
+
+	return list, err
+}
+
 func GetDrugByGoodId(drugid int64) (models.BaseDrugLib, error) {
 
 	lib := models.BaseDrugLib{}
 
 func GetStockBatchNumber(id int64, orgid int64) (info []*models.WarehousingInfo, err error) {
 
-	err = XTReadDB().Model(&info).Where("good_id = ? and org_id = ? and status = 1 and number <> ''", id, orgid).Group("number").Find(&info).Error
+	err = XTReadDB().Model(&info).Where("good_id = ? and org_id = ? and status = 1 and number <> '' and stock_count<> 0", id, orgid).Find(&info).Error
 	return info, err
 }
 
 func GetWarehouseOutInfoById(id int64, goodid int64) (info []*models.WarehouseOutInfo, err error) {
 
-	err = XTReadDB().Model(&info).Where("warehouse_out_id = ? and good_id = ? and status = 1", id, goodid).Find(&info).Error
+	err = XTReadDB().Where("warehouse_out_id = ? and good_id = ? and status = 1", id, goodid).Find(&info).Error
 	return info, err
 }
 
 	return out, err
 }
 
-func GetLastGoodInformationByGoodId(goodid int64, warehouse_info_id int64, orgid int64) (models.WarehouseOutInfo, error) {
+func GetLastGoodInformationByGoodId(goodid int64, warehouse_info_id int64) (models.WarehouseOutInfo, error) {
 
 	info := models.WarehouseOutInfo{}
 	err := XTReadDB().Where("good_id = ? and warehouse_info_id= ? and status =1", goodid, warehouse_info_id).Last(&info).Error
 }
 
 func FindFirstWarehousingInfoByGoodId(good_id int64, id int64) (info models.WarehousingInfo, err error) {
-	err = readDb.Model(&models.WarehousingInfo{}).Where("good_id = ? AND status = 1 and id<>?", good_id, id).Order("ctime").First(&info).Error
+	err = readDb.Model(&models.WarehousingInfo{}).Where("good_id = ? AND status = 1 and stock_count > 0", good_id).Order("ctime asc").First(&info).Error
 	return info, err
 }
 
 	return info, err
 }
 
+func GetLastCancelStockInfoOne(id int64, drug_id int64) (models.DrugCancelStockInfo, error) {
+
+	info := models.DrugCancelStockInfo{}
+
+	err := XTReadDB().Where("cancel_stock_id = ? and drug_id = ? and status = 1", id, drug_id).Find(&info).Error
+	return info, err
+}
+
 func UpdatedDrugInfo(id int64, count int64) (err error) {
 
-	err = writeDb.Model(&models.DrugWarehousingInfo{}).Where("id = ?", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", count)).Error
+	err = XTWriteDB().Model(&models.XtDrugWarehouseInfo{}).Where("id = ?", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", count)).Error
+	return err
+}
+
+func UpdatedDrugFlow(cancelstockid int64, drug_id int64, flow models.DrugFlow) error {
+
+	err := XTWriteDB().Model(&models.DrugFlow{}).Where("cancel_stock_id = ? and drug_id = ? and status = 1", cancelstockid, drug_id).Updates(map[string]interface{}{"count": flow.Count}).Error
 	return err
 }
 
 func UpdatedDrugInfoOne(id int64, count int64) (err error) {
 
-	err = writeDb.Model(&models.XtDrugWarehouseInfo{}).Where("id = ?", id).UpdateColumn("stock_min_number", gorm.Expr("stock_min_number + ?", count)).Error
+	err = XTWriteDB().Model(&models.XtDrugWarehouseInfo{}).Where("id = ?", id).UpdateColumn("stock_min_number", gorm.Expr("stock_min_number + ?", count)).Error
 	return err
 }
 
 	return adjust, total, err
 }
 
+func GetStockDamagedList(orgid int64, keyword string, page int64, limit int64) (adjust []*models.VmStockInventory, total int64, err error) {
+	likeKey := "%" + keyword + "%"
+	offset := (page - 1) * limit
+	db := XTReadDB().Table("xt_stock_inventory as x").Where("x.status = 1 and x.inventory_type = 4")
+	table := XTReadDB().Table("xt_good_information as t").Where("t.status = 1")
+	tab := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
+	fmt.Println(table, tab)
+
+	if len(keyword) > 0 {
+		db = db.Where("x.warehousing_order like ? or r.user_name like ?", likeKey, likeKey)
+	}
+
+	if orgid > 0 {
+		db = db.Where("x.user_org_id = ?", orgid)
+	}
+
+	err = db.Group("x.id").Select("x.id,x.good_name,x.specification_name,x.warehousing_unit,x.count,x.buy_price,x.packing_price,x.new_price,x.manufacturer,x.dealer,x.remark,x.good_id,x.warehousing_order,x.license_number,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.total,x.number,t.packing_unit,r.user_name").Joins("left join sgj_users.sgj_user_admin_role as r on r.admin_user_id = x.creater").Joins("left join xt_good_information as t on t.id =x.good_id").Count(&total).Offset(offset).Limit(limit).Scan(&adjust).Error
+	return adjust, total, err
+
+}
+
+func GetStockDamagedCount(orgid int64) (adjust []*models.VmStockInventory, err error) {
+
+	db := XTReadDB().Table("xt_stock_inventory as x").Where("x.status = 1 and x.inventory_type = 4")
+	if orgid > 0 {
+		db = db.Where("x.user_org_id = ?", orgid)
+	}
+	err = db.Group("x.good_id").Select("x.id,x.good_name,x.specification_name,x.warehousing_unit,sum(x.count) as count,x.buy_price,x.packing_price,x.new_price,x.manufacturer,x.dealer,x.remark,x.good_id,x.warehousing_order,x.license_number,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.total,x.number").Scan(&adjust).Error
+	return adjust, err
+}
+
 func UpdateCheckDamage(ids []string, reportPrice models.XtStockReportPrice) error {
 
 	err := XTWriteDB().Model(&reportPrice).Where("id in(?) and status = 1", ids).Updates(map[string]interface{}{"checker": reportPrice.Checker, "checker_time": reportPrice.CheckerTime, "checker_status": reportPrice.CheckerStatus}).Error
 
 	likeKey := "%" + keyword + "%"
 	offset := (page - 1) * limit
-	db := XTReadDB().Table("xt_stock_inventory as x").Where("x.status = 1")
+	db := XTReadDB().Table("xt_stock_inventory as x").Where("x.status = 1 and x.type = 10")
 	table := XTReadDB().Table("xt_good_information as t").Where("t.status = 1")
 	tab := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
 	fmt.Println(table, tab)
 	if len(keyword) > 0 {
-		db = db.Where("x.warehousing_order = ? or r.user_name like ?", keyword, likeKey)
+		db = db.Where("x.good_name = ?", likeKey)
 	}
 	if orgid > 0 {
 		db = db.Where("x.user_org_id = ?", orgid)
 	}
-	err = db.Select("x.id,x.good_name,x.specification_name,x.warehousing_unit,x.count,x.buy_price,x.packing_price,x.new_price,x.manufacturer,x.dealer,x.remark,x.good_id,x.warehousing_order,x.license_number,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.total,x.number,x.expire_date,x.product_date,t.packing_unit").Joins("left join sgj_users.sgj_user_admin_role as r on r.id = x.creater").Joins("left join xt_good_information as t on t.id =x.good_id").Count(&total).Offset(offset).Limit(limit).Scan(&list).Error
+	err = db.Select("x.id,x.good_name,x.specification_name,x.warehousing_unit,x.count,x.buy_price,x.packing_price,x.new_price,x.manufacturer,x.dealer,x.remark,x.good_id,x.warehousing_order,x.license_number,x.start_time,x.creater,x.checker,x.checker_status,x.checker_time,x.total,x.number,x.expire_date,x.product_date,t.packing_unit,x.last_stock_count,x.type,x.inventory_type,x.stock_count").Joins("left join sgj_users.sgj_user_admin_role as r on r.id = x.creater").Joins("left join xt_good_information as t on t.id =x.good_id").Count(&total).Offset(offset).Limit(limit).Scan(&list).Error
 	return list, total, err
 }
 
 	err = XTReadDB().Model(&info).Where("good_id = ? and status = 1", id).Preload("GoodInfo", "status = 1").Find(&info).Error
 	return info, err
 }
+
+func UpdatedWarehousingInfo(info models.WarehousingInfo, id int64) error {
+	err := XTWriteDB().Model(&info).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"stock_count": info.StockCount}).Error
+	return err
+}
+
+func GetDamageDetailByGoodId(good_id int64) (list []*models.XtStockInventory, err error) {
+
+	err = XTReadDB().Model(&list).Where("good_id = ? and status = 1", good_id).Find(&list).Error
+
+	return list, err
+}
+
+func GetCancelStockId(cancelstock_id int64, drug_id int64) (*models.DrugFlow, error) {
+	flow := models.DrugFlow{}
+	err := XTReadDB().Where("cancel_stock_id = ? and drug_id = ?", cancelstock_id, drug_id).Find(&flow).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &flow, nil
+}
+
+func GetTotalDrugCancelInfo(batchNumber_id int64, drug_id int64, id int64) (info []*models.DrugCancelStockInfo, err error) {
+
+	err = XTReadDB().Where("batch_number_id = ? and drug_id = ? and status = 1 and id<>?", batchNumber_id, drug_id, id).Find(&info).Error
+	return info, err
+}
+
+func GetLastDrugWarehouseInfo(drugid int64) (models.XtDrugWarehouseInfo, error) {
+	info := models.XtDrugWarehouseInfo{}
+	err := XTReadDB().Where("drug_id = ? and status =1", drugid).Last(&info).Error
+	return info, err
+}
+
+func GetLastGoodWarehouseInfo(goodid int64) (models.WarehousingInfo, error) {
+
+	info := models.WarehousingInfo{}
+	err := XTReadDB().Where("good_id =? and status = 1", goodid).Find(&info).Error
+	return info, err
+}
+
+func GetGoodStockFlowInfo(warehouseid int64, goodid int64) (*models.VmStockFlow, error) {
+
+	flow := models.VmStockFlow{}
+	err := XTReadDB().Where("warehousing_detail_id = ? and good_id = ? and status = 1", warehouseid, goodid).Find(&flow).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &flow, nil
+}
+
+func GetLastInfoMationById(id int64) (models.GoodInfo, error) {
+	info := models.GoodInfo{}
+	err := XTReadDB().Where("id =? and status = 1", id).Find(&info).Error
+	return info, err
+}
+
+func UpdateGoodInfoMation(goodid int64, info models.GoodInfo) error {
+
+	err := XTWriteDB().Model(&info).Where("id =? and status = 1", goodid).Updates(map[string]interface{}{"total": info.Total}).Error
+	return err
+}
+
+func UpdateWarehouseInfoByGoodId(info models.WarehousingInfo, id int64) error {
+
+	err := XTWriteDB().Model(&info).Where("id =? and status = 1", id).Updates(map[string]interface{}{"warehousing_count": info.WarehousingCount, "stock_count": info.StockCount}).Error
+	return err
+}

service/user_service.go

 }
 
 func GetAllAdminUsers(orgId, appid int64) (list []*AdminUserList, err error) {
-	//fmt.Println("orgid", orgId)
-	//fmt.Println("appid", appid)
+
 	err = readUserDb.Table("sgj_user_admin_role as uar").Joins("JOIN sgj_user_admin as ua ON ua.id = uar.admin_user_id").Where("uar.status=1 and uar.org_id=? and uar.app_id =? and ua.status=1", orgId, appid).Select("ua.id, uar.user_name as name, uar.user_type").Scan(&list).Error
 	//err = readUserDb.Table("sgj_user_admin_role as uar").Joins("JOIN sgj_user_admin as ua ON ua.id = uar.admin_user_id").Where("uar.status=1  and ua.status=1").Select("ua.id, uar.user_name as name, uar.user_type").Scan(&list).Error
 	return
 }
 
 func GetAllAdminUsersTwo(orgId int64) (list []*AdminUserList, err error) {
-	//fmt.Println("orgid", orgId)
-	//fmt.Println("appid", appid)
+
 	err = readUserDb.Table("sgj_user_admin_role as uar").Joins("JOIN sgj_user_admin as ua ON ua.id = uar.admin_user_id").Where("uar.status=1 and uar.org_id=?  and ua.status=1", orgId).Select("ua.id, uar.user_name as name, uar.user_type").Scan(&list).Error
 	//err = readUserDb.Table("sgj_user_admin_role as uar").Joins("JOIN sgj_user_admin as ua ON ua.id = uar.admin_user_id").Where("uar.status=1  and ua.status=1").Select("ua.id, uar.user_name as name, uar.user_type").Scan(&list).Error
 	return