1、修改相关列表的商品分类，选择父分类后支持展示子分类的数据；

2、零售明细入参商品分类改成多选；

app/admin/models/category.go

@@ -180,3 +180,54 @@ func IsExistingCategory(categoryName string) bool {
 
 	return count > 0
 }
+
+// GetSubcategoryIds 获取指定分类的所有子分类ID
+func GetSubcategoryIds(categoryID uint32) ([]uint32, error) {
+	var subCategories []Category
+	err := orm.Eloquent.Model(&Category{}).Where("pid = ?", categoryID).Find(&subCategories).Error
+	if err != nil {
+		return nil, err
+	}
+
+	var subCategoryIDs []uint32
+	for _, subCategory := range subCategories {
+		subCategoryIDs = append(subCategoryIDs, subCategory.ID)
+		// 递归获取子分类的子分类
+		childIDs, err := GetSubcategoryIds(subCategory.ID)
+		if err != nil {
+			return nil, err
+		}
+		subCategoryIDs = append(subCategoryIDs, childIDs...)
+	}
+
+	return subCategoryIDs, nil
+}
+
+// TransformErpCategoryIds 转换 ErpCategoryId，将子分类ID添加进来并去重
+func TransformErpCategoryIds(categoryIds []uint32) ([]uint32, error) {
+	categoryIDSet := make(map[uint32]struct{}) // 用于去重的集合
+
+	// 遍历传入的 ErpCategoryId
+	for _, categoryID := range categoryIds {
+		// 获取当前分类及其所有子分类ID
+		subCategoryIDs, err := GetSubcategoryIds(categoryID)
+		if err != nil {
+			return nil, err
+		}
+
+		// 将当前分类ID添加到集合中
+		categoryIDSet[categoryID] = struct{}{}
+		// 将子分类ID添加到集合中
+		for _, subID := range subCategoryIDs {
+			categoryIDSet[subID] = struct{}{}
+		}
+	}
+
+	// 将集合转换为切片
+	var result []uint32
+	for id := range categoryIDSet {
+		result = append(result, id)
+	}
+
+	return result, nil
+}

app/admin/models/decision.go

@@ -170,15 +170,22 @@ func (m *ErpDecisionReportReq) DecisionReportList(c *gin.Context) (*ErpDecisionR
 	}
 
 	if len(m.CategoryID) > 0 { // 商品分类id
-		var categoryIDs []uint32
+		//var categoryIDs []uint32
-		for _, category := range m.CategoryID {
+		//for _, category := range m.CategoryID {
-			categoryIDs = append(categoryIDs, category)
+		//	categoryIDs = append(categoryIDs, category)
-		}
+		//}
-		if len(categoryIDs) == 1 {
+		//if len(categoryIDs) == 1 {
-			qs = qs.Where("erp_category_id = ?", categoryIDs[0])
+		//	qs = qs.Where("erp_category_id = ?", categoryIDs[0])
-		} else {
+		//} else {
-			qs = qs.Where("erp_category_id IN (?)", categoryIDs)
+		//	qs = qs.Where("erp_category_id IN (?)", categoryIDs)
+		//}
+		//
+		categoryList, err := TransformErpCategoryIds(m.CategoryID)
+		if err != nil {
+			return nil, err
 		}
+
+		qs = qs.Where("erp_category_id IN ?", categoryList)
 	}
 
 	var count int64

app/admin/models/erp_order.go

@@ -342,7 +342,7 @@ type ErpOrderRetailDetailReq struct {
 	Uid              int      `json:"uid"`                // 用户ID
 	Tel              string   `json:"tel"`                // 客户手机号
 	StoreId          uint32   `json:"store_id"`           // 门店ID
-	ErpCategoryId    uint32 `json:"erp_category_id"`    // 分类id
+	ErpCategoryId    []uint32 `json:"erp_category_id"`    // 分类id
 	ErpCommodityName string   `json:"erp_commodity_name"` // 商品名称
 	Salesman         uint32   `json:"salesman"`           // 销售人员ID
 	IMEI             string   `json:"imei"`               // 串码
@@ -2936,7 +2936,11 @@ func QueryRetailMargin(req *ErpOrderRetailMarginReq, c *gin.Context) (*ErpOrderR
 		qs.Where("erp_order_commodity.erp_commodity_name in ?", req.ErpCommodityName)
 	}
 	if len(req.ErpCategoryId) != 0 {
-		qs.Where("erp_order_commodity.erp_category_id in ?", req.ErpCategoryId)
+		categoryList, err := TransformErpCategoryIds(req.ErpCategoryId)
+		if err != nil {
+			return nil, err
+		}
+		qs.Where("erp_order_commodity.erp_category_id in ?", categoryList)
 	}
 	if req.StartTime != "" {
 		startTime, err := time.Parse(QueryTimeFormat, req.StartTime)
@@ -3213,7 +3217,7 @@ func QueryRetailDetail(req *ErpOrderRetailDetailReq, c *gin.Context) (*ErpOrderR
 	}
 
 	var err error
-	if (req.ErpCategoryId != 0 || req.ErpCommodityName != "" || req.IMEI != "") && req.BillSn == "" { // 商品分类or商品名称不为空且订单编号为空
+	if (len(req.ErpCategoryId) != 0 || req.ErpCommodityName != "" || req.IMEI != "") && req.BillSn == "" { // 商品分类or商品名称不为空且订单编号为空
 		// 联表查询
 		resp, err = queryRetailDetailByJoin(req, c)
 	} else {
@@ -4200,11 +4204,15 @@ func queryRetailDetailByJoin(req *ErpOrderRetailDetailReq, c *gin.Context) (*Erp
 	rejectedOrderSumQs := orm.Eloquent.Table("erp_order_commodity AS oc").Select("oc.*, eo.*").
 		Joins("JOIN erp_order AS eo ON oc.erp_order_id = eo.id")
 
-	if req.ErpCategoryId != 0 { // 商品分类
+	if len(req.ErpCategoryId) != 0 { // 商品分类
-		qs = qs.Where("erp_order_commodity.erp_category_id=?", req.ErpCategoryId)
+		categoryList, err := TransformErpCategoryIds(req.ErpCategoryId)
-		es = es.Where("erp_order_commodity.erp_category_id=?", req.ErpCategoryId)
+		if err != nil {
-		orderSumQs = orderSumQs.Where("oc.erp_category_id=?", req.ErpCategoryId)
+			return nil, err
-		rejectedOrderSumQs = rejectedOrderSumQs.Where("oc.erp_category_id=?", req.ErpCategoryId)
+		}
+		qs = qs.Where("erp_order_commodity.erp_category_id in ?", categoryList)
+		es = es.Where("erp_order_commodity.erp_category_id in ?", categoryList)
+		orderSumQs = orderSumQs.Where("oc.erp_category_id in ?", categoryList)
+		rejectedOrderSumQs = rejectedOrderSumQs.Where("oc.erp_category_id in ?", categoryList)
 	}
 	if req.ErpCommodityName != "" { // 商品名称
 		qs = qs.Where("erp_order_commodity.erp_commodity_name = ?", req.ErpCommodityName)

app/admin/models/inventory_report.go

@@ -455,8 +455,12 @@ func (m *InventoryReportByProductReq) ReportByProductList(c *gin.Context) (*Inve
 	}
 
 	if len(m.CategoryID) > 0 {
-		qs = qs.Where("erp_category_id IN (?)", m.CategoryID)
+		categoryList, err := TransformErpCategoryIds(m.CategoryID)
-		sumQs = sumQs.Where("erp_category_id IN (?)", m.CategoryID)
+		if err != nil {
+			return nil, err
+		}
+		qs = qs.Where("erp_category_id IN ?", categoryList)
+		sumQs = sumQs.Where("erp_category_id IN ?", categoryList)
 	}
 
 	if len(m.CommoditySerialNumber) > 0 { // 商品编号
@@ -960,7 +964,11 @@ func (m *InventoryReportByAllotReq) ReportAllotList(c *gin.Context) (*InventoryR
 
 		// 判断分类信息是否有筛选
 		if len(m.CategoryID) > 0 { // 商品分类id
-			if !tools.Uint32SliceContains(m.CategoryID, commodityInfo.ErpCategoryId) {
+			categoryList, err := TransformErpCategoryIds(m.CategoryID)
+			if err != nil {
+				return nil, err
+			}
+			if !tools.Uint32SliceContains(categoryList, commodityInfo.ErpCategoryId) {
 				continue
 			}
 		}
@@ -1200,12 +1208,12 @@ func (m *InventoryReportAllotDetailReq) ReportAllotDetailList(c *gin.Context) (*
 	}
 
 	if len(m.CategoryID) > 0 { // 商品分类id
-		var categoryIDs []uint32
+		categoryList, err := TransformErpCategoryIds(m.CategoryID)
-		for _, category := range m.CategoryID {
+		if err != nil {
-			categoryIDs = append(categoryIDs, category)
+			return nil, err
 		}
-		qs = qs.Where("erp_inventory_allot_commodity.category_id IN (?)", categoryIDs)
+		qs = qs.Where("erp_inventory_allot_commodity.category_id IN ?", categoryList)
-		countQuery = countQuery.Where("erp_inventory_allot_commodity.category_id IN (?)", categoryIDs)
+		countQuery = countQuery.Where("erp_inventory_allot_commodity.category_id IN ?", categoryList)
 	}
 
 	if m.IMEI != "" {
@@ -1553,10 +1561,17 @@ func (m *InventoryReportByOtherReq) ReportByOtherList(c *gin.Context) (*Inventor
 	var nTotalAllotCount int64
 	var nTotalAllotAmount float64
 	filteredData := make([]ReportByOtherData, 0)
+	var categoryList []uint32
+	if len(m.CategoryID) != 0 {
+		categoryList, err = TransformErpCategoryIds(m.CategoryID)
+		if err != nil {
+			return nil, err
+		}
+	}
 	for _, data := range summaryList {
 		if (len(m.StoreId) == 0 || tools.Uint32SliceContains(m.StoreId, data.StoreId)) &&
 			(len(m.CommodityName) == 0 || tools.StringSliceContains(m.CommodityName, data.CommodityName)) &&
-			(len(m.CategoryID) == 0 || tools.Uint32SliceContains(m.CategoryID, data.CategoryID)) &&
+			(len(m.CategoryID) == 0 || tools.Uint32SliceContains(categoryList, data.CategoryID)) &&
 			(m.Type == 0 || m.Type == data.Type) &&
 			((m.StartTime == "" && m.EndTime == "") || (data.StockTime.After(startTime) && data.StockTime.Before(endTime))) {
 			nTotalAllotCount += data.Count
@@ -1817,10 +1832,18 @@ func (m *InventoryReportOtherDetailReq) ReportByOtherDetailList(c *gin.Context)
 				continue
 			}
 		} else {
+			var categoryList []uint32
+			if len(m.CategoryID) != 0 {
+				categoryList, err = TransformErpCategoryIds(m.CategoryID)
+				if err != nil {
+					return nil, err
+				}
+			}
+
 			if (len(m.SerialNumber) == 0 || data.SerialNumber == m.SerialNumber) &&
 				(len(m.StoreId) == 0 || tools.Uint32SliceContains(m.StoreId, data.StoreId)) &&
 				(len(m.CommodityName) == 0 || tools.StringSliceContains(m.CommodityName, data.CommodityName)) &&
-				(len(m.CategoryID) == 0 || tools.Uint32SliceContains(m.CategoryID, allData[i].CategoryID)) &&
+				(len(m.CategoryID) == 0 || tools.Uint32SliceContains(categoryList, allData[i].CategoryID)) &&
 				(m.Type == 0 || m.Type == data.Type) &&
 				((m.StartTime == "" && m.EndTime == "") || (data.StockTime.After(startTime) && data.StockTime.Before(endTime))) {
 				if data.Type == 3 || data.Type == 4 { // 系统出库、盘点出库

app/admin/models/purchase.go

@@ -3461,6 +3461,16 @@ func getReportByOrderFromCommon(req *ErpPurchaseReportByOrderReq, c *gin.Context
 		//parse = parse.AddDate(0, 0, 1)
 		qs = qs.Where("erp_purchase_order.audit_time < ?", parse)
 	}
+	if req.ErpCommodityName != "" { // 商品名称
+		qs = qs.Where("erp_purchase_commodity.erp_commodity_name=?", req.ErpCommodityName)
+	}
+	if req.ErpCategoryID != 0 { // 商品分类
+		categoryInfo, err := GetErpCategory(req.ErpCategoryID)
+		if err != nil {
+			return nil, err
+		}
+		qs = qs.Where("erp_purchase_commodity.commodity_serial_number LIKE ?", categoryInfo.Number+"%")
+	}
 
 	var count int64
 	err := qs.Distinct("erp_purchase_order.id").Count(&count).Error
@@ -3645,18 +3655,30 @@ func getOrderInventorySumData(req *ErpPurchaseReportByOrderReq) (float64, int32,
 // 查询采购订单的入库信息
 func getOrderInventoryInfo(req *ErpPurchaseReportByOrderReq, erpPurchaseOrderId uint32) ([]ErpPurchaseCommodityData, float64, int32, error) {
 	var inventoryList []ErpPurchaseInventory
-	err := orm.Eloquent.Table("erp_purchase_inventory").
+	qs := orm.Eloquent.Table("erp_purchase_inventory").
-		Where("erp_purchase_order_id = ?", erpPurchaseOrderId).
+		Where("erp_purchase_order_id = ?", erpPurchaseOrderId)
-		Find(&inventoryList).Error
+
+	if req.ErpCommodityName != "" { // 商品名称
+		qs = qs.Where("erp_commodity_name=?", req.ErpCommodityName)
+	}
+	if req.ErpCategoryID != 0 { // 商品分类
+		categoryInfo, err := GetErpCategory(req.ErpCategoryID)
+		if err != nil {
+			return nil, 0, 0, err
+		}
+		qs = qs.Where("commodity_serial_number LIKE ?", categoryInfo.Number+"%")
+	}
+
+	err := qs.Find(&inventoryList).Error
 	if err != nil {
 		logger.Error("getOrderInventoryInfo err:", logger.Field("err", err))
 		return nil, 0, 0, err
 	}
 
-	if len(inventoryList) == 0 {
+	//if len(inventoryList) == 0 {
-		//return nil, 0, 0, errors.New("未查询到采购订单的入库信息")
+	//	//return nil, 0, 0, errors.New("未查询到采购订单的入库信息")
-		return nil, 0, 0, nil
+	//	return nil, 0, 0, nil
-	}
+	//}
 
 	// 使用 map 来组合相同 ErpCommodityId 的数据
 	commodityMap := make(map[uint32]ErpPurchaseCommodityData)
@@ -3668,13 +3690,13 @@ func getOrderInventoryInfo(req *ErpPurchaseReportByOrderReq, erpPurchaseOrderId
 		var vCount int32
 		var vAmount float64
 
-		// 商品名称和分类筛选
+		//// 商品名称和分类筛选
-		if req.ErpCommodityName != "" && v.ErpCommodityName != req.ErpCommodityName {
+		//if req.ErpCommodityName != "" && v.ErpCommodityName != req.ErpCommodityName {
-			continue
+		//	continue
-		}
+		//}
-		if req.ErpCategoryID != 0 && v.ErpCategoryID != req.ErpCategoryID {
+		//if req.ErpCategoryID != 0 && v.ErpCategoryID != req.ErpCategoryID {
-			continue
+		//	continue
-		}
+		//}
 
 		if v.PurchaseType == ErpRejectOrder { // 退货单金额和数量取负值
 			vAmount = -v.Amount
@@ -3709,6 +3731,43 @@ func getOrderInventoryInfo(req *ErpPurchaseReportByOrderReq, erpPurchaseOrderId
 		nCount += vCount
 	}
 
+	if len(inventoryList) == 0 { // 没有入库信息，默认展示商品名称和分类
+		es := orm.Eloquent.Table("erp_purchase_commodity").
+			Where("erp_purchase_order_id = ?", erpPurchaseOrderId)
+
+		if req.ErpCommodityName != "" { // 商品名称
+			es = es.Where("erp_commodity_name=?", req.ErpCommodityName)
+		}
+		if req.ErpCategoryID != 0 { // 商品分类
+			categoryInfo, err := GetErpCategory(req.ErpCategoryID)
+			if err != nil {
+				return nil, 0, 0, err
+			}
+			es = es.Where("commodity_serial_number LIKE ?", categoryInfo.Number+"%")
+		}
+
+		var commodityList []ErpPurchaseCommodity
+		err = es.Find(&commodityList).Error
+		if err != nil {
+			return nil, 0, 0, err
+		}
+
+		for _, v := range commodityList {
+			commodityMap[v.ErpCommodityId] = ErpPurchaseCommodityData{
+				CommodityData: CommodityData{
+					ErpCommodityId:   v.ErpCommodityId,
+					ErpCommodityName: v.ErpCommodityName,
+					ErpCategoryID:    v.ErpCategoryID,
+					ErpCategoryName:  v.ErpCategoryName,
+				},
+				Amount: 0,
+				Price:  0,
+				Count:  0,
+			}
+		}
+
+	}
+
 	// 将 map 中的值转换为 slice
 	var resp []ErpPurchaseCommodityData
 	for _, data := range commodityMap {
@@ -4180,24 +4239,25 @@ func getReportByCommodityFromCommon(req *ErpPurchaseReportByCommodityReq, c *gin
 		PageSize:  req.PageSize,
 	}
 	qs := orm.Eloquent.Table("erp_purchase_order").
+		Joins("JOIN erp_purchase_commodity ON erp_purchase_order.id = erp_purchase_commodity.erp_purchase_order_id").
 		Where("state NOT IN (?, ?)", ErpPurchaseOrderUnAudit, ErpPurchaseOrderEnd)
 	if req.SerialNumber != "" { // 单据编号
-		qs = qs.Where("serial_number=?", req.SerialNumber)
+		qs = qs.Where("erp_purchase_order.serial_number=?", req.SerialNumber)
 	}
 	if req.PurchaseType != "" { // 采购类型
-		qs = qs.Where("purchase_type=?", req.PurchaseType)
+		qs = qs.Where("erp_purchase_order.purchase_type=?", req.PurchaseType)
 	}
 	if len(req.ErpSupplierId) > 0 { // 供应商复选
-		qs = qs.Where("erp_supplier_id IN (?)", req.ErpSupplierId)
+		qs = qs.Where("erp_purchase_order.erp_supplier_id IN ?", req.ErpSupplierId)
 	}
 	if len(req.StoreId) > 0 { // 门店复选
-		qs = qs.Where("store_id IN (?)", req.StoreId)
+		qs = qs.Where("erp_purchase_order.store_id IN ?", req.StoreId)
 	}
 	if req.HandlerId != 0 { // 经手人id
-		qs = qs.Where("handler_id=?", req.HandlerId)
+		qs = qs.Where("erp_purchase_order.handler_id=?", req.HandlerId)
 	}
 	if req.State != 0 { // 订单状态
-		qs = qs.Where("state=?", req.State)
+		qs = qs.Where("erp_purchase_order.state=?", req.State)
 	}
 	if req.AuditTimeStart != "" { // 审核开始时间
 		parse, err := time.Parse(QueryTimeFormat, req.AuditTimeStart)
@@ -4205,7 +4265,7 @@ func getReportByCommodityFromCommon(req *ErpPurchaseReportByCommodityReq, c *gin
 			logger.Errorf("erpPurchaseOrderList err:", err)
 			return nil, err
 		}
-		qs = qs.Where("audit_time > ?", parse)
+		qs = qs.Where("erp_purchase_order.audit_time > ?", parse)
 	}
 	if req.AuditTimeEnd != "" { // 审核结束时间
 		parse, err := time.Parse(QueryTimeFormat, req.AuditTimeEnd)
@@ -4214,25 +4274,37 @@ func getReportByCommodityFromCommon(req *ErpPurchaseReportByCommodityReq, c *gin
 			return nil, err
 		}
 		//parse = parse.AddDate(0, 0, 1)
-		qs = qs.Where("audit_time < ?", parse)
+		qs = qs.Where("erp_purchase_order.audit_time < ?", parse)
+	}
+
+	if req.ErpCommodityName != "" { // 商品名称
+		qs = qs.Where("erp_purchase_commodity.erp_commodity_name=?", req.ErpCommodityName)
+	}
+	if req.ErpCategoryID != 0 { // 商品分类
+		categoryInfo, err := GetErpCategory(req.ErpCategoryID)
+		if err != nil {
+			return nil, err
+		}
+		qs = qs.Where("erp_purchase_commodity.commodity_serial_number LIKE ?", categoryInfo.Number+"%")
 	}
 
 	var count int64
-	err := qs.Count(&count).Error
+	err := qs.Distinct("erp_purchase_order.id").Count(&count).Error
 	if err != nil {
 		logger.Error("getReportByOrderFromCommon count err:", logger.Field("err", err))
 		return resp, err
 	}
 
 	var orders []ErpPurchaseOrder
-	err = qs.Order("id DESC").Find(&orders).Error
+	err = qs.Order("erp_purchase_order.id DESC").Distinct("erp_purchase_order.*").Find(&orders).Error
 	if err != nil && err != RecordNotFound {
 		logger.Error("getReportByOrderFromCommon erp_purchase_order err:", logger.Field("err", err))
 		return resp, err
 	}
 
 	// 查询所有商品id及其对应的orderId
-	commodityAndOrderIdMap, err := getAllOrderCommodity(page, req.PageSize, int(req.IsExport))
+	//commodityAndOrderIdMap, err := getAllOrderCommodity(page, req.PageSize, int(req.IsExport))
+	commodityAndOrderIdMap, err := getAllOrderCommodity(req)
 	if err != nil {
 		return nil, err
 	}
@@ -4305,13 +4377,13 @@ func getReportByCommodityFromCommon(req *ErpPurchaseReportByCommodityReq, c *gin
 	for _, tempDataList := range tempDataMap {
 		var reportData ReportByCommodityData
 		for _, v := range tempDataList {
-			// 商品名称和分类筛选
+			//// 商品名称和分类筛选
-			if req.ErpCommodityName != "" && v.ErpCommodityName != req.ErpCommodityName {
+			//if req.ErpCommodityName != "" && v.ErpCommodityName != req.ErpCommodityName {
-				continue
+			//	continue
-			}
+			//}
-			if req.ErpCategoryID != 0 && v.ErpCategoryID != req.ErpCategoryID {
+			//if req.ErpCategoryID != 0 && v.ErpCategoryID != req.ErpCategoryID {
-				continue
+			//	continue
-			}
+			//}
 
 			reportData.ErpCategoryID = v.ErpCategoryID
 			reportData.ErpCategoryName = v.ErpCategoryName
@@ -4700,34 +4772,102 @@ LEFT JOIN
 //}
 
 // 查询所有商品信息，每页展示不同商品ID及其对应的订单ID
-func getAllOrderCommodity(pageIndex, pageSize, isExport int) (map[uint32][]uint32, error) {
+//func getAllOrderCommodity(req *ErpPurchaseReportByCommodityReq) (map[uint32][]uint32, error) {
-	var commodityMap = make(map[uint32][]uint32)
+//	var commodityMap = make(map[uint32][]uint32)
-	var query string
+//	var query string
-	//	if isExport == 1 { //导出excel
+//
 //	// 执行原生 SQL 查询，联结表格，按照每个商品ID列出所有的订单ID
 //	query = fmt.Sprintf(`
 //        SELECT erp_commodity_id, GROUP_CONCAT(erp_purchase_order_id) AS order_ids FROM erp_purchase_commodity
 //GROUP BY erp_commodity_id`)
-	//	} else {
+//
-	//		// 执行原生 SQL 查询，联结表格，按照每个商品ID列出所有的订单ID
+//	rows, err := orm.Eloquent.Raw(query).Rows()
-	//		query = fmt.Sprintf(`
+//	if err != nil {
-	//        SELECT erp_commodity_id, GROUP_CONCAT(erp_purchase_order_id) AS order_ids FROM erp_purchase_commodity
+//		logger.Error("getAllOrderCommodity erp_purchase_commodity err:", logger.Field("err", err))
-	//GROUP BY erp_commodity_id
+//		return nil, err
-	//        LIMIT %d OFFSET %d`, pageSize, pageIndex*pageSize)
+//	}
+//	defer rows.Close()
+//
+//	for rows.Next() {
+//		var commodityID uint32
+//		var orderIDs string
+//		if err := rows.Scan(&commodityID, &orderIDs); err != nil {
+//			logger.Error("getAllOrderCommodity rows scan err:", logger.Field("err", err))
+//			return nil, err
+//		}
+//
+//		// 将 orderIDs 字符串拆分为字符串数组
+//		orderIDStrList := strings.Split(orderIDs, ",")
+//
+//		// 去重并转换为 uint32 数组
+//		var orderIDList []uint32
+//		seen := make(map[uint32]bool)
+//		for _, idStr := range orderIDStrList {
+//			id, err := strconv.ParseUint(idStr, 10, 32)
+//			if err != nil {
+//				logger.Error("getAllOrderCommodity parse orderID err:", logger.Field("err", err))
+//				return nil, err
+//			}
+//
+//			// 如果该订单ID未被添加过，则添加到列表中
+//			if _, ok := seen[uint32(id)]; !ok {
+//				orderIDList = append(orderIDList, uint32(id))
+//				seen[uint32(id)] = true
+//			}
+//		}
+//
+//		// 添加到 map 中
+//		commodityMap[commodityID] = orderIDList
+//	}
+//
+//	return commodityMap, nil
 //}
 
-	// 执行原生 SQL 查询，联结表格，按照每个商品ID列出所有的订单ID
+func getAllOrderCommodity(req *ErpPurchaseReportByCommodityReq) (map[uint32][]uint32, error) {
-	query = fmt.Sprintf(`
+	var commodityMap = make(map[uint32][]uint32)
-        SELECT erp_commodity_id, GROUP_CONCAT(erp_purchase_order_id) AS order_ids FROM erp_purchase_commodity 
+	var queryBuilder strings.Builder
-GROUP BY erp_commodity_id`)
 
-	rows, err := orm.Eloquent.Raw(query).Rows()
+	// Construct the base query
+	queryBuilder.WriteString(`
+        SELECT erp_commodity_id, GROUP_CONCAT(erp_purchase_order_id) AS order_ids 
+        FROM erp_purchase_commodity`)
+
+	var args []interface{}
+	// Add conditions if provided
+	if req.ErpCommodityName != "" {
+		queryBuilder.WriteString(" WHERE erp_commodity_name = ?")
+		args = append(args, req.ErpCommodityName)
+	}
+
+	if req.ErpCategoryID != 0 {
+		// Fetch category info for the serial number prefix
+		categoryInfo, err := GetErpCategory(req.ErpCategoryID)
+		if err != nil {
+			return nil, err
+		}
+		if req.ErpCommodityName != "" {
+			queryBuilder.WriteString(" AND commodity_serial_number LIKE ?")
+		} else {
+			queryBuilder.WriteString(" WHERE commodity_serial_number LIKE ?")
+		}
+
+		args = append(args, categoryInfo.Number+"%")
+	}
+
+	// Group by commodity ID
+	queryBuilder.WriteString(" GROUP BY erp_commodity_id")
+	// Prepare query with conditions
+	query := queryBuilder.String()
+
+	// Execute the query
+	rows, err := orm.Eloquent.Raw(query, args...).Rows()
 	if err != nil {
 		logger.Error("getAllOrderCommodity erp_purchase_commodity err:", logger.Field("err", err))
 		return nil, err
 	}
 	defer rows.Close()
 
+	// Process the query results
 	for rows.Next() {
 		var commodityID uint32
 		var orderIDs string
@@ -4736,10 +4876,8 @@ GROUP BY erp_commodity_id`)
 			return nil, err
 		}
 
-		// 将 orderIDs 字符串拆分为字符串数组
+		// Split and deduplicate order IDs
 		orderIDStrList := strings.Split(orderIDs, ",")
-
-		// 去重并转换为 uint32 数组
 		var orderIDList []uint32
 		seen := make(map[uint32]bool)
 		for _, idStr := range orderIDStrList {
@@ -4748,15 +4886,13 @@ GROUP BY erp_commodity_id`)
 				logger.Error("getAllOrderCommodity parse orderID err:", logger.Field("err", err))
 				return nil, err
 			}
-
+			if !seen[uint32(id)] {
-			// 如果该订单ID未被添加过，则添加到列表中
-			if _, ok := seen[uint32(id)]; !ok {
 				orderIDList = append(orderIDList, uint32(id))
 				seen[uint32(id)] = true
 			}
 		}
 
-		// 添加到 map 中
+		// Add to the map
 		commodityMap[commodityID] = orderIDList
 	}
 
@@ -5024,8 +5160,12 @@ func GetReportBySupplier(req *ErpPurchaseReportBySupplierReq, c *gin.Context) (
 	}
 
 	if len(req.ErpCategoryID) > 0 {
-		query = query.Where("erp_purchase_inventory.erp_category_id IN (?)", req.ErpCategoryID)
+		categoryList, err := TransformErpCategoryIds(req.ErpCategoryID)
-		countQuery = countQuery.Where("erp_purchase_inventory.erp_category_id IN (?)", req.ErpCategoryID)
+		if err != nil {
+			return nil, err
+		}
+		query = query.Where("erp_purchase_inventory.erp_category_id IN ?", categoryList)
+		countQuery = countQuery.Where("erp_purchase_inventory.erp_category_id IN ?", categoryList)
 	}
 
 	if req.StartTime != "" { // 入/出库开始时间