Create & Init Project...

app/admin/main/up/service/data/BUILD

@@ -0,0 +1,60 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "service.go",
+        "uparchiveinfo.go",
+        "viewer.go",
+    ],
+    importpath = "go-common/app/admin/main/up/service/data",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/up/conf:go_default_library",
+        "//app/admin/main/up/dao/data:go_default_library",
+        "//app/admin/main/up/dao/tag:go_default_library",
+        "//app/admin/main/up/model/datamodel:go_default_library",
+        "//app/admin/main/up/service/cache:go_default_library",
+        "//app/admin/main/up/util:go_default_library",
+        "//app/interface/main/creative/model/tag:go_default_library",
+        "//library/log:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "service_test.go",
+        "uparchiveinfo_test.go",
+        "viewer_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/up/conf:go_default_library",
+        "//app/admin/main/up/model/datamodel:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/admin/main/up/service/data/service.go

@@ -0,0 +1,62 @@
+package data
+
+import (
+	"go-common/app/admin/main/up/conf"
+	"go-common/app/admin/main/up/dao/data"
+	"go-common/app/admin/main/up/dao/tag"
+	"time"
+)
+
+//Service data service
+type Service struct {
+	c    *conf.Config
+	data *data.Dao
+	dtag *tag.Dao
+}
+
+//New get service
+func New(c *conf.Config) *Service {
+	s := &Service{
+		c:    c,
+		data: data.New(c),
+		dtag: tag.New(c),
+	}
+	return s
+}
+
+func beginningOfDay(t time.Time) time.Time {
+	d := time.Duration(-t.Hour()) * time.Hour
+	return t.Truncate(time.Hour).Add(d)
+}
+
+func getTuesday(now time.Time) time.Time {
+	t := beginningOfDay(now)
+	weekday := int(t.Weekday())
+	if weekday == 0 {
+		weekday = 7
+	}
+	d := time.Duration(-weekday+2) * 24 * time.Hour
+	return t.Truncate(time.Hour).Add(d)
+}
+
+func getSunday(now time.Time) time.Time {
+	t := beginningOfDay(now)
+	weekday := int(t.Weekday())
+	if weekday == 0 {
+		return t
+	}
+	d := time.Duration(7-weekday) * 24 * time.Hour
+	return t.Truncate(time.Hour).Add(d)
+}
+
+func getDateLastSunday() (date time.Time) {
+	t := time.Now()
+	td := getTuesday(t).Add(12 * time.Hour)
+	if t.Before(td) { //当前时间在本周二12点之前，则取上上周日的数据，否则取上周日的数据
+		date = getSunday(t.AddDate(0, 0, -14))
+	} else {
+		date = getSunday(t.AddDate(0, 0, -7))
+	}
+	//log.Info("current time (%s) tuesday (%s) sunday (%s)", t.Format("2006-01-02 15:04:05"), td, sd)
+	return
+}

app/admin/main/up/service/data/service_test.go

@@ -0,0 +1,23 @@
+package data
+
+import (
+	"flag"
+	"go-common/app/admin/main/up/conf"
+	"os"
+	"testing"
+)
+
+var (
+	s *Service
+)
+
+func TestMain(m *testing.M) {
+	flag.Set("conf", "../../cmd/up-admin.toml")
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	s = New(conf.Conf)
+	m.Run()
+	os.Exit(m.Run())
+}

app/admin/main/up/service/data/uparchiveinfo.go

@@ -0,0 +1,96 @@
+package data
+
+import (
+	"context"
+	"go-common/app/admin/main/up/dao/data"
+	"go-common/app/admin/main/up/model/datamodel"
+	"go-common/app/admin/main/up/util"
+	"go-common/library/log"
+	"sort"
+	"strconv"
+)
+
+//GetUpArchiveInfo get up archive info
+func (s *Service) GetUpArchiveInfo(c context.Context, arg *datamodel.GetUpArchiveInfoArg) (result *datamodel.GetUpArchiveInfoResult, err error) {
+	if arg.DataType == 0 {
+		arg.DataType = datamodel.DataType30Day
+	}
+	result = &datamodel.GetUpArchiveInfoResult{}
+	var mids = util.ExplodeInt64(arg.Mids, ",")
+	var length = len(mids)
+	if length == 0 {
+		log.Info("no mids specified")
+		return
+	} else if length > 100 {
+		// 每次最多100个
+		mids = mids[0:100]
+	}
+
+	dataMap, err := s.data.UpArchiveInfo(c, mids, data.UpArchiveDataType(arg.DataType))
+	if err != nil {
+		log.Error("get up archive info fail, err=%v, arg=%+v", err, arg)
+		return
+	}
+
+	for mid, v := range dataMap {
+		(*result)[mid] = v
+	}
+	log.Info("get up archive info ok, type=%d", arg.DataType)
+	return
+}
+
+//GetUpArchiveTagInfo get up archive tag info
+func (s *Service) GetUpArchiveTagInfo(c context.Context, arg *datamodel.GetUpArchiveTagInfoArg) (result []*datamodel.ViewerTagData, err error) {
+
+	tagData, err := s.data.UpArchiveTagInfo(c, arg.Mid)
+	if err != nil {
+		log.Error("get up archive tag fail, err=%v", err)
+		return
+	}
+
+	var tagResultMap = make(map[int64]*datamodel.ViewerTagData)
+	var tagIds []int64
+	for idxstr, tid := range tagData.TagMap {
+		tagIds = append(tagIds, tid)
+		var idx, _ = strconv.Atoi(idxstr)
+		var tag = &datamodel.ViewerTagData{
+			Idx:   idx,
+			TagID: int(tid),
+		}
+		tagResultMap[tid] = tag
+	}
+	var tagMeta = s.GetTags(c, tagIds...)
+	for tid, meta := range tagMeta {
+		tag, ok := tagResultMap[tid]
+		if !ok {
+			continue
+		}
+		tag.Name = meta.TagName
+	}
+
+	for _, tag := range tagResultMap {
+		result = append(result, tag)
+	}
+
+	if len(result) > 1 {
+		sort.Slice(result, func(i, j int) bool {
+			return result[i].Idx < result[j].Idx
+		})
+	}
+
+	log.Info("get up archive tag info ok, mid=%d", arg.Mid)
+	return
+}
+
+//GetUpArchiveTypeInfo get type info
+func (s *Service) GetUpArchiveTypeInfo(c context.Context, arg *datamodel.GetUpArchiveTypeInfoArg) (result *datamodel.UpArchiveTypeData, err error) {
+	res, err := s.data.UpArchiveTypeInfo(c, arg.Mid)
+	result = &res
+	if err != nil {
+		log.Error("fail to get up type, err=%v", err)
+		return
+	}
+
+	log.Info("get up archive type info ok, mid=%d", arg.Mid)
+	return
+}

app/admin/main/up/service/data/uparchiveinfo_test.go

@@ -0,0 +1,57 @@
+package data
+
+import (
+	"context"
+	"go-common/app/admin/main/up/model/datamodel"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDataGetUpArchiveInfo(t *testing.T) {
+	convey.Convey("GetUpArchiveInfo", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &datamodel.GetUpArchiveInfoArg{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			result, err := s.GetUpArchiveInfo(c, arg)
+			ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(result, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDataGetUpArchiveTagInfo(t *testing.T) {
+	convey.Convey("GetUpArchiveTagInfo", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &datamodel.GetUpArchiveTagInfoArg{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			result, err := s.GetUpArchiveTagInfo(c, arg)
+			ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(result, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDataGetUpArchiveTypeInfo(t *testing.T) {
+	convey.Convey("GetUpArchiveTypeInfo", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &datamodel.GetUpArchiveTypeInfoArg{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			result, err := s.GetUpArchiveTypeInfo(c, arg)
+			ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(result, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/admin/main/up/service/data/viewer.go

@@ -0,0 +1,234 @@
+package data
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/admin/main/up/model/datamodel"
+	"go-common/app/admin/main/up/service/cache"
+	"go-common/app/interface/main/creative/model/tag"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+)
+
+// ViewerBase get up viewer base data.
+func (s *Service) ViewerBase(c context.Context, mid int64) (res *datamodel.ViewerBaseInfo, err error) {
+	dt := getDateLastSunday()
+
+	if res, err = s.data.ViewerBase(c, mid, dt); err != nil {
+		log.Error("get viewer base error, err=%v", err)
+		return
+	}
+	return
+}
+
+// ViewerArea get up viewer area data.
+func (s *Service) ViewerArea(c context.Context, mid int64) (res *datamodel.ViewerAreaInfo, err error) {
+	dt := getDateLastSunday()
+
+	res, err = s.data.ViewerArea(c, mid, dt)
+	if err != nil {
+		log.Error("get viewer area error, err=%v", err)
+		return
+	}
+	return
+}
+
+// CacheTrend get trend from mc.
+func (s *Service) CacheTrend(c context.Context, mid int64) (res *datamodel.ViewerTrendInfo, err error) {
+	dt := getDateLastSunday()
+
+	if res, err = s.viewerTrend(c, mid, dt); err != nil {
+		return
+	}
+
+	return
+}
+
+//GetTags get tag
+func (s *Service) GetTags(c context.Context, ids ...int64) (result map[int64]*tag.Meta) {
+	var tagMetaMap, leftIDs = cache.GetTagCache(ids...)
+	if len(leftIDs) > 0 {
+		if tlist, err := s.dtag.TagList(c, leftIDs); err != nil {
+			log.Error("trend s.dtag.TagList err(%v)", err)
+		} else {
+			for _, v := range tlist {
+				tagMetaMap[v.TagID] = v
+				cache.AddTagCache(v)
+			}
+		}
+	}
+	result = tagMetaMap
+	return
+}
+
+// ViewerTrend get up viewer trend data.
+func (s *Service) viewerTrend(c context.Context, mid int64, dt time.Time) (res *datamodel.ViewerTrendInfo, err error) {
+	ut, err := s.data.ViewerTrend(c, mid, dt)
+	if err != nil || ut == nil {
+		log.Error("trend s.data.ViewerTrend err(%v)", err)
+		return
+	}
+	f := []string{"fan", "guest"}
+	skeys := make([]int, 0) //for tag sort.
+	tgs := make([]int64, 0) // for request tag name.
+	res = &datamodel.ViewerTrendInfo{}
+	var dataMap = make(map[string]*datamodel.ViewerTypeTagInfo)
+	for _, fk := range f {
+		td := ut[fk]
+		vt := &datamodel.ViewerTypeTagInfo{}
+		if td == nil {
+			vt.Type = nil
+			vt.Tag = nil
+			dataMap[fk] = vt
+			continue
+		}
+		typeMap := make(map[int]*datamodel.ViewerTypeData) //return type map to user.
+		//deal type for type name.
+		if td.Ty != nil {
+			for k, v := range td.Ty {
+				var tagInfo, ok = cache.VideoUpTypeCache[k]
+				var name = ""
+				if ok {
+					name = tagInfo.Name
+				}
+				typeMap[k] = &datamodel.ViewerTypeData{
+					Tid:  k,
+					Name: name,
+					Play: v,
+				}
+			}
+		} else {
+			typeMap = nil
+		}
+		// deal tag for tag name.
+		if td.Tag != nil {
+			for k, v := range td.Tag {
+				tgs = append(tgs, v)
+				skeys = append(skeys, k)
+			}
+			var tagMetaMap, leftIDs = cache.GetTagCache(tgs...)
+			if len(leftIDs) > 0 {
+				var tlist []*tag.Meta
+				if tlist, err = s.dtag.TagList(c, leftIDs); err != nil {
+					log.Error("trend s.dtag.TagList err(%v)", err)
+				} else {
+					for _, v := range tlist {
+						tagMetaMap[v.TagID] = v
+						cache.AddTagCache(v)
+					}
+				}
+			}
+
+			for _, k := range skeys {
+				var tagID = td.Tag[k]
+				var tagData = &datamodel.ViewerTagData{
+					Idx:   k,
+					TagID: int(tagID),
+					Name:  "",
+				}
+				if tagMeta, ok := tagMetaMap[tagID]; ok {
+					tagData.Name = tagMeta.TagName
+				}
+				vt.Tag = append(vt.Tag, tagData)
+			}
+		}
+		for _, v := range typeMap {
+			vt.Type = append(vt.Type, v)
+		}
+
+		dataMap[fk] = vt
+	}
+	res.Fans = dataMap["fan"]
+	res.Guest = dataMap["guest"]
+	return
+}
+
+//ViewData view data for up
+type ViewData struct {
+	Base  *datamodel.ViewerBaseInfo  `json:"viewer_base"`
+	Trend *datamodel.ViewerTrendInfo `json:"viewer_trend"`
+	Area  *datamodel.ViewerAreaInfo  `json:"viewer_area"`
+}
+
+//GetUpViewInfo get view info by arg
+func (s *Service) GetUpViewInfo(c context.Context, arg *datamodel.GetUpViewInfoArg) (result *ViewData, err error) {
+	if arg == nil {
+		log.Error("arg is nil")
+		return
+	}
+	res, err := s.GetViewData(c, arg.Mid)
+	result = &res
+	return
+}
+
+//GetViewData get all view data
+func (s *Service) GetViewData(c context.Context, mid int64) (result ViewData, err error) {
+	var group, ctx = errgroup.WithContext(c)
+	group.Go(func() error {
+		var e error
+		result.Base, e = s.ViewerBase(ctx, mid)
+		if e != nil {
+			log.Error("get base view err happen, err=%v", e)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		var e error
+		result.Area, e = s.ViewerArea(ctx, mid)
+		if e != nil {
+			log.Error("get area view err happen, err=%v", e)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		var e error
+		result.Trend, e = s.CacheTrend(ctx, mid)
+		if e != nil {
+			log.Error("get trend view err happen, err=%v", e)
+		}
+		return nil
+	})
+
+	err = group.Wait()
+	if err != nil {
+		log.Error("get view data error, err=%+v", err)
+	}
+	return
+}
+
+//GetFansSummary get fan summary
+func (s *Service) GetFansSummary(c context.Context, arg *datamodel.GetFansSummaryArg) (result *datamodel.FansSummaryResult, err error) {
+	result = &datamodel.FansSummaryResult{}
+	var fanInfo, e = s.data.UpFansAnalysis(c, arg.Mid, datamodel.Thirty)
+	if e != nil || fanInfo == nil {
+		err = e
+		log.Error("get fan analysis err happen, err=%v", e)
+		return
+	}
+	result.FanSummary = fanInfo.Summary
+	return
+}
+
+//GetRelationFansDay get fan day history
+func (s *Service) GetRelationFansDay(c context.Context, arg *datamodel.GetRelationFansHistoryArg) (result *datamodel.GetRelationFansHistoryResult, err error) {
+
+	result = &datamodel.GetRelationFansHistoryResult{}
+	if arg.DataType == 0 {
+		arg.DataType = datamodel.DataType30Day
+	}
+	switch arg.DataType {
+	case datamodel.DataType30Day:
+		result.RelationFanHistoryData, err = s.data.RelationFansDay(c, arg.Mid)
+	case datamodel.DataTypeMonth:
+		result.RelationFanHistoryData, err = s.data.RelationFansMonth(c, arg.Mid)
+	default:
+		err = fmt.Errorf("invalid data type(%d)", arg.DataType)
+	}
+	if err != nil {
+		log.Error("get relation fans day fail, err=%v", err)
+		return
+	}
+	return
+}

app/admin/main/up/service/data/viewer_test.go

@@ -0,0 +1,154 @@
+package data
+
+import (
+	"context"
+	"go-common/app/admin/main/up/model/datamodel"
+	"testing"
+	"time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDataViewerBase(t *testing.T) {
+	convey.Convey("ViewerBase", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err := s.ViewerBase(c, mid)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDataViewerArea(t *testing.T) {
+	convey.Convey("ViewerArea", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err := s.ViewerArea(c, mid)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDataCacheTrend(t *testing.T) {
+	convey.Convey("CacheTrend", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err := s.CacheTrend(c, mid)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDataGetTags(t *testing.T) {
+	convey.Convey("GetTags", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			ids = int64(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			result := s.GetTags(c, ids)
+			ctx.Convey("Then result should not be nil.", func(ctx convey.C) {
+				ctx.So(result, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDataviewerTrend(t *testing.T) {
+	convey.Convey("viewerTrend", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			dt  = time.Now()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err := s.viewerTrend(c, mid, dt)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDataGetUpViewInfo(t *testing.T) {
+	convey.Convey("GetUpViewInfo", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &datamodel.GetUpViewInfoArg{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			result, err := s.GetUpViewInfo(c, arg)
+			ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(result, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDataGetViewData(t *testing.T) {
+	convey.Convey("GetViewData", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			result, err := s.GetViewData(c, mid)
+			ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(result, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDataGetFansSummary(t *testing.T) {
+	convey.Convey("GetFansSummary", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &datamodel.GetFansSummaryArg{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			result, err := s.GetFansSummary(c, arg)
+			ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(result, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDataGetRelationFansDay(t *testing.T) {
+	convey.Convey("GetRelationFansDay", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			arg = &datamodel.GetRelationFansHistoryArg{}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			result, err := s.GetRelationFansDay(c, arg)
+			ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(result, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}