Create & Init Project...

app/interface/main/app-resource/service/show/BUILD

@@ -0,0 +1,60 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["show_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "audit.go",
+        "cache.go",
+        "service.go",
+        "show.go",
+    ],
+    importpath = "go-common/app/interface/main/app-resource/service/show",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/dao/audit:go_default_library",
+        "//app/interface/main/app-resource/dao/resource:go_default_library",
+        "//app/interface/main/app-resource/dao/tab:go_default_library",
+        "//app/interface/main/app-resource/model:go_default_library",
+        "//app/interface/main/app-resource/model/abtest:go_default_library",
+        "//app/interface/main/app-resource/model/show:go_default_library",
+        "//app/interface/main/app-resource/model/tab:go_default_library",
+        "//app/service/main/resource/model:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//vendor/github.com/dgryski/go-farm: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"],
+)

app/interface/main/app-resource/service/show/audit.go

@@ -0,0 +1,26 @@
+package show
+
+import (
+	"context"
+
+	"go-common/library/log"
+)
+
+func (s *Service) loadAuditCache() {
+	as, err := s.adt.Audits(context.TODO())
+	if err != nil {
+		log.Error("s.adt.Audits error(%v)", err)
+		return
+	}
+	s.auditCache = as
+}
+
+// Audit show tab data list.
+func (s *Service) auditTab(mobiApp string, build int, plat int8) (isAudit bool) {
+	if plats, ok := s.auditCache[mobiApp]; ok {
+		if _, ok = plats[build]; ok {
+			return true
+		}
+	}
+	return false
+}

app/interface/main/app-resource/service/show/cache.go

@@ -0,0 +1,98 @@
+package show
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/interface/main/app-resource/model/show"
+	resource "go-common/app/service/main/resource/model"
+	"go-common/library/log"
+)
+
+func (s *Service) loadTabCache() (err error) {
+	var (
+		tmp      = map[int64]struct{}{}
+		ss       = map[string][]*show.Tab{}
+		sideBars *resource.SideBars
+	)
+	if sideBars, err = s.rdao.ResSideBar(context.TODO()); err != nil || sideBars == nil {
+		log.Error("s.sideDao.SideBar error(%v) or nil", err)
+		return
+	}
+	for _, v := range sideBars.SideBar {
+		if _, ok := tmp[v.ID]; ok {
+			continue
+		}
+		tmp[v.ID] = struct{}{}
+		st := &show.Tab{}
+		if !st.TabChange(v, _showAbtest, _deafaultTab) {
+			continue
+		}
+		key := fmt.Sprintf(_initTabKey, st.Plat, st.Language)
+		ss[key] = append(ss[key], st)
+	}
+	if len(ss) == 0 && len(s.tabCache) == 0 {
+		err = fmt.Errorf("tabCache is null")
+		return
+	} else if len(ss) == 0 {
+		return
+	}
+	s.tabCache = ss
+	s.limitsCahce = sideBars.Limit
+	log.Info("loadTabCache cache success")
+	return
+}
+
+func (s *Service) loadMenusCache(now time.Time) {
+	menus, err := s.tdao.Menus(context.TODO(), now)
+	if err != nil {
+		log.Error("s.tab.Menus error(%v)", err)
+		return
+	}
+	s.menuCache = menus
+	log.Info("loadMenusCache cache success")
+}
+
+func (s *Service) loadAbTestCache() {
+	var (
+		groups string
+	)
+	for _, g := range _showAbtest {
+		groups = groups + g + ","
+	}
+	if gLen := len(groups); gLen > 0 {
+		groups = groups[:gLen-1]
+	}
+	res, err := s.rdao.AbTest(context.TODO(), groups)
+	if err != nil {
+		log.Error("resource s.rdao.AbTest error(%v)", err)
+		return
+	}
+	s.abtestCache = res
+	log.Info("loadAbTestCache cache success")
+}
+
+func (s *Service) loadCache() (err error) {
+	now := time.Now()
+	err = s.loadTabCache()
+	s.loadMenusCache(now)
+	s.loadAbTestCache()
+	s.loadAuditCache()
+	return
+}
+
+func (s *Service) loadCacheproc() {
+	for {
+		time.Sleep(s.tick)
+		s.loadCache()
+	}
+}
+
+func (s *Service) loadShowTabAids() {
+	tmp := map[int64]struct{}{}
+	for _, mid := range s.c.ShowTabMids {
+		tmp[mid] = struct{}{}
+	}
+	s.showTabMids = tmp
+}

app/interface/main/app-resource/service/show/service.go

@@ -0,0 +1,52 @@
+package show
+
+import (
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+	adtdao "go-common/app/interface/main/app-resource/dao/audit"
+	resdao "go-common/app/interface/main/app-resource/dao/resource"
+	tabdao "go-common/app/interface/main/app-resource/dao/tab"
+	"go-common/app/interface/main/app-resource/model/show"
+	"go-common/app/interface/main/app-resource/model/tab"
+	resource "go-common/app/service/main/resource/model"
+)
+
+// Service is showtab service.
+type Service struct {
+	c *conf.Config
+	//dao
+	rdao        *resdao.Dao
+	tdao        *tabdao.Dao
+	adt         *adtdao.Dao
+	tick        time.Duration
+	tabCache    map[string][]*show.Tab
+	limitsCahce map[int64][]*resource.SideBarLimit
+	menuCache   []*tab.Menu
+	abtestCache map[string]*resource.AbTest
+	showTabMids map[int64]struct{}
+	auditCache  map[string]map[int]struct{} // audit mobi_app builds
+}
+
+// New new a showtab service.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:           c,
+		rdao:        resdao.New(c),
+		tdao:        tabdao.New(c),
+		adt:         adtdao.New(c),
+		tick:        time.Duration(c.Tick),
+		tabCache:    map[string][]*show.Tab{},
+		limitsCahce: map[int64][]*resource.SideBarLimit{},
+		menuCache:   []*tab.Menu{},
+		abtestCache: map[string]*resource.AbTest{},
+		showTabMids: map[int64]struct{}{},
+		auditCache:  map[string]map[int]struct{}{},
+	}
+	if err := s.loadCache(); err != nil {
+		panic(err)
+	}
+	s.loadShowTabAids()
+	go s.loadCacheproc()
+	return
+}

app/interface/main/app-resource/service/show/show.go

@@ -0,0 +1,118 @@
+package show
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/app/interface/main/app-resource/model/abtest"
+	"go-common/app/interface/main/app-resource/model/show"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	farm "github.com/dgryski/go-farm"
+)
+
+const (
+	_initTabKey          = "tab_%d_%s"
+	_initVersion         = "showtab_version"
+	_defaultLanguageHans = "hans"
+	_defaultLanguageHant = "hant"
+)
+
+var (
+	_showAbtest = map[string]string{
+		"bilibili://pegasus/hottopic": "home_tabbar_server_1",
+	}
+	_deafaultTab = map[string]*show.Tab{
+		"bilibili://pegasus/promo": &show.Tab{
+			DefaultSelected: 1,
+		},
+	}
+)
+
+// Tabs show tabs
+func (s *Service) Tabs(c context.Context, plat int8, build int, buvid, ver, mobiApp, language string, mid int64) (res map[string][]*show.Tab, version string, a *abtest.List, err error) {
+	if key := fmt.Sprintf(_initTabKey, plat, language); len(s.tabCache[fmt.Sprintf(key)]) == 0 || language == "" {
+		if model.IsOverseas(plat) {
+			var key = fmt.Sprintf(_initTabKey, plat, _defaultLanguageHant)
+			if len(s.tabCache[fmt.Sprintf(key)]) > 0 {
+				language = _defaultLanguageHant
+			} else {
+				language = _defaultLanguageHans
+			}
+		} else {
+			language = _defaultLanguageHans
+		}
+	}
+	var (
+		key     = fmt.Sprintf(_initTabKey, plat, language)
+		tmptabs = []*show.Tab{}
+	)
+	res = map[string][]*show.Tab{}
+	if tabs, ok := s.tabCache[key]; ok {
+	LOOP:
+		for _, v := range tabs {
+			for _, l := range s.limitsCahce[v.ID] {
+				if model.InvalidBuild(build, l.Build, l.Condition) {
+					continue LOOP
+				}
+			}
+			if !s.c.ShowHotAll {
+				if ab, ok := s.abtestCache[v.Group]; ok {
+					if _, ok := s.showTabMids[mid]; !ab.AbTestIn(buvid) && !ok {
+						continue LOOP
+					}
+					a = &abtest.List{}
+					a.ListChange(ab)
+				}
+			}
+			tmptabs = append(tmptabs, v)
+		}
+	}
+	if !s.auditTab(mobiApp, build, plat) {
+		if menus := s.menus(plat, build); len(menus) > 0 {
+			tmptabs = append(tmptabs, menus...)
+		}
+	}
+	for _, v := range tmptabs {
+		t := &show.Tab{}
+		*t = *v
+		t.Pos = len(res[v.ModuleStr]) + 1
+		res[v.ModuleStr] = append(res[v.ModuleStr], t)
+	}
+	if version = s.hash(res); version == ver {
+		err = ecode.NotModified
+		res = nil
+	}
+	return
+}
+
+func (s *Service) menus(plat int8, build int) (res []*show.Tab) {
+	memuCache := s.menuCache
+LOOP:
+	for _, m := range memuCache {
+		if vs, ok := m.Versions[model.PlatAPPBuleChange(plat)]; ok {
+			for _, v := range vs {
+				if model.InvalidBuild(build, v.Build, v.Condition) {
+					continue LOOP
+				}
+			}
+			t := &show.Tab{}
+			t.TabMenuChange(m)
+			res = append(res, t)
+		}
+	}
+	return
+}
+
+func (s *Service) hash(v map[string][]*show.Tab) string {
+	bs, err := json.Marshal(v)
+	if err != nil {
+		log.Error("json.Marshal error(%v)", err)
+		return _initVersion
+	}
+	return strconv.FormatUint(farm.Hash64(bs), 10)
+}

app/interface/main/app-resource/service/show/show_test.go

@@ -0,0 +1,39 @@
+package show
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	s *Service
+)
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		f(s)
+	}
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-resource-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	s = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestTabs(t *testing.T) {
+	Convey("get Tabs data", t, WithService(func(s *Service) {
+		res, _, _, err := s.Tabs(context.TODO(), 1, 1, "xxxx", "xxx", "iphone", "hans", 111)
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	}))
+}