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

package bus

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

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

type TreeDbCategoryReq struct {
	DbName     string
	UserId     string
	AssetScope string
}

type TreeDbCategoryResp struct {
	Db                *comm.Database
	UserAssetCategory *comm.DbAssetUserCategory
	UserCategory      *comm.DbCategory
}

type TreeDbReq struct {
	DbName string
}

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

			if len(req.DbName) < 1 || len(req.AssetScope) < 1 {
				return nil, fmt.Errorf("请求参数错误 不能为空")
			}

			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)
			}

			if len(req.UserId) < 1 {
				return &TreeDbCategoryResp{
					Db: enity,
				}, nil
			}

			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, "scope": req.AssetScope},
			}, userAssetCaties)

			if err != nil {
				return nil, err
			}
			return &TreeDbCategoryResp{
				Db:                enity,
				UserAssetCategory: userAssetCaties,
				UserCategory:      userCaties,
			}, nil
		},
	}
}

func RegTreeDbAssetsQuery() *comm.NatsMsgReplyer {
	return &comm.NatsMsgReplyer{
		Subject: "tree.db.assets",
		Entity:  func() interface{} { return &TreeDbReq{} },
		Cb2: func(msg *nats.Msg, entity interface{}) (interface{}, error) {
			req, ok := entity.(*TreeDbReq)
			if !ok {
				return nil, fmt.Errorf("参数错误")
			}
			if len(req.DbName) < 1 {
				return nil, fmt.Errorf("请求参数错误 不能为空")
			}
			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{"assets"},
			}, enity)
			if !ok {
				return nil, fmt.Errorf("没有查询到数据库:%s", req.DbName)
			}
			return enity, nil
		},
	}
}

type TreeDbUpdateReq struct {
	DbName string
	Db     *comm.Database
}

func RegTreeDbAssetsUpdate() *comm.NatsMsgReplyer {
	return &comm.NatsMsgReplyer{
		Subject: "tree.db.assets.update",
		Entity:  func() interface{} { return &TreeDbUpdateReq{} },
		Cb2: func(msg *nats.Msg, entity interface{}) (interface{}, error) {
			req, ok := entity.(*TreeDbUpdateReq)
			if !ok {
				return nil, fmt.Errorf("参数错误")
			}
			if len(req.DbName) < 1 || req.Db == nil {
				return nil, fmt.Errorf("请求参数错误 不能为空")
			}

			var CreateRepoCtx = func() *repo.RepoSession {
				return &repo.RepoSession{
					Ctx:    context.Background(),
					Client: db.MongoClient,
				}
			}
			update := bson.M{"$set": bson.M{"assets": req.Db.Assets}}
			_, err := repo.RepoUpdateSetDocProps(CreateRepoCtx(),
				repo.CollectionDatabase,
				req.Db.Id.Hex(), update)

			return nil, err
		},
	}
}

type UpdateDbCateReq struct {
	DbName string
	Cate   *comm.DbCategory
}

func RegTreeDbCategoriesUpdate() *comm.NatsMsgReplyer {
	return &comm.NatsMsgReplyer{
		Subject: "tree.db.category.update",
		Entity:  func() interface{} { return &UpdateDbCateReq{} },
		Cb2: func(msg *nats.Msg, entity interface{}) (interface{}, error) {
			req, ok := entity.(*UpdateDbCateReq)
			if !ok {
				return nil, fmt.Errorf("参数错误")
			}
			if len(req.DbName) < 1 || req.Cate == nil {
				return nil, fmt.Errorf("请求参数错误 不能为空")
			}

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

			dbtree := &comm.DbCategory{}
			ok, _ = repo.RepoSeachDoc(CreateRepoCtx(), &repo.DocSearchOptions{
				CollectName: repo.CollectionDatabase,
				Project:     []string{"_id"},
				Query:       repo.Map{"name": req.DbName},
			}, dbtree)
			if !ok {
				return nil, fmt.Errorf("没有对应的数据库")
			}

			update := bson.M{"$set": bson.M{"categories": req.Cate}}
			_, err := repo.RepoUpdateSetDocProps(CreateRepoCtx(),
				repo.CollectionDatabase,
				dbtree.Id.Hex(), update)

			return nil, err
		},
	}
}