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

controllers/drug_stock_api_contorller.go

 	adminInfo := c.GetAdminUserInfo()
 	warehouseOutInfo, _ := service.FindDrugWarehouseOutInfoById(id, adminInfo.CurrentOrgId)
 	warehouseOut, _ := service.FindDrugWareHouseOutById(id, adminInfo.CurrentOrgId)
+	manulist, _ := service.GetAllManufacturerList(adminInfo.CurrentOrgId)
 	c.ServeSuccessJSON(map[string]interface{}{
-		"list": warehouseOutInfo,
-		"info": warehouseOut,
+		"list":     warehouseOutInfo,
+		"info":     warehouseOut,
+		"manulist": manulist,
 	})
 
 }

controllers/gobal_config_api_controller.go

 	//新接口
 	beego.Router("/api/drugstock/drugstocklist", &GobalConfigApiController{}, "Get:GetDrugStockList")
 	beego.Router("/api/drugstock/getdrugstockflow", &GobalConfigApiController{}, "Get:GetDrugStockFllow")
+
+	beego.Router("/api/drugoutstock/getoutdrugstockflow", &GobalConfigApiController{}, "Get:GetDrugOutStockFlow")
+	beego.Router("/api/drug/getbatchorderdetail", &GobalConfigApiController{}, "Get:GetBatchOrderDetail")
 }
 
 //provinces, _ := service.GetDistrictsByUpid(0)21
 	}
 	orgId := c.GetAdminUserInfo().CurrentOrgId
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
+
 	//查询入库数据
 	if stock_type == 3 || stock_type == 0 {
 		list, total, err := service.GetDrugStockFlow(drug_id, startTime, endTime, page, limit, orgId)
 		})
 	}
 
+}
+
+func (c *GobalConfigApiController) GetDrugOutStockFlow() {
+	drug_id, _ := c.GetInt64("drug_id")
+	start_time := c.GetString("start_time")
+	end_time := c.GetString("end_time")
+	stock_type, _ := c.GetInt64("stock_type")
+	page, _ := c.GetInt64("page")
+	limit, _ := c.GetInt64("limit")
+
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	var startTime int64
+	if len(start_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+		if err != nil {
+			fmt.Println(err)
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		startTime = theTime.Unix()
+	}
+	var endTime int64
+	if len(end_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		endTime = theTime.Unix()
+	}
+	orgId := c.GetAdminUserInfo().CurrentOrgId
 	if stock_type >= 0 && stock_type != 3 {
 		outList, total, err := service.GetDrugStockOutFlow(drug_id, startTime, endTime, page, limit, orgId, stock_type)
+
 		if err != nil {
 			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
 			return
 			"total":   total,
 		})
 	}
+}
+
+func (c *GobalConfigApiController) GetBatchOrderDetail() {
 
+	drug_id, _ := c.GetInt64("drug_id")
+	orgId := c.GetAdminUserInfo().CurrentOrgId
+	limit, _ := c.GetInt64("limit")
+	page, _ := c.GetInt64("page")
+	detail, total, err := service.GetBatchOrderDetail(drug_id, orgId, limit, page)
+	if err != nil {
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
+		return
+	}
+	c.ServeSuccessJSON(map[string]interface{}{
+		"detail": detail,
+		"total":  total,
+	})
 }

controllers/stock_in_api_controller.go

 	beego.Router("/api/good/getwarehouseorderinfolist", &StockManagerApiController{}, "Get:GetWarehouseOrderInfolist")
 
 	beego.Router("/api/good/postsearchgoodlist", &StockManagerApiController{}, "Get:PostSearchGoodList")
+
+	beego.Router("/api/good/getallstocklist", &StockManagerApiController{}, "Get:GetAllStockList")
 }
 
 func (c *StockManagerApiController) CreateWarehouse() {
 		"manufacturerList": manufacturerList,
 	})
 }
+
+func (this *StockManagerApiController) GetAllStockList() {
+
+	page, _ := this.GetInt64("page", -1)
+	limit, _ := this.GetInt64("limit", -1)
+	start_time := this.GetString("start_time")
+	end_time := this.GetString("end_time")
+	types, _ := this.GetInt64("type", 0)
+	keywords := this.GetString("keywords")
+
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	var startTime int64
+	if len(start_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+		if err != nil {
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		startTime = theTime.Unix()
+	}
+	var endTime int64
+	if len(end_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		endTime = theTime.Unix()
+	}
+	adminUserInfo := this.GetAdminUserInfo()
+	orgId := adminUserInfo.CurrentOrgId
+
+	list, total, _ := service.GetAllStockList(page, limit, startTime, endTime, types, keywords, orgId)
+	manufacturerList, _ := service.GetAllManufacturerList(orgId)
+	this.ServeSuccessJSON(map[string]interface{}{
+		"list":             list,
+		"total":            total,
+		"manufacturerList": manufacturerList,
+	})
+}

models/stock_models.go

 	return "xt_warehouse_info"
 }
 
+type VmWarehousingInfo struct {
+	ID                int64       `gorm:"column:id" json:"id"`
+	WarehousingId     int64       `gorm:"column:warehousing_id" json:"warehousing_id"`
+	GoodId            int64       `gorm:"column:good_id" json:"good_id"`
+	GoodTypeId        int64       `gorm:"column:good_type_id" json:"good_type_id"`
+	Number            string      `gorm:"column:number" json:"number"`
+	ProductDate       int64       `gorm:"column:product_date" json:"product_date"`
+	ExpiryDate        int64       `gorm:"column:expiry_date" json:"expiry_date"`
+	WarehousingCount  int64       `gorm:"column:warehousing_count" json:"warehousing_count"`
+	WarehousingUnit   string      `gorm:"column:warehousing_unit" json:"warehousing_unit"`
+	Price             float64     `gorm:"column:price" json:"price"`
+	TotalPrice        float64     `gorm:"column:total_price" json:"total_price"`
+	Dealer            int64       `gorm:"column:dealer" json:"dealer"`
+	Manufacturer      int64       `gorm:"column:manufacturer" json:"manufacturer"`
+	Remark            string      `gorm:"column:remark" json:"remark"`
+	Ctime             int64       `gorm:"column:ctime" json:"ctime"`
+	Mtime             int64       `gorm:"column:mtime" json:"mtime"`
+	Status            int64       `gorm:"column:status" json:"status"`
+	OrgId             int64       `gorm:"column:org_id" json:"org_id"`
+	IsReturn          int64       `gorm:"column:is_return" json:"is_return"`
+	StockCount        int64       `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
+	Warehousing       Warehousing `ForeignKey:WarehousingId json:"warehouse"`
+	WarehousingOrder  string      `gorm:"column:warehousing_order" json:"warehousing_order"`
+	GoodInfo          GoodInfo    `gorm:"ForeignKey:ID;AssociationForeignKey:GoodId" `
+	Type              int64       `gorm:"column:type" json:"type"`
+	GoodName          string      `gorm:"column:good_name" json:"good_name"`
+	SpecificationName string      `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
+	MinNumber         int64       `gorm:"column:min_number" json:"min_number" form:"min_number"`
+	MinUnit           string      `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+}
+
 type WarehouseOut struct {
 	ID                      int64        `gorm:"column:id" json:"id"`
 	WarehouseOutOrderNumber string       `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number"`

service/gobal_config_service.go

 		db = db.Where("x.org_id = ?", orgid)
 	}
 
-	err = db.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.packing_unit,t.dosage,t.manufacturer").Offset(offset).Count(&total).Group("x.drug_id").Order("x.ctime desc").Scan(&list).Error
+	err = db.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).Group("x.drug_id").Order("x.ctime desc").Scan(&list).Error
 	return list, total, err
 }
 
 		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.packing_unit,t.dosage,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,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
 }
 
 	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.warehousing_out_target,x.count,x.count_unit,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
 	return list, total, err
 }
+
+func GetBatchOrderDetail(drugid int64, orgid int64, page int64, limit int64) (drug []*models.DrugWarehouseInfo, total int64, err error) {
+	offset := (page - 1) * limit
+	err = XTReadDB().Model(&drug).Where("drug_id = ? and org_id = ?", drugid, orgid).Offset(offset).Count(&total).Find(&drug).Error
+	return drug, total, err
+}

service/stock_service.go

 	err = readDb.Model(&models.GoodInfo{}).Where("id = ? AND status = 1", id).First(&goodInfo).Error
 	return
 }
+
+func GetAllStockList(page int64, limit int64, startime int64, endtime int64, good_type int64, keyword string, orgid int64) (info []*models.VmWarehousingInfo, total int64, err error) {
+
+	offset := (page - 1) * limit
+	db := XTReadDB().Table("xt_warehouse_info as x").Where("x.status= 1")
+	table := XTReadDB().Table("xt_good_information as t").Where("t.status = 1")
+	fmt.Println(table)
+	if startime > 0 {
+		db = db.Where("x.ctime>=?", startime)
+	}
+	if endtime > 0 {
+		db = db.Where("x.ctime<=?", endtime)
+	}
+
+	likeKey := "%" + keyword + "%"
+	if len(likeKey) > 0 {
+		db = db.Where("t.good_name like ?", likeKey)
+	}
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	if good_type > 0 {
+		db = db.Where("t.good_type_id = ?", good_type)
+	}
+	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").Offset(offset).Count(&total).Group("x.good_id").Scan(&info).Error
+	return info, total, err
+}