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

package bus

import (
	"assetcenter/db"
	"assetcenter/db/repo"
	"context"
	"fmt"
	"time"

	"github.com/nats-io/nats.go"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"infish.cn/comm"
)

type TreeQueryDbCategoryReq struct {
	DefineCollection string
	DbName           string
	UserId           string
	AssetScope       string
}

func RegTreeCategoryQuery() *comm.NatsMsgReplyer {
	return &comm.NatsMsgReplyer{
		Subject: "tree.category.query",
		Entity:  func() interface{} { return &TreeQueryDbCategoryReq{} },
		Cb2: func(msg *nats.Msg, entity interface{}) (interface{}, error) {
			req, ok := entity.(*TreeQueryDbCategoryReq)
			if !ok {
				return nil, fmt.Errorf("参数错误")
			}

			if len(req.DbName) < 1 || len(req.DefineCollection) < 1 {
				return nil, fmt.Errorf("DbName 或 DefineName 不能为空")
			}

			var CreateRepoCtx = func() *repo.RepoSession {
				return &repo.RepoSession{
					Ctx:    context.Background(),
					Client: db.MongoClient,
				}
			}
			enity := &comm.Database{}
			ok, _ = repo.RepoSeachDoc(CreateRepoCtx(), &repo.DocSearchOptions{
				CollectName: repo.CollectionDatabase,
				Query:       repo.Map{"name": req.DbName},
				Project:     []string{"categories", "assets"},
			}, enity)
			if !ok {
				return nil, fmt.Errorf("没有查询到数据库:%s", req.DbName)
			}

			defineId := ""
			for _, a := range enity.Assets {
				if a.Collection == req.DefineCollection {
					defineId = a.Id
					break
				}
			}
			if len(defineId) < 1 {
				return nil, fmt.Errorf("没有查询到%s的定义", req.DefineCollection)
			}

			if len(req.UserId) > 0 && len(req.AssetScope) > 0 { //自定义分类
				userCaties := &comm.DbCategory{}
				userId, _ := primitive.ObjectIDFromHex(req.UserId)
				_, err := repo.RepoSeachDoc(CreateRepoCtx(), &repo.DocSearchOptions{
					CollectName: repo.CollectionCategories,
					Query:       repo.Map{"userId": userId, "scope": req.AssetScope},
				}, userCaties)
				if err != nil {
					return nil, err
				}
				userAssetCaties := &comm.DbAssetUserCategory{}
				_, err = repo.RepoSeachDoc(CreateRepoCtx(), &repo.DocSearchOptions{
					CollectName: repo.CollectionDbAssetCategory,
					Query:       repo.Map{"userId": userId},
				}, userAssetCaties)

				if err != nil {
					return nil, err
				}

				cates := &comm.DbCategory{}
				for _, v := range userAssetCaties.CategoryConfs {
					if v.DbAssetId.Hex() == defineId {
						for _, id := range v.CategoryIds {
							for _, c := range userCaties.Categories {
								if c.Id == id {
									cates.Categories = append(cates.Categories, c)
									break
								}
							}
						}
					}
				}
				return cates, nil
			}
			if len(req.DbName) < 1 {
				return nil, fmt.Errorf("DbName不能为空")
			}

			cates := &comm.DbCategory{}
			for _, v := range enity.Assets {
				if v.Id != defineId {
					continue
				}
				for _, id := range v.CategoryIds {
					for _, c := range enity.Categories.Categories {
						if c.Id == id {
							cates.Categories = append(cates.Categories, c)
							break
						}
					}
				}
			}
			return cates, nil
		},
	}
}

func RegTreeUserCategoryUpdate() *comm.NatsMsgReplyer {
	return &comm.NatsMsgReplyer{
		Subject: "tree.user.category.update",
		Entity:  func() interface{} { return &comm.DbCategory{} },
		Cb2: func(msg *nats.Msg, entity interface{}) (interface{}, error) {
			req, ok := entity.(*comm.DbCategory)
			if !ok {
				return nil, fmt.Errorf("参数错误")
			}

			var CreateRepoCtx = func() *repo.RepoSession {
				return &repo.RepoSession{
					Ctx:    context.Background(),
					Client: db.MongoClient,
				}
			}

			curr := &comm.DbCategory{}
			ok, err := repo.RepoSeachDoc(CreateRepoCtx(), &repo.DocSearchOptions{
				CollectName: repo.CollectionCategories,
				Project:     []string{"_id"},
				Query:       repo.Map{"userId": req.UserId, "scope": req.Scope},
			}, curr)
			if err != nil {
				return nil, err
			}

			if !ok { //没有查询到新增
				id, err := repo.RepoAddDoc(CreateRepoCtx(), repo.CollectionCategories, req)
				if err != nil {
					return nil, err
				}
				req.Id, _ = primitive.ObjectIDFromHex(id)
				return req, nil
			}
			req.Id = primitive.NilObjectID

			return repo.RepoUpdateSetDoc(CreateRepoCtx(), repo.CollectionCategories, curr.Id.Hex(), req)
		},
	}
}

func RegTreeUserAssetCategoryUpdate() *comm.NatsMsgReplyer {
	return &comm.NatsMsgReplyer{
		Subject: "tree.user.assetCategory.update",
		Entity:  func() interface{} { return &comm.DbAssetUserCategory{} },
		Cb2: func(msg *nats.Msg, entity interface{}) (interface{}, error) {
			req, ok := entity.(*comm.DbAssetUserCategory)
			if !ok {
				return nil, fmt.Errorf("参数错误")
			}

			var CreateRepoCtx = func() *repo.RepoSession {
				return &repo.RepoSession{
					Ctx:    context.Background(),
					Client: db.MongoClient,
				}
			}

			curr := &comm.DbAssetUserCategory{}
			ok, err := repo.RepoSeachDoc(CreateRepoCtx(), &repo.DocSearchOptions{
				CollectName: repo.CollectionDbAssetCategory,
				Project:     []string{"_id"},
				Query:       repo.Map{"userId": req.UserId, "scope": req.Scope},
			}, curr)
			if err != nil {
				return nil, err
			}

			if !ok { //没有查询到新增
				req.CreateTime = time.Now()
				req.UpdateTime = time.Now()
				id, err := repo.RepoAddDoc(CreateRepoCtx(), repo.CollectionDbAssetCategory, req)
				if err != nil {
					return nil, err
				}
				req.Id, _ = primitive.ObjectIDFromHex(id)
				return true, nil
			}

			req.Id = primitive.NilObjectID
			req.UpdateTime = time.Now()
			req.CreateTime = curr.CreateTime
			_, err = repo.RepoUpdateSetDoc(CreateRepoCtx(), repo.CollectionDbAssetCategory, curr.Id.Hex(), req)

			return true, err
		},
	}
}

type TreeUserAssetCateReq struct {
	UserId string
	Scope  string
}

func RegTreeUserAssetCategoryQuery() *comm.NatsMsgReplyer {
	return &comm.NatsMsgReplyer{
		Subject: "tree.user.assetCategory.query",
		Entity:  func() interface{} { return &TreeUserAssetCateReq{} },
		Cb2: func(msg *nats.Msg, entity interface{}) (interface{}, error) {
			req, ok := entity.(*TreeUserAssetCateReq)
			if !ok {
				return nil, fmt.Errorf("参数错误")
			}

			var CreateRepoCtx = func() *repo.RepoSession {
				return &repo.RepoSession{
					Ctx:    context.Background(),
					Client: db.MongoClient,
				}
			}
			uid, _ := primitive.ObjectIDFromHex(req.UserId)
			curr := &comm.DbAssetUserCategory{}
			_, err := repo.RepoSeachDoc(CreateRepoCtx(), &repo.DocSearchOptions{
				CollectName: repo.CollectionDbAssetCategory,
				Query:       repo.Map{"userId": uid, "scope": req.Scope},
			}, curr)
			if err != nil {
				return nil, err
			}
			return curr, nil
		},
	}
}