hangzhou_mat_manage/tree/assetcenter/bus/tree-query.go

package bus

import (
	"assetcenter/db/repo"
	"encoding/json"
	"fmt"

	"go.mongodb.org/mongo-driver/bson"
	"infish.cn/comm"
)

type IteChildren func(n *comm.CategoryNode) []string
type FindChild func(n *comm.CategoryNode, id string) []string

func FindCategoryIds(c *comm.DbCategory, parents []string) ([]string, [][]string) {
	out := []string{}
	andOut := [][]string{}
	var allChildren IteChildren
	allChildren = func(n *comm.CategoryNode) []string {
		ids := []string{}
		if n == nil {
			return ids
		}
		ids = append(ids, n.Id)
		if n.Children != nil {
			for _, c := range n.Children {
				cids := allChildren(c)
				if len(cids) > 0 {
					ids = append(ids, cids...)
				}
			}
		}
		return ids
	}
	var findChildrens FindChild
	findChildrens = func(n *comm.CategoryNode, id string) []string {
		ids := []string{}
		if n == nil {
			return ids
		}

		if n.Id == id {
			ids = allChildren(n)
			return ids
		}

		if n.Children == nil {
			return ids
		}

		//查找孩子节点
		for _, c := range n.Children {
			ids = findChildrens(c, id)
			if len(ids) > 0 {
				break
			}
		}
		return ids
	}
	for _, v := range parents {
		for _, catnode := range c.Categories {
			extends := findChildrens(catnode, v)
			if len(extends) > 0 {
				andOut = append(andOut, extends)
				out = append(out, extends...)
				break
			}
		}
	}
	return out, andOut
}

func ParseCategories(query map[string]interface{}, repoSession *repo.RepoSession, dbConf *comm.AssetDbConf) error {

	filters := []bson.M{}
	keyfilters := []bson.M{}
	//keyword
	if query["keyword"] != nil {
		keyword := query["keyword"].(string)
		if len(keyword) > 0 {
			keyfilters = append(keyfilters, bson.M{"name": bson.M{"$regex": keyword, "$options": "$i"}})
			keyfilters = append(keyfilters, bson.M{"cusNum": bson.M{"$regex": keyword, "$options": "$i"}})
			filters = append(filters, bson.M{"$or": keyfilters})
		}
		query["keyword"] = nil
	}

	if query["cusCategories"] != nil && query["cateId"] != nil {

		categories := query["categories"].([]interface{})

		cateId := query["cateId"].(string)
		//查询所有子内容
		if len(categories) > 0 {
			cateConf := &comm.DbCategory{}
			filterCaties := []string{}
			//查询用户的
			ok, _ := repo.RepoSeachDoc(repoSession, &repo.DocSearchOptions{CollectName: repo.CollectionCategories, Query: repo.Map{"_id": cateId}}, cateConf)
			if !ok {
				return fmt.Errorf("cate get error")
			}

			for _, c := range categories {
				if c != nil {
					if str, ok := c.(string); ok {
						filterCaties = append(filterCaties, str)
					}
				}

			}
			extends, _ := FindCategoryIds(cateConf, filterCaties)
			if len(extends) > 0 {
				filter := bson.M{"categories": bson.M{"$elemMatch": bson.M{"$in": extends}}}
				filters = append(filters, filter)
			}
		}
		query["cusCategories"] = nil
		query["cateId"] = nil
	}

	if query["cusCategories"] != nil && query["cateConfJson"] != nil {
		categories := query["cusCategories"].([]interface{})
		cnfJson := query["cateConfJson"].(string)
		if len(cnfJson) > 0 {
			cateConf := &comm.DbCategory{}
			err := json.Unmarshal([]byte(cnfJson), cateConf)
			if err != nil {
				return fmt.Errorf("parse cateConfJson string error")
			}

			// filterCaties := []string{}
			for _, c := range categories { //每个对于一种分类
				currCate := c.(string)
				if len(currCate) > 0 {
					extends, _ := FindCategoryIds(cateConf, []string{currCate})
					if len(extends) > 0 {
						filter := bson.M{"cusCategories": bson.M{"$elemMatch": bson.M{"$in": extends}}}
						filters = append(filters, filter)
					}
				}
				// filterCaties = append(filterCaties, c.(string))
			}
			// extends := FindCategoryIds(cateConf, filterCaties)
			// if len(extends) > 0 {
			// 	filter := bson.M{"cusCategories": bson.M{"$elemMatch": bson.M{"$in": extends}}}
			// 	filters = append(filters, filter)
			// }
		}
		query["cusCategories"] = nil
		query["cateConfJson"] = nil
	}

	if query["categories"] != nil && dbConf.Db.Categories != nil {

		categories := query["categories"].([]interface{})
		delete(query, "categories")

		//查询所有子内容
		if len(categories) > 0 {
			cateConf := dbConf.Db.Categories
			filterCaties := []string{}

			for _, c := range categories {
				if c != nil {
					if str, ok := c.(string); ok {
						filterCaties = append(filterCaties, str)
					}
				}
			}
			oldextends, andExtends := FindCategoryIds(cateConf, filterCaties)
			// extends, andExtends := FindCategoryIds(cateConf, filterCaties)
			// if len(extends) > 0 {
			// 	filter := bson.M{"categories": bson.M{"$elemMatch": bson.M{"$in": extends}}}
			// 	filters = append(filters, filter)
			// }
			fmt.Println("old and :=============================================")
			fmt.Println(oldextends)
			fmt.Println(andExtends)
			// todo待测试
			// !多个分类筛选，包含在所有分类中
			andArrayCons := []bson.M{}
			// if len(andExtends) > 0 {
			// 	for _, cateCon := range andExtends {
			// 		if len(cateCon) > 0 {
			// 			andArrayCons = append(andArrayCons, bson.M{"categories": bson.M{"$elemMatch": bson.M{"$in": cateCon}}})
			// 		}
			// 	}
			// 	// !20250102 fix
			// 	if len(andArrayCons) > 0 {
			// 		filters = append(filters, bson.M{"$and": andArrayCons})
			// 	}
			// } else {
			// 	// !20250102 fix
			// 	// 如果没有子分类 传递的categories是叶子分类
			// 	query["categories"] = bson.M{"$elemMatch": bson.M{"$in": filterCaties}}

			// }
			if len(andExtends) > 0 {
				for _, cateCon := range andExtends {
					if len(cateCon) > 0 {
						andArrayCons = append(andArrayCons, bson.M{"categories": bson.M{"$elemMatch": bson.M{"$in": cateCon}}})
					}
				}
			}
			if len(andArrayCons) > 0 {
				filters = append(filters, bson.M{"$and": andArrayCons})
			}

		}
		// query["categories"] = nil

	}

	if len(filters) > 0 {
		query["$and"] = filters
	}
	fmt.Println("分类条件:==========================================>")
	fmt.Printf("%#v\n", query)

	return nil
}