耗材参数

controllers/drug_stock_api_contorller.go

 	}
 	adminUserInfo := this.GetAdminUserInfo()
 	userDetails, err, total := service.FindDrugStockUserDetailById(adminUserInfo.CurrentOrgId, order_id)
+
 	if err == nil {
 		this.ServeSuccessJSON(map[string]interface{}{
 			"list":  userDetails,

controllers/gobal_config_api_controller.go

 	drugConfig, _ := service.GetDrugStockConfig(orgId)
 	list, err := service.GetDrugAutoMaticList(orgId, warehous_out_id, record_time, warehouse_out_order_number)
 	drugList, err := service.GetAllBaseDrugList(orgId)
+	manufacturerList, _ := service.GetAllManufacturerList(orgId)
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
 		return
 	}
 	c.ServeSuccessJSON(map[string]interface{}{
-		"list":       list,
-		"drugConfig": drugConfig,
-		"drugList":   drugList,
+		"list":             list,
+		"drugConfig":       drugConfig,
+		"drugList":         drugList,
+		"manufacturerList": manufacturerList,
 	})
 }
 

controllers/stock_in_api_controller.go

 func (c *StockManagerApiController) CreateWarehouse() {
 
 	warehousing_time := c.GetString("warehousing_time")
-	dealer_id, _ := c.GetInt64("dealer_id", 0)
-	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
 
 	types, _ := c.GetInt64("type", 0)
 
 		Ctime:            ctime,
 		Status:           1,
 		WarehousingTime:  warehousingDate.Unix(),
-		Dealer:           dealer_id,
-		Manufacturer:     manufacturer_id,
 		Type:             types,
 	}
 	service.AddSigleWarehouse(&warehousing)
 
 				remark, _ := items["remark"].(string)
 
+				manufacturer := int64(items["manufacturer"].(float64))
+				dealer := int64(items["dealer"].(float64))
 				warehouseInfo := &models.WarehousingInfo{
 					WarehousingOrder: warehousing.WarehousingOrder,
 					WarehousingId:    warehousing.ID,
 					Remark:           remark,
 					OrgId:            adminUserInfo.CurrentOrgId,
 					Type:             types,
-					Manufacturer:     manufacturer_id,
-					Dealer:           dealer_id,
+					Manufacturer:     manufacturer,
 					StockCount:       warehousing_count,
+					Dealer:           dealer,
 				}
 				warehousingInfo = append(warehousingInfo, warehouseInfo)
 
 	warehousing_time := c.GetString("warehousing_time")
 	id, _ := c.GetInt64("id", 0)
 	types, _ := c.GetInt64("type", 0)
-	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
-	dealer_id, _ := c.GetInt64("dealer_id", 0)
 
 	if id == 0 {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		Status:           1,
 		WarehousingTime:  warehousingDate.Unix(),
 		Type:             warehouse.Type,
-		Dealer:           dealer_id,
-		Manufacturer:     manufacturer_id,
 	}
 
 	service.EditWarehousing(warehousing)
 
 				remark, _ := items["remark"].(string)
 
+				manufacturer := int64(items["manufacturer"].(float64))
+				dealer := int64(items["dealer"].(float64))
+
 				if items["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
 					utils.ErrorLog("id")
 					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 						Remark:           remark,
 						OrgId:            adminUserInfo.CurrentOrgId,
 						Type:             types,
-						Manufacturer:     manufacturer_id,
-						Dealer:           dealer_id,
+						Manufacturer:     manufacturer,
+						Dealer:           dealer,
+						StockCount:       warehousing_count,
 					}
 					warehousingInfo = append(warehousingInfo, warehouseInfo)
 
 						Remark:           remark,
 						OrgId:            adminUserInfo.CurrentOrgId,
 						Type:             types,
-						Manufacturer:     manufacturer_id,
-						Dealer:           dealer_id,
+						Manufacturer:     manufacturer,
+						Dealer:           dealer,
+						StockCount:       warehousing_count,
 					}
 					upDateWarehousingInfo = append(upDateWarehousingInfo, warehouseInfo)
 				}
 }
 
 func (c *StockManagerApiController) CreateWarehouseOut() {
-	dealer_id, _ := c.GetInt64("dealer_id", 0)
-	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
+
 	types, _ := c.GetInt64("type", 0)
 
 	ctime := time.Now().Unix()
 		Ctime:                   ctime,
 		Status:                  1,
 		WarehouseOutTime:        warehousingOutDate.Unix(),
-		Dealer:                  dealer_id,
-		Manufacturer:            manufacturer_id,
 		Type:                    types,
 	}
 	service.AddSigleWarehouseOut(&warehouseOut)
 				}
 
 				good_id := int64(items["good_id"].(float64))
-				fmt.Println("stockout223232324343445456465656565565665", good_id)
+
 				if items["good_type_id"] == nil || reflect.TypeOf(items["good_type_id"]).String() != "float64" {
 					utils.ErrorLog("good_type_id")
 					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 				total := float64(count) * price
 				remark := items["remark"].(string)
 
+				manufacturer := int64(items["manufacturer"].(float64))
+
 				warehouseOutInfo := &models.WarehouseOutInfo{
 					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 					WarehouseOutId:          warehouseOut.ID,
 					Remark:                  remark,
 					OrgId:                   adminUserInfo.CurrentOrgId,
 					Type:                    types,
-					Manufacturer:            manufacturer_id,
-					Dealer:                  dealer_id,
+					Manufacturer:            manufacturer,
 				}
 				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 	warehouse_out_time := c.GetString("warehouse_out_time")
 	id, _ := c.GetInt64("id", 0)
 	types, _ := c.GetInt64("type", 0)
-	manufacturer_id, _ := c.GetInt64("manufacturer_id", 0)
-	dealer_id, _ := c.GetInt64("dealer_id", 0)
 
 	if id == 0 {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		ID:               warehouseOut.ID,
 		Mtime:            mtime,
 		WarehouseOutTime: warehouseOutDate.Unix(),
-		Manufacturer:     manufacturer_id,
-		Dealer:           dealer_id,
 	}
 
 	service.EditWarehouseOut(tempWarehouseOut)
 				}
 				id := int64(items["id"].(float64))
 
+				manufacturer := int64(items["manufacturer"].(float64))
 				if id == 0 {
 					warehouseOutInfo := &models.WarehouseOutInfo{
 						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 						Remark:                  remark,
 						OrgId:                   adminUserInfo.CurrentOrgId,
 						Type:                    types,
-						Manufacturer:            manufacturer_id,
-						Dealer:                  dealer_id,
 						IsSys:                   0,
 						SysRecordTime:           0,
 					}
 						OrgId:                   adminUserInfo.CurrentOrgId,
 						Mtime:                   time.Now().Unix(),
 						Type:                    types,
-						Manufacturer:            manufacturer_id,
-						Dealer:                  dealer_id,
+						Manufacturer:            manufacturer,
 						IsSys:                   is_sys,
 						SysRecordTime:           sys_record_time,
 					}
 	orgId := adminUserInfo.CurrentOrgId
 	list, _ := service.GetSearchGoodList(keyword, orgId)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
+	dealerList, _ := service.GetAllDealerList(orgId)
 	this.ServeSuccessJSON(map[string]interface{}{
 		"list":             list,
 		"manufacturerList": manufacturerList,
+		"dealerList":       dealerList,
 	})
 }
 
 	}
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
 	list, total, _ := service.GetStockListById(id, orgId, limit, page, startTime, endTime)
+	outList, _, _ := service.GetStockOutList(id, orgId, limit, page, startTime, endTime)
 	this.ServeSuccessJSON(map[string]interface{}{
 		"list":             list,
 		"total":            total,
 		"manufacturerList": manufacturerList,
+		"outList":          outList,
 	})
 }
 

service/gobal_config_service.go

 		db = db.Where("x.drug_id = ?", drugid)
 	}
 
-	err = db.Joins("left join xt_base_drug as t on t.id = x.drug_id and t.status = 1 and t.org_id = ?", orgid).Select("x.id,x.warehousing_id,x.drug_id,x.number,x.product_date,x.expiry_date,x.warehousing_count,x.warehouseing_unit,x.max_unit,x.min_unit,x.stock_max_number,x.stock_min_number,x.price,x.total_price,x.dealer,x.remark,x.org_id,x.is_return,x.warehousing_order,x.type,x.retail_price,x.retail_total_price,x.batch_number,t.drug_name,t.drug_type,t.max_unit,t.min_unit,t.min_number,t.dose,t.dose_unit,t.last_price,t.manufacturer").Offset(offset).Count(&total).Order("x.ctime desc").Scan(&list).Error
+	err = db.Joins("left join xt_base_drug as t on t.id = x.drug_id and t.status = 1 and t.org_id = ?", orgid).Select("x.id,x.warehousing_id,x.drug_id,x.number,x.product_date,x.expiry_date,x.warehousing_count,x.warehouseing_unit,x.max_unit,x.min_unit,x.stock_max_number,x.stock_min_number,x.price,x.total_price,x.dealer,x.remark,x.org_id,x.is_return,x.warehousing_order,x.type,x.retail_price,x.retail_total_price,x.batch_number,x.ctime,t.drug_name,t.drug_type,t.max_unit,t.min_unit,t.min_number,t.dose,t.dose_unit,t.last_price,t.manufacturer").Offset(offset).Count(&total).Order("x.ctime desc").Scan(&list).Error
 	return list, total, err
 }
 
 	if stocktype == 2 {
 		db = db.Where("x,is_sys = 1")
 	}
-	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.warehousing_out_target,x.count,x.price,x.total_price,x.product_date,x.expiry_date,x.org_id,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,x.warehouse_info_id").Offset(offset).Count(&total).Order("x.ctime desc").Scan(&list).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.warehousing_out_target,x.count,x.price,x.total_price,x.product_date,x.expiry_date,x.org_id,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,x.warehouse_info_id,x.ctime").Offset(offset).Count(&total).Order("x.ctime desc").Scan(&list).Error
 	return list, total, err
 }
 

service/stock_service.go

 	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.manufacturer,x.remark,x.ctime,x.is_return,x.warehousing_order,x.type,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.min_unit").Joins("left join xt_good_information as t on t.id = x.good_id").Count(&total).Offset(offset).Limit(limit).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,t.manufacturer,x.remark,x.ctime,x.is_return,x.warehousing_order,x.type,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.min_unit").Joins("left join xt_good_information as t on t.id = x.good_id").Count(&total).Offset(offset).Limit(limit).Scan(&info).Error
 	return info, total, err
 
 }
 	if good_id > 0 {
 		db = db.Where("x.good_id = ?", good_id)
 	}
-	err = db.Select("x.id,x.warehouse_out_id,x.warehouse_info_id,x.good_id,x.good_type_id,x.warehousing_out_target,x.count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id").Offset(offset).Count(&total).Scan(&info).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.warehouse_info_id,x.good_id,x.good_type_id,x.warehousing_out_target,x.count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number").Offset(offset).Count(&total).Scan(&info).Error
 	return info, total, err
 }
 
 
 func GetOutStockTotalCountFour(startime int64, endtime int64, orgid int64) (autoMatic []*models.NewXtAutomaticReduceDetail, err error) {
 
-	err = XTReadDB().Raw("SELECT good_id,SUM(b.count) as count FROM (SELECT DISTINCT x.patient_id,x.good_id,x.count 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 startime > 0 {
+		err = XTReadDB().Raw("SELECT good_id,SUM(b.count) as count FROM (SELECT DISTINCT x.patient_id,x.good_id,x.count FROM xt_automatic_reduce_detail as x WHERE x.org_id = ? and x.record_time >=?  and `status` = 1)  as b GROUP BY good_id", orgid, startime).Scan(&autoMatic).Error
+	} else {
+		err = XTReadDB().Raw("SELECT good_id,SUM(b.count) as count FROM (SELECT DISTINCT x.patient_id,x.good_id,x.count 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 endtime > 0 {
+		err = XTReadDB().Raw("SELECT good_id,SUM(b.count) as count FROM (SELECT DISTINCT x.patient_id,x.good_id,x.count FROM xt_automatic_reduce_detail as x WHERE x.org_id = ? and x.record_time <=?  and `status` = 1)  as b GROUP BY good_id", orgid, endtime).Scan(&autoMatic).Error
+	} else {
+		err = XTReadDB().Raw("SELECT good_id,SUM(b.count) as count FROM (SELECT DISTINCT x.patient_id,x.good_id,x.count FROM xt_automatic_reduce_detail as x WHERE x.org_id = ? and `status` = 1)  as b GROUP BY good_id", orgid).Scan(&autoMatic).Error
+	}
 
 	return autoMatic, err
 

service/warhouse_service.go

 			}
 		}
 		fmt.Println("newcount9999999999999999999999999999999", goods.NewCount)
-		
+
 		maxNumber = goods.Count
-		
 
 		if warehouse.StockCount < maxNumber {
 			return errors.New("库存数量不足")
 		goods.Count = deliver_number - stock_number
 
 		ConsumablesDelivery(orgID, patient_id, record_time, goods, warehouseOut, count)
-		
+
 	}
 	return nil
 }
 			Type:                    1,
 			Manufacturer:            0,
 			Dealer:                  0,
-			IsSys:                   2,
+			IsSys:                   1,
 			SysRecordTime:           record_time,
 			GoodTypeId:              goods.GoodTypeId,
 			GoodId:                  goods.GoodId,
 				Type:                    1,
 				Manufacturer:            0,
 				Dealer:                  0,
-				IsSys:                   2,
+				IsSys:                   1,
 				SysRecordTime:           record_time,
 				GoodTypeId:              goods.GoodTypeId,
 				GoodId:                  goods.GoodId,
 			Type:          1,
 			Manufacturer:  0,
 			Dealer:        0,
-			IsSys:         2,
+			IsSys:         1,
 			SysRecordTime: record_time,
 			GoodTypeId:    good_yc.GoodTypeId,
 			GoodId:        good_yc.GoodId,