test

queencount/Dockerfile

@@ -10,13 +10,13 @@ RUN echo -e https://mirrors.ustc.edu.cn/alpine/v3.15/main > /etc/apk/repositorie
 # 由于alpine镜像使用的是musl libc而不是gnu libc，/lib64/ 是不存在的。但他们是兼容的，可以创建个软连接
   && mkdir /lib64 \
   && ln -s /lib/libc.musl-x86_64.so.1 /lib64/ld-linux-x86-64.so.2 \
-  && mkdir -p /root/queentree
+  && mkdir -p /root/queencount
 
-WORKDIR /root/queentree
+WORKDIR /root/queencount
 
 ADD ./app.yaml ./app.yaml
-ADD ./tree-service ./tree-service
+ADD ./queencount-service ./queencount-service
 
 EXPOSE 8902
 
-ENTRYPOINT ["./tree-service"]
+ENTRYPOINT ["./queencount-service"]

queencount/api/service-asset-count.backup

@@ -1,511 +0,0 @@
-// package api
-
-// import (
-// 	"queencount/db/model"
-// 	"queencount/db/repo"
-// 	"errors"
-// 	"fmt"
-// 	"time"
-
-// 	"github.com/gin-gonic/gin"
-// )
-
-// func AssetCount(router *GinRouter) {
-// 	router.GETJWT("/count/info", GetAssetCount)
-// 	// 统计总图表
-// 	router.GET("/count/info/chart", GetInfoChart)
-// 	// 定义模型图表
-// 	router.GET("/count/def/chart", GetDefModelChart)
-// 	// 定义模型分类
-// 	router.GET("/count/def/cate", GetDefModelCate)
-// }
-
-// const SKU3D_DB = "sku3d-tree"
-
-// type AssetDefCountInfo struct {
-// 	Mesh     []CountDefItem `json:"mesh"`
-// 	Image    []CountDefItem `json:"image"`
-// 	Material []CountDefItem `json:"material"`
-// 	Env3d    []CountDefItem `json:"env3d"`
-// }
-
-// type CountDefItem struct {
-// 	DefItemNum int    `json:"defItemNum"`
-// 	DefName    string `json:"defName"`
-// 	DefKey     string `json:"defKey"`
-// }
-
-// func GetAssetCount(c *gin.Context, apictx *ApiSession) (interface{}, error) {
-// 	// databases := []string{"mesh", "image", "material", "env3d"}
-// 	// 定义模型数量
-
-// 	query := make(map[string]interface{})
-// 	query["userId"] = apictx.User.ID
-
-// 	option := &repo.DocSearchOptions{
-// 		CollectName: repo.CollectionDatabase,
-// 		Query:       query,
-// 		Project:     []string{"_id", "assets"},
-// 	}
-// 	var datbaseDoc model.Database
-
-// 	found, err := repo.RepoSeachDoc(apictx.CreateRepoCtx(), option, &datbaseDoc)
-// 	if err != nil {
-// 		return nil, err
-// 	}
-// 	if !found {
-// 		return nil, err
-// 	}
-
-// 	var countDefitem CountDefItem
-// 	var assetDefCountInfo AssetDefCountInfo
-
-// 	defMeshSet := make([]CountDefItem, 0)
-// 	defImageSet := make([]CountDefItem, 0)
-// 	defMaterialSet := make([]CountDefItem, 0)
-// 	defEnv3dSet := make([]CountDefItem, 0)
-
-// 	for _, v := range datbaseDoc.Assets {
-// 		// 模型
-// 		if v.Type == 10 {
-// 			countDefitem.DefKey = v.Collection
-// 			countDefitem.DefName = v.Label
-
-// 			parm := &repo.DbDocsSearchOptions{
-// 				Db:          SKU3D_DB,
-// 				Query:       map[string]interface{}{"ownerId": apictx.User.ID},
-// 				CollectName: v.Collection,
-// 				Project:     []string{"_id"},
-// 			}
-
-// 			ok, res := repo.DbRepoSeachDocsMap(apictx.CreateRepoCtx(), parm)
-// 			if ok {
-// 				countDefitem.DefItemNum = len(res)
-// 				defMeshSet = append(defMeshSet, countDefitem)
-// 				assetDefCountInfo.Mesh = defMeshSet
-// 			}
-
-// 		}
-// 		if v.Type == 20 {
-// 			countDefitem.DefKey = v.Collection
-// 			countDefitem.DefName = v.Label
-
-// 			parm := &repo.DbDocsSearchOptions{
-// 				Db:          SKU3D_DB,
-// 				Query:       map[string]interface{}{"ownerId": apictx.User.ID},
-// 				CollectName: v.Collection,
-// 				Project:     []string{"_id"},
-// 			}
-
-// 			ok, res := repo.DbRepoSeachDocsMap(apictx.CreateRepoCtx(), parm)
-// 			if ok {
-// 				countDefitem.DefItemNum = len(res)
-// 				defImageSet = append(defImageSet, countDefitem)
-// 				assetDefCountInfo.Image = defImageSet
-
-// 			}
-
-// 		}
-// 		if v.Type == 30 {
-// 			countDefitem.DefKey = v.Collection
-// 			countDefitem.DefName = v.Label
-
-// 			parm := &repo.DbDocsSearchOptions{
-// 				Db:          SKU3D_DB,
-// 				Query:       map[string]interface{}{"ownerId": apictx.User.ID},
-// 				CollectName: v.Collection,
-// 				Project:     []string{"_id"},
-// 			}
-
-// 			ok, res := repo.DbRepoSeachDocsMap(apictx.CreateRepoCtx(), parm)
-// 			if ok {
-// 				countDefitem.DefItemNum = len(res)
-// 				defMaterialSet = append(defMaterialSet, countDefitem)
-// 				assetDefCountInfo.Material = defMaterialSet
-
-// 			}
-// 		}
-// 		if v.Type == 40 {
-// 			countDefitem.DefKey = v.Collection
-// 			countDefitem.DefName = v.Label
-
-// 			parm := &repo.DbDocsSearchOptions{
-// 				Db:          SKU3D_DB,
-// 				Query:       map[string]interface{}{"ownerId": apictx.User.ID},
-// 				CollectName: v.Collection,
-// 				Project:     []string{"_id"},
-// 			}
-
-// 			ok, res := repo.DbRepoSeachDocsMap(apictx.CreateRepoCtx(), parm)
-// 			if ok {
-// 				countDefitem.DefItemNum = len(res)
-// 				defEnv3dSet = append(defEnv3dSet, countDefitem)
-// 				assetDefCountInfo.Env3d = defEnv3dSet
-
-// 			}
-// 		}
-
-// 	}
-
-// 	return assetDefCountInfo, nil
-
-// }
-
-// // 增量时间段
-// type IncrementDuration struct {
-// 	Start time.Time
-// 	End   time.Time
-// }
-
-// // 增量时间段集合
-// type IncrementTimes []IncrementDuration
-
-// type ReqFrom struct {
-// 	TimeType string `json:"timeType"` // day
-// 	TimeStep string `json:"timeStep"` // 1h
-// }
-
-// type ListItem struct {
-// 	Type string `json:"type"`
-// 	Data []int  `json:"data"`
-// }
-// type ResultData struct {
-// 	Step string      `json:"step"`
-// 	Time []time.Time `json:"time"`
-// 	List []ListItem  `json:"list"`
-// }
-
-// // 步距代表的小时数
-// var step2HourTimes = map[string]int32{"1h": 1, "1d": 24, "1w": 24 * 7, "1M": 24 * 30}
-
-// // 类型代表的小时数
-// var type2HourTimes = map[string]int32{"day": 24, "threeDay": 24, "week": 24 * 30, "month": 30 * 24, "year": 365 * 24, "all": 120 * 24}
-
-// // 获取统计信息图表需要的信息
-// func GetInfoChart(c *gin.Context, apictx *ApiSession) (interface{}, error) {
-// 	var form ReqFrom
-// 	// err := c.ShouldBindJSON(&form)
-// 	// if err != nil {
-// 	// 	return nil, err
-// 	// }
-// 	form.TimeStep = "1h"
-// 	form.TimeType = "day"
-// 	if form.TimeType == "" {
-// 		return nil, errors.New("时间类型不能为空")
-// 	}
-// 	if form.TimeStep == "" {
-// 		return nil, errors.New("时间步距不能为空")
-// 	}
-
-// 	ctx := apictx.CreateRepoCtx()
-// 	userId := apictx.User.ID
-// 	var list ResultData
-
-// 	incrementTimes, timeSet := GetIncrementTimes(form.TimeType, form.TimeStep)
-
-// 	countCollection := "assetcount"
-// 	query := make(map[string]interface{})
-// 	query["userId"] = userId
-
-// 	parm := &repo.DocsSearchOptions{
-// 		CollectName: countCollection,
-// 		Project:     []string{"_id", "productId", "type", "defKey", "defName", "createTime"},
-// 	}
-
-// 	// "mesh"
-// 	var meshItem ListItem
-// 	meshItem.Type = "mesh"
-// 	for _, incrementTime := range incrementTimes {
-// 		// 拼接条件 查询各个增量时间段的数据
-// 		query["$gt"] = incrementTime.Start
-// 		query["$lte"] = incrementTime.End
-// 		query["type"] = "mesh"
-// 		parm.Query = query
-// 		ok, res := repo.RepoSeachDocsMap(ctx, parm)
-// 		if ok {
-// 			meshItem.Data = append(meshItem.Data, len(res))
-// 		}
-// 	}
-// 	list.List = append(list.List, meshItem)
-
-// 	// "image"
-// 	var imageItem ListItem
-// 	imageItem.Type = "image"
-// 	for _, incrementTime := range incrementTimes {
-// 		// 拼接条件 查询各个增量时间段的数据
-// 		query["$gt"] = incrementTime.Start
-// 		query["$lte"] = incrementTime.End
-// 		query["type"] = "image"
-// 		parm.Query = query
-// 		ok, res := repo.RepoSeachDocsMap(ctx, parm)
-// 		if ok {
-// 			imageItem.Data = append(imageItem.Data, len(res))
-// 		}
-// 	}
-// 	list.List = append(list.List, imageItem)
-
-// 	// "material"
-// 	var materialItem ListItem
-// 	materialItem.Type = "material"
-
-// 	for _, incrementTime := range incrementTimes {
-// 		// 拼接条件 查询各个增量时间段的数据
-// 		query["$gt"] = incrementTime.Start
-// 		query["$lte"] = incrementTime.End
-// 		query["type"] = "material"
-// 		parm.Query = query
-// 		ok, res := repo.RepoSeachDocsMap(ctx, parm)
-// 		if ok {
-// 			materialItem.Data = append(materialItem.Data, len(res))
-// 		}
-// 	}
-
-// 	list.List = append(list.List, materialItem)
-
-// 	// "env3d"
-// 	var env3dItem ListItem
-// 	env3dItem.Type = "env3d"
-// 	for _, incrementTime := range incrementTimes {
-// 		// 拼接条件 查询各个增量时间段的数据
-// 		query["$gt"] = incrementTime.Start
-// 		query["$lte"] = incrementTime.End
-// 		query["type"] = "env3d"
-// 		parm.Query = query
-// 		ok, res := repo.RepoSeachDocsMap(ctx, parm)
-// 		if ok {
-// 			env3dItem.Data = append(env3dItem.Data, len(res))
-// 		}
-// 	}
-
-// 	list.List = append(list.List, env3dItem)
-// 	list.Step = form.TimeStep
-// 	list.Time = timeSet
-
-// 	return list, nil
-
-// }
-
-// type ItemCountResult struct {
-// 	Step string      `json:"step"`
-// 	Time []time.Time `json:"time"`
-// 	Data ItemCount   `json:"data"`
-// }
-
-// type ItemCount struct {
-// 	DefKey  string `json:"defKey"`
-// 	DefName string `json:"defName"`
-// 	Data    []int  `json:"data"`
-// }
-
-// // 获取定义模型的统计数据
-// func GetDefModelChart(c *gin.Context, apictx *ApiSession) (interface{}, error) {
-// 	// 接受timeType timeStep type defKey
-// 	var form struct {
-// 		TimeType string `json:"timeType"`
-// 		TimeStep string `json:"timeStep"`
-// 		Type     string `json:"type"`
-// 		DefKey   string `json:"defKey"`
-// 	}
-// 	// err := c.ShouldBindJSON(&form)
-// 	// if err != nil {
-// 	// 	return nil, err
-// 	// }
-// 	form.TimeStep = "1h"
-// 	form.TimeType = "day"
-// 	if form.TimeType == "" {
-// 		return nil, errors.New("时间类型不能为空")
-// 	}
-// 	if form.TimeStep == "" {
-// 		return nil, errors.New("时间步距不能为空")
-// 	}
-// 	if form.Type == "" {
-// 		return nil, errors.New("时间类型不能为空")
-// 	}
-// 	if form.TimeStep == "" {
-// 		return nil, errors.New("时间步距不能为空")
-// 	}
-
-// 	ctx := apictx.CreateRepoCtx()
-// 	userId := apictx.User.ID
-// 	var result ItemCountResult
-// 	var data ItemCount
-// 	data.DefKey = form.DefKey
-
-// 	incrementTimes, timeSet := GetIncrementTimes(form.TimeType, form.TimeStep)
-// 	result.Time = timeSet
-
-// 	countCollection := "assetcount"
-// 	query := make(map[string]interface{})
-// 	query["userId"] = userId
-
-// 	parm := &repo.DocsSearchOptions{
-// 		CollectName: countCollection,
-// 		Project:     []string{"_id", "productId", "type", "defKey", "defName", "createTime"},
-// 	}
-
-// 	for _, incrementTime := range incrementTimes {
-// 		// 拼接条件 查询各个增量时间段的数据
-// 		query["$gt"] = incrementTime.Start
-// 		query["$lte"] = incrementTime.End
-// 		query["type"] = form.Type
-// 		query["defKey"] = form.DefKey
-// 		parm.Query = query
-// 		ok, res := repo.RepoSeachDocsMap(ctx, parm)
-// 		if ok {
-// 			data.Data = append(data.Data, len(res))
-// 		}
-// 	}
-// 	result.Data = data
-
-// 	return result, nil
-// }
-
-// type DefInfo struct {
-// 	DefName string `json:"defName"`
-// 	DefKey  string `json:"defKey"`
-// }
-
-// type DefCateInfo struct {
-// 	Mesh     []DefInfo
-// 	Image    []DefInfo
-// 	Material []DefInfo
-// 	Env3d    []DefInfo
-// }
-
-// // 获取用户定义类型分类
-// func GetDefModelCate(c *gin.Context, apictx *ApiSession) (interface{}, error) {
-
-// 	var form struct {
-// 		Name string `json:"name"`
-// 	}
-// 	err := c.ShouldBindJSON(&form)
-// 	if err != nil {
-// 		return nil, errors.New("参数错误")
-// 	}
-// 	if form.Name == "" {
-// 		return nil, errors.New("资产库名不能为空")
-// 	}
-// 	// 查询 database 根据name 和用户id查找用户的asset资产
-// 	// 遍历资产信息，根据type获取对应类型的资产集合
-// 	// 62f05931ae8ddfeb72cf684e sku3d-tree
-// 	var database model.Database
-// 	ctx := apictx.CreateRepoCtx()
-// 	var defCateInfo DefCateInfo
-// 	var defInfo DefInfo
-// 	query := make(map[string]interface{})
-// 	// query["userId"] = apictx.User.ID
-// 	query["userId"] = "62f05931ae8ddfeb72cf684e"
-// 	// query["name"] = form.Name
-// 	query["name"] = "sku3d-tree"
-
-// 	param := &repo.DocSearchOptions{
-// 		CollectName: repo.CollectionDatabase,
-// 		Query:       query,
-// 		Project:     []string{"_id", "assets"},
-// 	}
-// 	ok, err := repo.RepoSeachDoc(ctx, param, &database)
-// 	if err != nil || !ok {
-// 		return nil, errors.New("查询数据错误")
-// 	}
-
-// 	for _, v := range database.Assets {
-// 		if v.Type == 10 {
-// 			defInfo.DefKey = v.Collection
-// 			defInfo.DefName = v.Label
-// 			defCateInfo.Mesh = append(defCateInfo.Mesh, defInfo)
-// 		}
-// 		if v.Type == 20 {
-// 			defInfo.DefKey = v.Collection
-// 			defInfo.DefName = v.Label
-// 			defCateInfo.Image = append(defCateInfo.Image, defInfo)
-// 		}
-// 		if v.Type == 30 {
-// 			defInfo.DefKey = v.Collection
-// 			defInfo.DefName = v.Label
-// 			defCateInfo.Material = append(defCateInfo.Material, defInfo)
-// 		}
-// 		if v.Type == 40 {
-// 			defInfo.DefKey = v.Collection
-// 			defInfo.DefName = v.Label
-// 			defCateInfo.Env3d = append(defCateInfo.Env3d, defInfo)
-// 		}
-
-// 	}
-
-// 	return defCateInfo, nil
-// }
-
-// // 根据时间段进行范围查找
-// // [
-// //     {
-// //         "Start": "2022-10-13T15:35:11.072184706+08:00",
-// //         "End": "2022-10-13T17:35:11.072184706+08:00"
-// //     }
-// // ]
-
-// // 获取当前用户各个资源类型的
-
-// // 	f := bson.M{"orderId": bson.M{"$gte": minId, "$lt": maxId}, "type": item["type"].(string)}
-// // 	filters = append(filters, f)
-
-// // ok, extendsItems := RepoSeachDocsMap(ctx, &DocsSearchOptions{CollectName: CollectionLibCategory, Query: Map{"$or": filters}, Project: []string{"_id"}})
-
-// // 	// return nil, nil
-// // 	今天用mongodb查昨天某个collection产生的记录数量，在mysql里面可以用between..and..或者 >、>=、<、<=来查
-// // 询指定的时间范围数据，但是mongodb有自己的语法。mongodb里比较，用 "$gt" 、"$gte"、 "$lt"、 "$lte"（分别对应">"、 ">=" 、"<" 、"<="），
-// // 组合起来可以进行范围的查找。比如查昨天的，就可以用
-
-// // db.CollectionAAA.find({ "CreateTime" : { "$gte" : ISODate("2017-04-20T00:00:00Z")
-// // , "$lt" : ISODate("2017-04-21T00:00:00Z") } }).count()
-// // 注意，开始的时候日期使用 "2017-04-20" 和"2017-04-21"，但是返回结果为空，应该日期字段需要指定格式吧，看了下存在库里的数据为ISODate类型，所以直接写成ISODate的方式，结果就正常了。
-
-// // }
-
-// // 根据类型/步距 = 时间点个数
-
-// // 获取时间集合 用于统计查询
-// func GetIncrementTimes(timeType string, timeStep string) (incrementTimes IncrementTimes, timeSet []time.Time) {
-// 	// key 对应 时间段 day threeDay ...
-// 	step, ok := step2HourTimes[timeStep]
-// 	if !ok {
-// 		return
-// 	}
-
-// 	typev, ok := type2HourTimes[timeType]
-// 	fmt.Println(typev)
-// 	if !ok {
-// 		return
-// 	}
-
-// 	// 这个类型有多少个记录点
-// 	times := typev/step + 1
-
-// 	now := time.Now() //获取当前时间
-// 	incrementDuration := IncrementDuration{}
-
-// 	// 24小时之前
-// 	// a, _ := time.ParseDuration(fmt.Sprintf("%dh", -counts))
-// 	// start := now.Add(a)
-
-// 	for i := times; i > 0; i-- {
-// 		if timeStep == "1d" {
-// 			i = i * 24
-// 		}
-// 		if timeStep == "1w" {
-// 			i = i * 24 * 7
-// 		}
-// 		if timeStep == "1M" {
-// 			i = i * 24 * 30
-// 		}
-// 		a, _ := time.ParseDuration(fmt.Sprintf("%dh", -i))
-// 		b, _ := time.ParseDuration(fmt.Sprintf("%dh", -i+1))
-// 		start := now.Add(a)
-// 		end := now.Add(b)
-// 		incrementDuration.Start = start
-// 		incrementDuration.End = end
-// 		incrementTimes = append(incrementTimes, incrementDuration)
-// 		timeSet = append(timeSet, end)
-// 	}
-// 	return incrementTimes, timeSet
-
-// }

queencount/api/service-asset-count.go

@@ -8,13 +8,15 @@ import (
 	"time"
 
 	"github.com/gin-gonic/gin"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
 func AssetCount(router *GinRouter) {
 	// 统计总信息
 	router.GET("/count/info/types/:dbId", GetAssetCount)
 	// 统计总图表
-	router.GET("/count/info/chart", GetInfoChart)
+	router.GET("/count/info", GetInfo)
 }
 
 type AssetDefCountInfo struct {
@@ -145,221 +147,27 @@ func GetAssetCount(c *gin.Context, apictx *ApiSession) (interface{}, error) {
 	return assetDefCountInfo, nil
 }
 
-// 增量时间段
-type IncrementDuration struct {
-	Start time.Time
-	End   time.Time
+type CountInfo struct {
+	Mesh     []DefItem `json:"mesh"`
+	Image    []DefItem `json:"image"`
+	Material []DefItem `json:"material"`
+	Env3d    []DefItem `json:"env3d"`
 }
 
-// 增量时间段集合
-type IncrementTimes []IncrementDuration
-
-type ReqFrom struct {
-	TimeType string `json:"timeType"` // day
-	TimeStep string `json:"timeStep"` // 1h
-}
-
-type ListItem struct {
-	Type string `json:"type"`
-	Data []int  `json:"data"`
-}
-type ResultData struct {
-	Step string      `json:"step"`
-	Time []time.Time `json:"time"`
-	List []ListItem  `json:"list"`
-}
-
-// 步距代表的小时数
-var step2HourTimes = map[string]int32{"1h": 1, "1d": 24, "1w": 24 * 7, "1M": 24 * 30}
-
-// 类型代表的小时数
-var type2HourTimes = map[string]int32{"day": 24, "threeDay": 24, "week": 24 * 30, "month": 30 * 24, "year": 365 * 24, "all": 120 * 24}
-
-// 获取统计信息图表需要的信息
-func GetInfoChart(c *gin.Context, _ *ApiSession) (interface{}, error) {
-
-	var form struct {
-		TimeType string
-		DbId     string
-	}
-	err := c.ShouldBindJSON(&form)
-	if err != nil {
-		return nil, errors.New("参数错误")
-	}
-
-	if form.TimeType == "" {
-		return nil, errors.New("时间类型不能为空")
-	}
-	if form.DbId == "" {
-		return nil, errors.New("数据库id不为空")
-	}
-
-	// ctx := apictx.CreateRepoCtx()
-	// userId := apictx.User.ID
-	// var list ResultData
-
-	// incrementTimes, timeSet := GetIncrementTimes(form.TimeType, form.TimeStep)
-
-	query := make(map[string]interface{})
-	query["dbId"] = form.DbId
-
-	// parm := &repo.DocsSearchOptions{
-	// 	CollectName: countCollection,
-	// 	Project:     []string{"_id", "productId", "type", "defKey", "defName", "createTime"},
-	// }
-
-	// // "mesh"
-	// var meshItem ListItem
-	// meshItem.Type = "mesh"
-	// for _, incrementTime := range incrementTimes {
-	// 	// 拼接条件 查询各个增量时间段的数据
-	// 	query["$gt"] = incrementTime.Start
-	// 	query["$lte"] = incrementTime.End
-	// 	query["type"] = "mesh"
-	// 	parm.Query = query
-	// 	ok, res := repo.RepoSeachDocsMap(ctx, parm)
-	// 	if ok {
-	// 		meshItem.Data = append(meshItem.Data, len(res))
-	// 	}
-	// }
-	// list.List = append(list.List, meshItem)
-
-	// // "image"
-	// var imageItem ListItem
-	// imageItem.Type = "image"
-	// for _, incrementTime := range incrementTimes {
-	// 	// 拼接条件 查询各个增量时间段的数据
-	// 	query["$gt"] = incrementTime.Start
-	// 	query["$lte"] = incrementTime.End
-	// 	query["type"] = "image"
-	// 	parm.Query = query
-	// 	ok, res := repo.RepoSeachDocsMap(ctx, parm)
-	// 	if ok {
-	// 		imageItem.Data = append(imageItem.Data, len(res))
-	// 	}
-	// }
-	// list.List = append(list.List, imageItem)
-
-	// // "material"
-	// var materialItem ListItem
-	// materialItem.Type = "material"
-
-	// for _, incrementTime := range incrementTimes {
-	// 	// 拼接条件 查询各个增量时间段的数据
-	// 	query["$gt"] = incrementTime.Start
-	// 	query["$lte"] = incrementTime.End
-	// 	query["type"] = "material"
-	// 	parm.Query = query
-	// 	ok, res := repo.RepoSeachDocsMap(ctx, parm)
-	// 	if ok {
-	// 		materialItem.Data = append(materialItem.Data, len(res))
-	// 	}
-	// }
-
-	// list.List = append(list.List, materialItem)
-
-	// // "env3d"
-	// var env3dItem ListItem
-	// env3dItem.Type = "env3d"
-	// for _, incrementTime := range incrementTimes {
-	// 	// 拼接条件 查询各个增量时间段的数据
-	// 	query["$gt"] = incrementTime.Start
-	// 	query["$lte"] = incrementTime.End
-	// 	query["type"] = "env3d"
-	// 	parm.Query = query
-	// 	ok, res := repo.RepoSeachDocsMap(ctx, parm)
-	// 	if ok {
-	// 		env3dItem.Data = append(env3dItem.Data, len(res))
-	// 	}
-	// }
-
-	// list.List = append(list.List, env3dItem)
-	// list.Step = form.TimeStep
-	// list.Time = timeSet
-
-	// return list, nil
-
-	return nil, nil
+type DefItem struct {
+	DefName string      `json:"defName"`
+	DefKey  string      `json:"defKey"`
+	Time    []CountTime `json:"time"`
 }
-
-type ItemCountResult struct {
-	Step string      `json:"step"`
-	Time []time.Time `json:"time"`
-	Data ItemCount   `json:"data"`
-}
-
-type ItemCount struct {
-	DefKey  string `json:"defKey"`
-	DefName string `json:"defName"`
-	Data    []int  `json:"data"`
-}
-
-// 获取定义模型的统计数据
-func GetDefModelChart(_ *gin.Context, apictx *ApiSession) (interface{}, error) {
-	// 接受timeType timeStep type defKey
-	var form struct {
-		TimeType string `json:"timeType"`
-		TimeStep string `json:"timeStep"`
-		Type     string `json:"type"`
-		DefKey   string `json:"defKey"`
-	}
-	// err := c.ShouldBindJSON(&form)
-	// if err != nil {
-	// 	return nil, err
-	// }
-	form.TimeStep = "1h"
-	form.TimeType = "day"
-	if form.TimeType == "" {
-		return nil, errors.New("时间类型不能为空")
-	}
-	if form.TimeStep == "" {
-		return nil, errors.New("时间步距不能为空")
-	}
-	if form.Type == "" {
-		return nil, errors.New("时间类型不能为空")
-	}
-	if form.TimeStep == "" {
-		return nil, errors.New("时间步距不能为空")
-	}
-
-	ctx := apictx.CreateRepoCtx()
-	userId := apictx.User.ID
-	var result ItemCountResult
-	var data ItemCount
-	data.DefKey = form.DefKey
-
-	incrementTimes, timeSet := GetIncrementTimes(form.TimeType, form.TimeStep)
-	result.Time = timeSet
-
-	countCollection := "assetcount"
-	query := make(map[string]interface{})
-	query["userId"] = userId
-
-	parm := &repo.DocsSearchOptions{
-		CollectName: countCollection,
-		Project:     []string{"_id", "productId", "type", "defKey", "defName", "createTime"},
-	}
-
-	for _, incrementTime := range incrementTimes {
-		// 拼接条件 查询各个增量时间段的数据
-		query["$gt"] = incrementTime.Start
-		query["$lte"] = incrementTime.End
-		query["type"] = form.Type
-		query["defKey"] = form.DefKey
-		parm.Query = query
-		ok, res := repo.RepoSeachDocsMap(ctx, parm)
-		if ok {
-			data.Data = append(data.Data, len(res))
-		}
-	}
-	result.Data = data
-
-	return result, nil
+type CountTime struct {
+	TimePoint time.Time `json:"timePoint"`
+	Count     int       `json:"count"`
 }
 
 type DefInfo struct {
-	DefName string `json:"defName"`
-	DefKey  string `json:"defKey"`
+	DefId   string
+	DefName string
+	DefKey  string
 }
 
 type DefCateInfo struct {
@@ -369,31 +177,12 @@ type DefCateInfo struct {
 	Env3d    []DefInfo
 }
 
-// 获取用户定义类型分类
-func GetDefModelCate(c *gin.Context, apictx *ApiSession) (interface{}, error) {
-
-	var form struct {
-		Name string `json:"name"`
-	}
-	err := c.ShouldBindJSON(&form)
-	if err != nil {
-		return nil, errors.New("参数错误")
-	}
-	if form.Name == "" {
-		return nil, errors.New("资产库名不能为空")
-	}
-	// 查询 database 根据name 和用户id查找用户的asset资产
-	// 遍历资产信息，根据type获取对应类型的资产集合
-	// 62f05931ae8ddfeb72cf684e sku3d-tree
+// 查找类型分类信息
+func GetDefCate(dbId string, ctx *repo.RepoSession) (defCateInfo DefCateInfo, err error) {
 	var database model.Database
-	ctx := apictx.CreateRepoCtx()
-	var defCateInfo DefCateInfo
 	var defInfo DefInfo
 	query := make(map[string]interface{})
-	// query["userId"] = apictx.User.ID
-	query["userId"] = "62f05931ae8ddfeb72cf684e"
-	// query["name"] = form.Name
-	query["name"] = "sku3d-tree"
+	query["_id"], _ = primitive.ObjectIDFromHex(dbId)
 
 	param := &repo.DocSearchOptions{
 		CollectName: repo.CollectionDatabase,
@@ -402,28 +191,28 @@ func GetDefModelCate(c *gin.Context, apictx *ApiSession) (interface{}, error) {
 	}
 	ok, err := repo.RepoSeachDoc(ctx, param, &database)
 	if err != nil || !ok {
-		return nil, errors.New("查询数据错误")
+		return defCateInfo, errors.New("查询数据错误")
 	}
 
 	for _, v := range database.Assets {
+		defInfo.DefKey = v.Collection
+		defInfo.DefName = v.Label
+		defInfo.DefId = v.Id
+
+		// mesh
 		if v.Type == 10 {
-			defInfo.DefKey = v.Collection
-			defInfo.DefName = v.Label
 			defCateInfo.Mesh = append(defCateInfo.Mesh, defInfo)
 		}
+		// image
 		if v.Type == 20 {
-			defInfo.DefKey = v.Collection
-			defInfo.DefName = v.Label
 			defCateInfo.Image = append(defCateInfo.Image, defInfo)
 		}
+		// material
 		if v.Type == 30 {
-			defInfo.DefKey = v.Collection
-			defInfo.DefName = v.Label
 			defCateInfo.Material = append(defCateInfo.Material, defInfo)
 		}
+		// env3d
 		if v.Type == 40 {
-			defInfo.DefKey = v.Collection
-			defInfo.DefName = v.Label
 			defCateInfo.Env3d = append(defCateInfo.Env3d, defInfo)
 		}
 
@@ -432,77 +221,186 @@ func GetDefModelCate(c *gin.Context, apictx *ApiSession) (interface{}, error) {
 	return defCateInfo, nil
 }
 
-// 根据时间段进行范围查找
-// [
-//     {
-//         "Start": "2022-10-13T15:35:11.072184706+08:00",
-//         "End": "2022-10-13T17:35:11.072184706+08:00"
-//     }
-// ]
+// TODO 需要优化
+type ReqAssetCount struct {
+	DbId      string `json:"dbId"`
+	Step      int    `json:"step"`
+	StartTime string `json:"startTime"`
+	EndTime   string `json:"endTime"`
+}
 
-// 获取当前用户各个资源类型的
+// 获取统计信息图表需要的信息
+func GetInfo(c *gin.Context, apictx *ApiSession) (interface{}, error) {
 
-// 	f := bson.M{"orderId": bson.M{"$gte": minId, "$lt": maxId}, "type": item["type"].(string)}
-// 	filters = append(filters, f)
+	var form ReqAssetCount
+	err := c.ShouldBindJSON(&form)
+	if err != nil {
+		return nil, errors.New("参数错误")
+	}
+
+	if form.Step == 0 {
+		return nil, errors.New("时间步距不能为空")
+	}
+	if form.StartTime == "" {
+		return nil, errors.New("开始时间不能为空")
+	}
+	if form.EndTime == "" {
+		return nil, errors.New("结束时间不能为空")
+	}
+	if form.DbId == "" {
+		return nil, errors.New("数据库id不为空")
+	}
 
-// ok, extendsItems := RepoSeachDocsMap(ctx, &DocsSearchOptions{CollectName: CollectionLibCategory, Query: Map{"$or": filters}, Project: []string{"_id"}})
+	ctx := apictx.CreateRepoCtx()
+	timeSet := GetCountTimeSet(form)
 
-// 	// return nil, nil
-// 	今天用mongodb查昨天某个collection产生的记录数量，在mysql里面可以用between..and..或者 >、>=、<、<=来查
-// 询指定的时间范围数据，但是mongodb有自己的语法。mongodb里比较，用 "$gt" 、"$gte"、 "$lt"、 "$lte"（分别对应">"、 ">=" 、"<" 、"<="），
-// 组合起来可以进行范围的查找。比如查昨天的，就可以用
+	query := make(map[string]interface{})
+	query["dbId"], _ = primitive.ObjectIDFromHex(form.DbId)
 
-// db.CollectionAAA.find({ "CreateTime" : { "$gte" : ISODate("2017-04-20T00:00:00Z")
-// , "$lt" : ISODate("2017-04-21T00:00:00Z") } }).count()
-// 注意，开始的时候日期使用 "2017-04-20" 和"2017-04-21"，但是返回结果为空，应该日期字段需要指定格式吧，看了下存在库里的数据为ISODate类型，所以直接写成ISODate的方式，结果就正常了。
+	parm := &repo.DocSearchOptions{
+		CollectName: repo.CollectionAssetCount,
+		Project:     []string{"_id", "defId", "createTime"},
+		Sort:        bson.M{"createTime": -1}, // 降序 小于等于createTime中取时间最近的 第一条
+	}
 
-// }
+	var assetCount model.AssetCount
 
-// 根据类型/步距 = 时间点个数
+	// 返回的数据
+	var countInfo CountInfo
 
-// 获取时间集合 用于统计查询
-func GetIncrementTimes(timeType string, timeStep string) (incrementTimes IncrementTimes, timeSet []time.Time) {
-	// key 对应 时间段 day threeDay ...
-	step, ok := step2HourTimes[timeStep]
-	if !ok {
-		return
+	// 获取分类数据
+	defCateInfo, err := GetDefCate(form.DbId, ctx)
+	if err != nil {
+		return nil, err
 	}
 
-	typev, ok := type2HourTimes[timeType]
-	fmt.Println(typev)
-	if !ok {
-		return
+	var meshCountTime CountTime
+	var meshDefItem DefItem
+
+	counti := 0
+	countj := 0
+
+	for _, defMesh := range defCateInfo.Mesh {
+		counti++
+		query["type"] = 10
+		meshDefItem.DefKey = defMesh.DefKey
+		meshDefItem.DefName = defMesh.DefName
+		for _, timePoint := range timeSet {
+			// 拼接条件 查询各个增量时间段的数据
+			query["defKey"] = defMesh.DefKey
+			parm.Query = query
+			countj++
+			bl, err := repo.RepoSeachDoc(ctx, parm, &assetCount)
+			if !bl || err != nil {
+				meshCountTime.Count = 0
+			} else {
+				meshCountTime.Count = assetCount.Count
+			}
+			meshCountTime.TimePoint = timePoint
+			meshDefItem.Time = append(meshDefItem.Time, meshCountTime)
+
+		}
+		countInfo.Mesh = append(countInfo.Mesh, meshDefItem)
+
 	}
+	fmt.Println(counti) // 29
+	fmt.Println("---------------------------")
+	fmt.Println(countj) // 725
+
+	var imageCountTime CountTime
+	var imageDefItem DefItem
+	for _, defImage := range defCateInfo.Image {
+		query["type"] = 20
+		imageDefItem.DefKey = defImage.DefKey
+		imageDefItem.DefName = defImage.DefName
+		for _, timePoint := range timeSet {
+			// 拼接条件 查询各个增量时间段的数据
+			query["createTime"] = bson.M{"$lte": timePoint}
+			query["defKey"] = defImage.DefKey
+			parm.Query = query
+			bl, err := repo.RepoSeachDoc(ctx, parm, &assetCount)
+
+			if !bl || err != nil {
+				imageCountTime.Count = 0
+			} else {
+				imageCountTime.Count = assetCount.Count
+			}
+			imageCountTime.TimePoint = timePoint
+			imageDefItem.Time = append(imageDefItem.Time, imageCountTime)
 
-	// 这个类型有多少个记录点
-	times := typev/step + 1
+		}
+		countInfo.Image = append(countInfo.Image, imageDefItem)
 
-	now := time.Now() //获取当前时间
-	incrementDuration := IncrementDuration{}
+	}
 
-	// 24小时之前
-	// a, _ := time.ParseDuration(fmt.Sprintf("%dh", -counts))
-	// start := now.Add(a)
+	var materialCountTime CountTime
+	var materialDefItem DefItem
+	for _, defMaterial := range defCateInfo.Material {
+		query["type"] = 30
+		materialDefItem.DefKey = defMaterial.DefKey
+		materialDefItem.DefName = defMaterial.DefName
+		for _, timePoint := range timeSet {
+			// 拼接条件 查询各个增量时间段的数据
+			query["createTime"] = bson.M{"$lte": timePoint}
+			query["defKey"] = defMaterial.DefKey
+			parm.Query = query
+			bl, err := repo.RepoSeachDoc(ctx, parm, &assetCount)
+
+			if !bl || err != nil {
+				materialCountTime.Count = 0
+			} else {
+				materialCountTime.Count = assetCount.Count
+			}
+			materialCountTime.TimePoint = timePoint
+			materialDefItem.Time = append(materialDefItem.Time, materialCountTime)
 
-	for i := times; i > 0; i-- {
-		if timeStep == "1d" {
-			i = i * 24
-		}
-		if timeStep == "1w" {
-			i = i * 24 * 7
 		}
-		if timeStep == "1M" {
-			i = i * 24 * 30
+		countInfo.Material = append(countInfo.Material, materialDefItem)
+
+	}
+
+	var env3dCountTime CountTime
+	var env3dDefItem DefItem
+	for _, defEnv3d := range defCateInfo.Env3d {
+		query["type"] = 40
+		env3dDefItem.DefKey = defEnv3d.DefKey
+		env3dDefItem.DefName = defEnv3d.DefName
+		for _, timePoint := range timeSet {
+			// 拼接条件 查询各个增量时间段的数据
+			query["createTime"] = bson.M{"$lte": timePoint}
+			query["defKey"] = defEnv3d.DefKey
+			parm.Query = query
+			bl, err := repo.RepoSeachDoc(ctx, parm, &assetCount)
+
+			if !bl || err != nil {
+				env3dCountTime.Count = 0
+			} else {
+				env3dCountTime.Count = assetCount.Count
+			}
+			env3dCountTime.TimePoint = timePoint
+			env3dDefItem.Time = append(env3dDefItem.Time, env3dCountTime)
+
 		}
-		a, _ := time.ParseDuration(fmt.Sprintf("%dh", -i))
-		b, _ := time.ParseDuration(fmt.Sprintf("%dh", -i+1))
-		start := now.Add(a)
-		end := now.Add(b)
-		incrementDuration.Start = start
-		incrementDuration.End = end
-		incrementTimes = append(incrementTimes, incrementDuration)
-		timeSet = append(timeSet, end)
+		countInfo.Env3d = append(countInfo.Env3d, env3dDefItem)
+
 	}
-	return incrementTimes, timeSet
 
+	return countInfo, nil
+}
+
+// 获取需要查询数据的时间点
+func GetCountTimeSet(form ReqAssetCount) (timeSet []time.Time) {
+	// 计算有多少个时间段
+	startTime, _ := time.Parse("2006-01-02 15:04:05", form.StartTime)
+	endTime, _ := time.Parse("2006-01-02 15:04:05", form.EndTime)
+	duration := endTime.Unix() - startTime.Unix()
+	counts := int(duration / int64(form.Step)) // 取整
+
+	for i := 0; i <= counts; i++ {
+		b, _ := time.ParseDuration(fmt.Sprintf("%ds", i*form.Step))
+		start := startTime.Add(b)
+		// 第一个元素为开始时间
+		timeSet = append(timeSet, start)
+	}
+	return
 }

queencount/api/service-test.go

@@ -1,12 +1,16 @@
 package api
 
 import (
+	"queencount/bus"
+	"queencount/db/model"
+
 	"github.com/gin-gonic/gin"
 )
 
 func TestRouter(r *GinRouter) {
 	r.GET("/test/print", Printa)
 	// r.GET("/test/print", Printa)
+	r.GET("/test/sb", TestSubscribe)
 
 }
 
@@ -16,3 +20,12 @@ func Printa(c *gin.Context, apictx *ApiSession) (interface{}, error) {
 
 	return nil, nil
 }
+
+func TestSubscribe(c *gin.Context, apictx *ApiSession) (interface{}, error) {
+
+	var assetCount model.AssetCount
+	assetCount.DefId = "AAA"
+	assetCount.Count = 222
+	bus.NatsCenter.PublishObj("asset.added", &assetCount)
+	return nil, nil
+}

queencount/app.yaml

@@ -21,6 +21,7 @@ debug:
   UserRole: string
 
 nats:
-  url: nats://124.71.139.24:14220
+  # url: nats://124.71.139.24:14220
+  url: nats://127.0.0.1:14220
   maxReconnect: 1000
   reconnDelaySecond: 5

queencount/build.sh

@@ -2,11 +2,11 @@
 
 # 编译应用
 echo "building..."
-go build -o tree-service
+go build -o queencount-service
 
 # 命名镜像
-local_imge="pack-queentree-tree:v1.0.0"
-repository_image="registry.cn-chengdu.aliyuncs.com/infish/pack-queentree-tree:v1.0.0"
+local_imge="pack-queentree-count:v1.0.0"
+repository_image="registry.cn-chengdu.aliyuncs.com/infish/pack-queentree-count:v1.0.0"
 
 # 删除本地已存在的镜像
 docker rmi $repository_image
@@ -21,7 +21,7 @@ docker tag $local_imge $repository_image
 docker push $repository_image
 
 # 删除编译的文件
-rm -rf tree-service
+rm -rf queencount-service
 
 # 运行示例
 # docker run  -itd -p 20001:20001 --name comm-pay-service pay-service:1.0.0

queencount/bus/asset.added.go

@@ -1 +1,19 @@
 package bus
+
+import (
+	"fmt"
+
+	"github.com/nats-io/nats.go"
+	"infish.cn/comm"
+)
+
+func AssetAddedEnvent(bus *comm.NatsBus) {
+	bus.Subscribe("asset.added", AssetAddHandler)
+
+}
+
+func AssetAddHandler(msg *nats.Msg) {
+	fmt.Printf("%#s\n", msg.Data)
+
+	// dbcxt := &repo.RepoSession{Client: db.MongoClient, Ctx: context.Background()}
+}

queencount/bus/asset.remove.go

@@ -1 +1,6 @@
 package bus
+
+import "github.com/nats-io/nats.go"
+
+func AssetRemoveHandler(msg *nats.Msg) {
+}

queencount/bus/main.go

@@ -15,6 +15,8 @@ func NewNatsBus(app *conf.AppConf) *comm.NatsBus {
 		[]*comm.NatsStreamWather{},
 		[]*comm.NatsMsgReplyer{})
 	NatsCenter = bus
+	bus.Subscribe("asset.added", AssetAddHandler)
+	bus.Subscribe("asset.removed", AssetRemoveHandler)
 
 	return NatsCenter
 }

queencount/db/db.go

@@ -13,7 +13,6 @@ type MongoDB struct {
 }
 
 var MongoClient *MongoDB
-var Sku3dMongoClient *MongoDB
 
 func (db *MongoDB) GetCollection(name string) *mongo.Collection {
 	return db.Database.Collection(name)
@@ -44,8 +43,3 @@ func NewMongoDB(bus *comm.NatsBus) *MongoDB {
 	MongoClient = &MongoDB{Client: inst.Client, Database: inst.Database, Databases: map[string]*mongo.Database{}}
 	return MongoClient
 }
-
-func NewSku3dMongoDB(db *MongoDB) *MongoDB {
-	db.Client.Database("sku3d-tree")
-	return db
-}

queencount/db/model/assetCount.go

@@ -6,23 +6,9 @@ import (
 	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
-// 资产统计
-//
-//	type AssetCount struct {
-//		Id         primitive.ObjectID `bson:"_id,omitempty" json:"_id"`
-//		UserId     primitive.ObjectID `bson:"userId,omitempty" json:"userId"`
-//		ProductId  primitive.ObjectID `bson:"productId,omitempty" json:"productId"`
-//		DefKey     string             `bson:"defKey,omitempty" json:"defKey"`   //数据库名字
-//		DefName    string             `bson:"defName,omitempty" json:"defName"` //前端展示标签
-//		CreateTime time.Time          `bson:"createTime,omitempty" json:"createTime"`
-//		Status     *int32             `bson:"status,omitempty" json:"status"`
-//	}
 type AssetCount struct {
 	Id         primitive.ObjectID `bson:"_id,omitempty" json:"_id"`
-	DbId       primitive.ObjectID `bson:"dbId,omitempty" json:"dbId"`
-	Type       *int32             `bson:"type,omitempty" json:"type"`       // 10 mesh 20 image 30 material 40 env3d
-	DefKey     string             `bson:"defKey,omitempty" json:"defKey"`   //数据表名字
-	DefName    string             `bson:"defName,omitempty" json:"defName"` //前端展示标签
-	Count      *int32             `bson:"count,omitempty" json:"count"`
+	DefId      string             `bson:"defId,omitempty" json:"defId"`
+	Count      int                `bson:"count,omitempty" json:"count"`
 	CreateTime time.Time          `bson:"createTime,omitempty" json:"createTime"`
 }

queencount/db/repo/repo.go

@@ -90,6 +90,7 @@ type DocSearchOptions struct {
 	CollectName string
 	Query       Map
 	Project     []string
+	Sort        bson.M
 }
 
 func NewDocSearchOptions(filter Map, project []string) *DocSearchOptions {