Create & Init Project...

app/interface/main/app-interface/dao/account/BUILD

@@ -0,0 +1,53 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["account_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/account",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//app/service/main/account/rpc/client:go_default_library",
+        "//app/service/main/member/api/gorpc:go_default_library",
+        "//app/service/main/member/model/block:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/account/account_test.go

@@ -0,0 +1,54 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+//go test -conf="../../app-interface-example.toml"  -v -test.run TestCard
+func TestCard(t *testing.T) {
+	Convey("TestCard", t, func() {
+		err := conf.Init()
+		if err != nil {
+			return
+		}
+		dao := New(conf.Conf)
+		card, err := dao.Profile3(context.TODO(), 28009145)
+		if err != nil {
+			t.Errorf("dao.Profile3 error(%v)", err)
+			return
+		}
+		result, err := json.Marshal(card)
+		if err != nil {
+			t.Errorf("json.Marshal error(%v)", err)
+			return
+		}
+		fmt.Printf("test card (%v) \n", string(result))
+	})
+}
+
+//go test -conf="../../app-interface-example.toml"  -v -test.run TestCardByName
+func TestCardByName(t *testing.T) {
+	err := conf.Init()
+	if err != nil {
+		return
+	}
+	dao := New(conf.Conf)
+	card, err := dao.ProfileByName3(context.TODO(), "冠冠爱看书")
+	if err != nil {
+		t.Errorf("dao.ProfileByName3 error(%v)", err)
+		return
+	}
+	result, err := json.Marshal(card)
+	if err != nil {
+		t.Errorf("json.Marshal error(%v)", err)
+		return
+	}
+	fmt.Printf("test card (%v) \n", string(result))
+}

app/interface/main/app-interface/dao/account/dao.go

@@ -0,0 +1,193 @@
+package account
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	account "go-common/app/service/main/account/model"
+	accrpc "go-common/app/service/main/account/rpc/client"
+	memberrpc "go-common/app/service/main/member/api/gorpc"
+	blockmodel "go-common/app/service/main/member/model/block"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is account dao.
+type Dao struct {
+	client *bm.Client
+	// rpc
+	accRPC    *accrpc.Service3
+	memberRPC *memberrpc.Service
+}
+
+// New account dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:    bm.NewClient(c.HTTPClient),
+		accRPC:    accrpc.New3(c.AccountRPC),
+		memberRPC: memberrpc.New(c.MemberRPC),
+	}
+	return
+}
+
+// BlockTime get user blocktime
+func (d *Dao) BlockTime(c context.Context, mid int64) (blockTime int64, err error) {
+	info, err := d.memberRPC.BlockInfo(c, &blockmodel.RPCArgInfo{MID: mid})
+	if err != nil {
+		err = errors.Wrapf(err, "%v", mid)
+		return
+	}
+	if info.EndTime > 0 {
+		blockTime = info.EndTime
+	}
+	return
+}
+
+// Profile3 get profile
+func (d *Dao) Profile3(c context.Context, mid int64) (card *account.ProfileStat, err error) {
+	arg := &account.ArgMid{Mid: mid}
+	if card, err = d.accRPC.ProfileWithStat3(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+// Card get card
+func (d *Dao) Card(c context.Context, mid int64) (card *account.Card, err error) {
+	if card, err = d.accRPC.Card3(c, &account.ArgMid{Mid: mid}); err != nil {
+		err = errors.Wrapf(err, "%v", mid)
+	}
+	return
+}
+
+// ProfileByName3 rpc card get by name
+func (d *Dao) ProfileByName3(c context.Context, name string) (card *account.ProfileStat, err error) {
+	infos, err := d.accRPC.InfosByName3(c, &account.ArgNames{Names: []string{name}})
+	if err != nil {
+		err = errors.Wrapf(err, "%v", name)
+		return
+	}
+	if len(infos) == 0 {
+		err = ecode.NothingFound
+		return
+	}
+	for mid := range infos {
+		card, err = d.Profile3(c, mid)
+		break
+	}
+	return
+}
+
+// Infos3 rpc info get by mids .
+func (d *Dao) Infos3(c context.Context, mids []int64) (res map[int64]*account.Info, err error) {
+	arg := &account.ArgMids{Mids: mids}
+	if res, err = d.accRPC.Infos3(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+// Relations3 relations.
+func (d *Dao) Relations3(c context.Context, owners []int64, mid int64) (follows map[int64]bool) {
+	if len(owners) == 0 {
+		return nil
+	}
+	follows = make(map[int64]bool, len(owners))
+	for _, owner := range owners {
+		follows[owner] = false
+	}
+	var (
+		am  map[int64]*account.Relation
+		err error
+		ip  = metadata.String(c, metadata.RemoteIP)
+	)
+	arg := &account.ArgRelations{Owners: owners, Mid: mid, RealIP: ip}
+	if am, err = d.accRPC.Relations3(c, arg); err != nil {
+		log.Error("d.accRPC.Relations2(%v) error(%v)", arg, err)
+		return
+	}
+	for i, a := range am {
+		if _, ok := follows[i]; ok {
+			follows[i] = a.Following
+		}
+	}
+	return
+}
+
+// RichRelations3 rich relations.
+func (d *Dao) RichRelations3(c context.Context, owner, mid int64) (rel int, err error) {
+	var (
+		res map[int64]int
+		ip  = metadata.String(c, metadata.RemoteIP)
+	)
+	arg := &account.ArgRichRelation{Mids: []int64{mid}, Owner: owner, RealIP: ip}
+	if res, err = d.accRPC.RichRelations3(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+		return
+	}
+	if r, ok := res[mid]; ok {
+		rel = r
+	}
+	return
+}
+
+// Cards3 is
+func (d *Dao) Cards3(c context.Context, mids []int64) (res map[int64]*account.Card, err error) {
+	arg := &account.ArgMids{Mids: mids}
+	if res, err = d.accRPC.Cards3(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v")
+	}
+	return
+}
+
+// UserCheck 各种入口白名单
+// https://www.tapd.cn/20055921/prong/stories/view/1120055921001066980  动态互推TAPD在此！！
+func (d *Dao) UserCheck(c context.Context, mid int64, checkURL string) (ok bool, err error) {
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Status int `json:"status"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, checkURL, "", params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), checkURL+"?"+params.Encode())
+		return
+	}
+	if res.Data.Status == 1 {
+		ok = true
+	}
+	return
+}
+
+// RedDot 我的页小红点逻辑
+func (d *Dao) RedDot(c context.Context, mid int64, redDotURL string) (ok bool, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			RedDot bool `json:"red_dot"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, redDotURL, "", params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), redDotURL+"?"+params.Encode())
+		return
+	}
+	log.Warn("reddot response mid(%d) url(%s) res(%t)", mid, redDotURL+"?"+params.Encode(), res.Data.RedDot)
+	ok = res.Data.RedDot
+	return
+}

app/interface/main/app-interface/dao/archive/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 = [
+        "dao_test.go",
+        "memcache_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "memcache.go",
+    ],
+    importpath = "go-common/app/interface/main/app-interface/dao/archive",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/archive/api/gorpc:go_default_library",
+        "//app/service/main/archive/model/archive:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/archive/dao.go

@@ -0,0 +1,167 @@
+package archive
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/service/main/archive/api"
+	arcrpc "go-common/app/service/main/archive/api/gorpc"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/cache/memcache"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/sync/errgroup"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is archive dao.
+type Dao struct {
+	// http client
+	client *bm.Client
+	// rpc
+	arcRPC *arcrpc.Service2
+	// memcache
+	arcMc     *memcache.Pool
+	expireArc int32
+}
+
+// New new a archive dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		client: bm.NewClient(c.HTTPWrite),
+		arcRPC: arcrpc.New2(c.ArchiveRPC),
+		// memcache
+		arcMc:     memcache.NewPool(c.Memcache.Archive.Config),
+		expireArc: int32(time.Duration(c.Memcache.Archive.ArchiveExpire) / time.Second),
+	}
+	return
+}
+
+// UpArcs3 get upper archives
+func (d *Dao) UpArcs3(c context.Context, mid int64, pn, ps int) (as []*api.Arc, err error) {
+	arg := &archive.ArgUpArcs2{Mid: mid, Pn: pn, Ps: ps}
+	if as, err = d.arcRPC.UpArcs3(c, arg); err != nil {
+		if ecode.Cause(err) == ecode.NothingFound {
+			err = nil
+		}
+	}
+	return
+}
+
+// UpCount2 get upper count.
+func (d *Dao) UpCount2(c context.Context, mid int64) (cnt int, err error) {
+	arg := &archive.ArgUpCount2{Mid: mid}
+	return d.arcRPC.UpCount2(c, arg)
+}
+
+// Archives multi get archives.
+func (d *Dao) Archives(c context.Context, aids []int64) (as map[int64]*api.Arc, err error) {
+	if len(aids) == 0 {
+		return
+	}
+	g, ctx := errgroup.WithContext(c)
+	g.Go(func() (err error) {
+		var missed []int64
+		if as, missed, err = d.arcsCache(ctx, aids); err != nil {
+			log.Error("%+v", err)
+			missed = aids
+			err = nil
+		}
+		if len(missed) == 0 {
+			return
+		}
+		var tmp map[int64]*api.Arc
+		arg := &archive.ArgAids2{Aids: missed}
+		if tmp, err = d.arcRPC.Archives3(ctx, arg); err != nil {
+			log.Error("d.arcRPC.Archives3(%v) error(%v)", arg, err)
+			return
+		}
+		for aid, a := range tmp {
+			as[aid] = a
+		}
+		return
+	})
+	var stm map[int64]*api.Stat
+	g.Go(func() (err error) {
+		var missed []int64
+		if stm, missed, err = d.statsCache(ctx, aids); err != nil {
+			log.Error("%+v", err)
+			missed = aids
+			err = nil
+		}
+		if len(missed) == 0 {
+			return
+		}
+		var tmp map[int64]*api.Stat
+		arg := &archive.ArgAids2{Aids: missed}
+		if tmp, err = d.arcRPC.Stats3(ctx, arg); err != nil {
+			log.Error("d.arcRPC.Stats3(%v) error(%v)", arg, err)
+			err = nil
+			return
+		}
+		for aid, st := range tmp {
+			stm[aid] = st
+		}
+		return
+	})
+	if err = g.Wait(); err != nil {
+		return
+	}
+	for aid, a := range as {
+		if st, ok := stm[aid]; ok {
+			a.Stat = *st
+		}
+	}
+	return
+}
+
+// Archives2 multi get archives.
+func (d *Dao) Archives2(c context.Context, aids []int64) (am map[int64]*api.Arc, err error) {
+	if len(aids) == 0 {
+		return
+	}
+	var avMissed, stMissed []int64
+	if am, avMissed, stMissed, err = d.avWithStCaches(c, aids); err != nil {
+		avMissed = aids
+		log.Error("%+v", err)
+		err = nil
+	}
+	g, ctx := errgroup.WithContext(c)
+	if len(avMissed) != 0 {
+		g.Go(func() (err error) {
+			arg := &archive.ArgAids2{Aids: avMissed}
+			avm, err := d.arcRPC.Archives3(ctx, arg)
+			if err != nil {
+				err = errors.Wrapf(err, "%v", arg)
+				return
+			}
+			for aid, a := range avm {
+				am[aid] = a
+			}
+			return
+		})
+	}
+	var stm map[int64]*api.Stat
+	if len(stMissed) != 0 {
+		g.Go(func() error {
+			arg := &archive.ArgAids2{Aids: stMissed}
+			if stm, err = d.arcRPC.Stats3(ctx, arg); err != nil {
+				log.Error("d.arcRPC.Stats3(%v) error(%v)", arg, err)
+			}
+			return nil
+		})
+	}
+	if err = g.Wait(); err != nil {
+		return
+	}
+	for aid, a := range am {
+		if st, ok := stm[aid]; ok {
+			a.Stat = *st
+		}
+	}
+	return
+}

app/interface/main/app-interface/dao/archive/dao_test.go

@@ -0,0 +1,93 @@
+package archive
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-interface")
+		flag.Set("conf_token", "1mWvdEwZHmCYGoXJCVIdszBOPVdtpXb3")
+		flag.Set("tree_id", "2688")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/app-interface-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+	// time.Sleep(time.Second)
+}
+
+func TestUpArcs3(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		pn  = 1
+		ps  = 5
+	)
+	convey.Convey("UpArcs3", t, func(ctx convey.C) {
+		_, err := d.UpArcs3(c, mid, pn, ps)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestUpCount2(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("UpCount2", t, func(ctx convey.C) {
+		_, err := d.UpCount2(c, mid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestArchive(t *testing.T) {
+	var (
+		c    = context.TODO()
+		aids = []int64{1}
+	)
+	convey.Convey("Archives", t, func(ctx convey.C) {
+		_, err := d.Archives(c, aids)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestArchive2(t *testing.T) {
+	var (
+		c    = context.TODO()
+		aids = []int64{1}
+	)
+	convey.Convey("Archives2", t, func(ctx convey.C) {
+		_, err := d.Archives2(c, aids)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/app-interface/dao/archive/memcache.go

@@ -0,0 +1,164 @@
+package archive
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/service/main/archive/api"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_prefixArchive = "a3p_"
+	_prefixStat    = "stp_"
+)
+
+func keyArc(aid int64) string {
+	return _prefixArchive + strconv.FormatInt(aid, 10)
+}
+
+func keyStat(aid int64) string {
+	return _prefixStat + strconv.FormatInt(aid, 10)
+}
+
+// arcsCache get archives cache.
+func (d *Dao) arcsCache(c context.Context, aids []int64) (cached map[int64]*api.Arc, missed []int64, err error) {
+	cached = make(map[int64]*api.Arc, len(aids))
+	var rs map[string]*memcache.Item
+	conn := d.arcMc.Get(c)
+	keys := make([]string, 0, len(aids))
+	aidmap := make(map[string]int64, len(aids))
+	defer conn.Close()
+	for _, aid := range aids {
+		k := keyArc(aid)
+		if _, ok := aidmap[k]; !ok {
+			keys = append(keys, k)
+			aidmap[k] = aid
+		}
+	}
+	if rs, err = conn.GetMulti(keys); err != nil {
+		err = errors.Wrapf(err, "%v", keys)
+		return
+	}
+	for k, r := range rs {
+		a := &api.Arc{}
+		if err = conn.Scan(r, a); err != nil {
+			log.Error("conn.Scan(%s) error(%v)", r.Value, err)
+			err = nil
+			continue
+		}
+		cached[aidmap[k]] = a
+		// delete hit key
+		delete(aidmap, k)
+	}
+	// missed key
+	missed = make([]int64, 0, len(aidmap))
+	for _, aid := range aidmap {
+		missed = append(missed, aid)
+	}
+	return
+}
+
+// statsCache get stat cache by aids
+func (d *Dao) statsCache(c context.Context, aids []int64) (cached map[int64]*api.Stat, missed []int64, err error) {
+	cached = make(map[int64]*api.Stat, len(aids))
+	var rs map[string]*memcache.Item
+	conn := d.arcMc.Get(c)
+	keys := make([]string, 0, len(aids))
+	defer conn.Close()
+	for _, aid := range aids {
+		keys = append(keys, keyStat(aid))
+	}
+	if rs, err = conn.GetMulti(keys); err != nil {
+		err = errors.Wrapf(err, "%v", keys)
+		return
+	}
+	for _, r := range rs {
+		st := &api.Stat{}
+		if err = conn.Scan(r, st); err != nil {
+			log.Error("conn.Scan(%s) error(%v)", r.Value, err)
+			err = nil
+			continue
+		}
+		cached[st.Aid] = st
+	}
+	if len(cached) == len(aids) {
+		return
+	}
+	for _, aid := range aids {
+		if _, ok := cached[aid]; !ok {
+			missed = append(missed, aid)
+		}
+	}
+	return
+}
+
+func (d *Dao) avWithStCaches(c context.Context, aids []int64) (cached map[int64]*api.Arc, avMissed, stMissed []int64, err error) {
+	cached = make(map[int64]*api.Arc, len(aids))
+	conn := d.arcMc.Get(c)
+	defer conn.Close()
+	keys := make([]string, 0, len(aids)*2)
+	avm := make(map[string]int64, len(aids))
+	stm := make(map[string]int64, len(aids))
+	for _, aid := range aids {
+		ak := keyArc(aid)
+		if _, ok := avm[ak]; !ok {
+			keys = append(keys, ak)
+			avm[ak] = aid
+		}
+		sk := keyStat(aid)
+		if _, ok := stm[sk]; !ok {
+			keys = append(keys, sk)
+			stm[sk] = aid
+		}
+	}
+	rs, err := conn.GetMulti(keys)
+	if err != nil {
+		err = errors.Wrapf(err, "%v", keys)
+		return
+	}
+	stCached := make(map[string]*api.Stat, len(aids))
+	for k, r := range rs {
+		if aid, ok := avm[k]; ok {
+			a := &api.Arc{}
+			if err = conn.Scan(r, a); err != nil {
+				log.Error("conn.Scan(%s) error(%v)", r.Value, err)
+				err = nil
+				continue
+			}
+			cached[aid] = a
+			// delete hit key
+			delete(avm, k)
+		}
+		if _, ok := stm[k]; ok {
+			st := &api.Stat{}
+			if err = conn.Scan(r, st); err != nil {
+				log.Error("conn.Scan(%s) error(%v)", r.Value, err)
+				err = nil
+				continue
+			}
+			stCached[k] = st
+		}
+	}
+	for k, st := range stCached {
+		if a, ok := cached[st.Aid]; ok {
+			a.Stat = *st
+			// delete hit key
+			delete(stm, k)
+		}
+	}
+	// missed key
+	avMissed = make([]int64, 0, len(avm))
+	for _, aid := range avm {
+		avMissed = append(avMissed, aid)
+
+	}
+	stMissed = make([]int64, 0, len(stm))
+	for _, aid := range stm {
+		stMissed = append(stMissed, aid)
+	}
+	return
+}

app/interface/main/app-interface/dao/archive/memcache_test.go

@@ -0,0 +1,148 @@
+package archive
+
+import (
+	"context"
+	"go-common/app/service/main/archive/api"
+	"reflect"
+	"testing"
+)
+
+func Test_keyArc(t *testing.T) {
+	type args struct {
+		aid int64
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := keyArc(tt.args.aid); got != tt.want {
+				t.Errorf("keyArc() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_keyStat(t *testing.T) {
+	type args struct {
+		aid int64
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := keyStat(tt.args.aid); got != tt.want {
+				t.Errorf("keyStat() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDao_arcsCache(t *testing.T) {
+	type args struct {
+		c    context.Context
+		aids []int64
+	}
+	tests := []struct {
+		name       string
+		d          *Dao
+		args       args
+		wantCached map[int64]*api.Arc
+		wantMissed []int64
+		wantErr    bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotCached, gotMissed, err := tt.d.arcsCache(tt.args.c, tt.args.aids)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.arcsCache() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotCached, tt.wantCached) {
+				t.Errorf("Dao.arcsCache() gotCached = %v, want %v", gotCached, tt.wantCached)
+			}
+			if !reflect.DeepEqual(gotMissed, tt.wantMissed) {
+				t.Errorf("Dao.arcsCache() gotMissed = %v, want %v", gotMissed, tt.wantMissed)
+			}
+		})
+	}
+}
+
+func TestDao_statsCache(t *testing.T) {
+	type args struct {
+		c    context.Context
+		aids []int64
+	}
+	tests := []struct {
+		name       string
+		d          *Dao
+		args       args
+		wantCached map[int64]*api.Stat
+		wantMissed []int64
+		wantErr    bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotCached, gotMissed, err := tt.d.statsCache(tt.args.c, tt.args.aids)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.statsCache() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotCached, tt.wantCached) {
+				t.Errorf("Dao.statsCache() gotCached = %v, want %v", gotCached, tt.wantCached)
+			}
+			if !reflect.DeepEqual(gotMissed, tt.wantMissed) {
+				t.Errorf("Dao.statsCache() gotMissed = %v, want %v", gotMissed, tt.wantMissed)
+			}
+		})
+	}
+}
+
+func TestDao_avWithStCaches(t *testing.T) {
+	type args struct {
+		c    context.Context
+		aids []int64
+	}
+	tests := []struct {
+		name         string
+		d            *Dao
+		args         args
+		wantCached   map[int64]*api.Arc
+		wantAvMissed []int64
+		wantStMissed []int64
+		wantErr      bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotCached, gotAvMissed, gotStMissed, err := tt.d.avWithStCaches(tt.args.c, tt.args.aids)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.avWithStCaches() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotCached, tt.wantCached) {
+				t.Errorf("Dao.avWithStCaches() gotCached = %v, want %v", gotCached, tt.wantCached)
+			}
+			if !reflect.DeepEqual(gotAvMissed, tt.wantAvMissed) {
+				t.Errorf("Dao.avWithStCaches() gotAvMissed = %v, want %v", gotAvMissed, tt.wantAvMissed)
+			}
+			if !reflect.DeepEqual(gotStMissed, tt.wantStMissed) {
+				t.Errorf("Dao.avWithStCaches() gotStMissed = %v, want %v", gotStMissed, tt.wantStMissed)
+			}
+		})
+	}
+}

app/interface/main/app-interface/dao/article/BUILD

@@ -0,0 +1,48 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/article",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/interface/openplatform/article/rpc/client:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/article/dao.go

@@ -0,0 +1,77 @@
+package article
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-interface/conf"
+	article "go-common/app/interface/openplatform/article/model"
+	artrpc "go-common/app/interface/openplatform/article/rpc/client"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is atticle dao
+type Dao struct {
+	artRPC *artrpc.Service
+}
+
+// New initial tag dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		artRPC: artrpc.New(c.ArticleRPC),
+	}
+	return
+}
+
+// UpArticles get article data from api.
+func (d *Dao) UpArticles(c context.Context, mid int64, pn, ps int) (ams []*article.Meta, count int, err error) {
+	var (
+		res *article.UpArtMetas
+		ip  = metadata.String(c, metadata.RemoteIP)
+	)
+	arg := &article.ArgUpArts{Mid: mid, Pn: pn, Ps: ps, RealIP: ip}
+	if res, err = d.artRPC.UpArtMetas(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+		return
+	}
+	if res != nil {
+		ams = res.Articles
+		count = res.Count
+	}
+	return
+}
+
+// Favorites get article data from api.
+func (d *Dao) Favorites(c context.Context, mid int64, pn, ps int) (res []*article.Favorite, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &article.ArgFav{Mid: mid, Pn: pn, Ps: ps, RealIP: ip}
+	if res, err = d.artRPC.Favorites(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) Articles(c context.Context, aids []int64) (res map[int64]*article.Meta, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &article.ArgAids{Aids: aids, RealIP: ip}
+	if res, err = d.artRPC.ArticleMetas(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) UpLists(c context.Context, mid int64) (lists []*article.List, count int, err error) {
+	var (
+		res article.UpLists
+		ip  = metadata.String(c, metadata.RemoteIP)
+	)
+	arg := &article.ArgMid{Mid: mid, RealIP: ip}
+	if res, err = d.artRPC.UpLists(c, arg); err != nil {
+		err = errors.Wrapf(err, "%+v", arg)
+		return
+	}
+	lists = res.Lists
+	count = res.Total
+	return
+}

app/interface/main/app-interface/dao/article/dao_test.go

@@ -0,0 +1,36 @@
+package article
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-interface-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+}
+
+func TestUpArticles(t *testing.T) {
+	Convey("TestUpArticles", t, func() {
+		d.UpArticles(context.TODO(), 1, 1, 1)
+	})
+}
+
+func TestNew(t *testing.T) {
+	Convey("new", t, func() {
+		d := New(&conf.Config{})
+		So(d, ShouldNotBeNil)
+	})
+}

app/interface/main/app-interface/dao/audio/BUILD

@@ -0,0 +1,52 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/audio:go_default_library",
+        "//library/net/ip:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/audio",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/audio:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/audio/dao.go

@@ -0,0 +1,201 @@
+package audio
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/audio"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_audios      = "/audio/music-service-c/songs/internal/upsongslist"
+	_allAudio    = "/audio/music-service-c/songs/internal/uppersongs-preload"
+	_audioDetail = "/audio/music-service-c/songs/internal/uppersongs-batch"
+	_favAudio    = "/audio/music-service-c/collections"
+	_upperCert   = "/audio/music-service-c/internal/upper-cert"
+	_card        = "/x/internal/v1/audio/privilege/mcard"
+	_fav         = "/x/internal/v1/audio/personal/coll"
+)
+
+type Dao struct {
+	client      *httpx.Client
+	audios      string
+	allAudio    string
+	audioDetail string
+	favAudio    string
+	upperCert   string
+	card        string
+	fav         string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:      httpx.NewClient(c.HTTPClient),
+		audios:      c.Host.APICo + _audios,
+		allAudio:    c.Host.APICo + _allAudio,
+		audioDetail: c.Host.APICo + _audioDetail,
+		favAudio:    c.Host.APICo + _favAudio,
+		upperCert:   c.Host.APICo + _upperCert,
+		card:        c.Host.APICo + _card,
+		fav:         c.Host.APICo + _fav,
+	}
+	return
+}
+
+// Audios
+func (d *Dao) Audios(c context.Context, mid int64, pn, ps int) (audios []*audio.Audio, total int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	params.Set("pageIndex", strconv.Itoa(pn))
+	params.Set("pageSize", strconv.Itoa(ps))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Total int            `json:"total"`
+			List  []*audio.Audio `json:"list"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.audios, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.audios+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		total = res.Data.Total
+		audios = res.Data.List
+	}
+	return
+}
+
+// AllAudio get 100 audio by ctime desc
+func (d *Dao) AllAudio(c context.Context, vmid int64) (aus []*audio.Audio, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(vmid, 10))
+	var res struct {
+		Code int            `json:"code"`
+		Data []*audio.Audio `json:"data"`
+	}
+	if err = d.client.Get(c, d.allAudio, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.allAudio+"?"+params.Encode())
+		return
+	}
+	aus = res.Data
+	return
+}
+
+func (d *Dao) AudioDetail(c context.Context, ids []int64) (aum map[int64]*audio.Audio, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("ids", xstr.JoinInts(ids))
+	var res struct {
+		Code int                    `json:"code"`
+		Data map[int64]*audio.Audio `json:"data"`
+	}
+	if err = d.client.Get(c, d.audioDetail, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.audioDetail+"?"+params.Encode())
+		return
+	}
+	aum = res.Data
+	return
+}
+
+func (d *Dao) FavAudio(c context.Context, accessKey string, mid int64, pn, ps int) (aus []*audio.FavAudio, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("access_key", accessKey)
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("sort", "-1")
+	params.Set("page_index", strconv.Itoa(pn))
+	params.Set("page_size", strconv.Itoa(ps))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			List []*audio.FavAudio `json:"list"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.favAudio, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.favAudio+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		aus = res.Data.List
+	}
+	return
+}
+
+func (d *Dao) UpperCert(c context.Context, uid int64) (cert *audio.UpperCert, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(uid, 10))
+	var res struct {
+		Code int              `json:"code"`
+		Data *audio.UpperCert `json:"data"`
+	}
+	if err = d.client.Get(c, d.upperCert, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.upperCert+"?"+params.Encode())
+		return
+	}
+	cert = res.Data
+	return
+}
+
+func (d *Dao) Card(c context.Context, mid ...int64) (cardm map[int64]*audio.Card, err error) {
+	params := url.Values{}
+	params.Set("mid", xstr.JoinInts(mid))
+	var res struct {
+		Code int                   `json:"code"`
+		Data map[int64]*audio.Card `json:"data"`
+	}
+	if err = d.client.Get(c, d.card, "", params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.card+"?"+params.Encode())
+		return
+	}
+	cardm = res.Data
+	return
+}
+
+func (d *Dao) Fav(c context.Context, mid int64) (fav *audio.Fav, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int        `json:"code"`
+		Data *audio.Fav `json:"data"`
+	}
+	if err = d.client.Get(c, d.fav, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.fav+"?"+params.Encode())
+		return
+	}
+	fav = res.Data
+	return
+}

app/interface/main/app-interface/dao/audio/dao_test.go

@@ -0,0 +1,246 @@
+package audio
+
+import (
+	"context"
+	"flag"
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/audio"
+	"go-common/library/net/ip"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-interface-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+}
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotD := New(tt.args.c); !reflect.DeepEqual(gotD, tt.wantD) {
+				t.Errorf("New() = %v, want %v", gotD, tt.wantD)
+			}
+		})
+	}
+}
+
+func TestDao_Audios(t *testing.T) {
+	type args struct {
+		c   context.Context
+		mid int64
+		pn  int
+		ps  int
+	}
+	tests := []struct {
+		name       string
+		args       args
+		wantAudios []*audio.Audio
+		wantTotal  int
+		wantErr    bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotAudios, gotTotal, err := d.Audios(tt.args.c, tt.args.mid, tt.args.pn, tt.args.ps)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.Audios() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotAudios, tt.wantAudios) {
+				t.Errorf("Dao.Audios() gotAudios = %v, want %v", gotAudios, tt.wantAudios)
+			}
+			if gotTotal != tt.wantTotal {
+				t.Errorf("Dao.Audios() gotTotal = %v, want %v", gotTotal, tt.wantTotal)
+			}
+		})
+	}
+}
+
+func TestDao_AllAudio(t *testing.T) {
+	type args struct {
+		c    context.Context
+		vmid int64
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantAus []*audio.Audio
+		wantErr bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotAus, err := d.AllAudio(tt.args.c, tt.args.vmid)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.AllAudio() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotAus, tt.wantAus) {
+				t.Errorf("Dao.AllAudio() = %v, want %v", gotAus, tt.wantAus)
+			}
+		})
+	}
+}
+
+func TestDao_AudioDetail(t *testing.T) {
+	type args struct {
+		c   context.Context
+		ids []int64
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantAum map[int64]*audio.Audio
+		wantErr bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotAum, err := d.AudioDetail(tt.args.c, tt.args.ids)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.AudioDetail() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotAum, tt.wantAum) {
+				t.Errorf("Dao.AudioDetail() = %v, want %v", gotAum, tt.wantAum)
+			}
+		})
+	}
+}
+
+func TestDao_FavAudio(t *testing.T) {
+	type args struct {
+		c         context.Context
+		accessKey string
+		mid       int64
+		pn        int
+		ps        int
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantAus []*audio.FavAudio
+		wantErr bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotAus, err := d.FavAudio(tt.args.c, tt.args.accessKey, tt.args.mid, tt.args.pn, tt.args.ps)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.FavAudio() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotAus, tt.wantAus) {
+				t.Errorf("Dao.FavAudio() = %v, want %v", gotAus, tt.wantAus)
+			}
+		})
+	}
+}
+
+func TestDao_UpperCert(t *testing.T) {
+	type args struct {
+		c   context.Context
+		uid int64
+	}
+	tests := []struct {
+		name     string
+		args     args
+		wantCert *audio.UpperCert
+		wantErr  bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotCert, err := d.UpperCert(tt.args.c, tt.args.uid)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.UpperCert() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotCert, tt.wantCert) {
+				t.Errorf("Dao.UpperCert() = %v, want %v", gotCert, tt.wantCert)
+			}
+		})
+	}
+}
+
+func TestDao_Card(t *testing.T) {
+	type args struct {
+		c   context.Context
+		ip  string
+		mid []int64
+	}
+	tests := []struct {
+		name      string
+		args      args
+		wantCardm map[int64]*audio.Card
+		wantErr   error
+	}{
+		{
+			"normal",
+			args{
+				context.TODO(),
+				ip.InternalIP(),
+				[]int64{30047},
+			},
+			map[int64]*audio.Card{30047: &audio.Card{Type: 1, Status: 1}},
+			nil,
+		},
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotCardm, err := d.Card(tt.args.c, tt.args.mid...)
+			So(err, ShouldBeNil)
+			So(gotCardm, ShouldResemble, tt.wantCardm)
+		})
+	}
+}
+
+func TestDao_Fav(t *testing.T) {
+	type args struct {
+		c   context.Context
+		mid int64
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantFav *audio.Fav
+		wantErr bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotFav, err := d.Fav(tt.args.c, tt.args.mid)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.Fav() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotFav, tt.wantFav) {
+				t.Errorf("Dao.Fav() = %v, want %v", gotFav, tt.wantFav)
+			}
+		})
+	}
+}

app/interface/main/app-interface/dao/bangumi/BUILD

@@ -0,0 +1,55 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "grpc.go",
+    ],
+    importpath = "go-common/app/interface/main/app-interface/dao/bangumi",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/bangumi:go_default_library",
+        "//app/service/openplatform/pgc-season/api/grpc/season/v1:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/bangumi/dao.go

@@ -0,0 +1,226 @@
+package bangumi
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/bangumi"
+	seasongrpc "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_season     = "/api/inner/season"
+	_movie      = "/internal_api/movie_aid_info"
+	_bp         = "/sponsor/inner/xAjaxGetBP"
+	_concern    = "/api/get_concerned_season"
+	_hasFollows = "/follow/internal_api/has_follows"
+	_card       = "/pgc/internal/season/search/card"
+	_favDisplay = "/pgc/internal/follow/app/tab/view"
+)
+
+// Dao is bangumi dao
+type Dao struct {
+	client     *httpx.Client
+	season     string
+	movie      string
+	bp         string
+	concern    string
+	hasFollows string
+	card       string
+	favDisplay string
+	// grpc
+	rpcClient seasongrpc.SeasonClient
+}
+
+// New bangumi dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:     httpx.NewClient(c.HTTPBangumi),
+		season:     c.Host.Bangumi + _season,
+		movie:      c.Host.Bangumi + _movie,
+		bp:         c.Host.Bangumi + _bp,
+		concern:    c.Host.Bangumi + _concern,
+		hasFollows: c.Host.Bangumi + _hasFollows,
+		card:       c.Host.APICo + _card,
+		favDisplay: c.Host.APICo + _favDisplay,
+	}
+	var err error
+	if d.rpcClient, err = seasongrpc.NewClient(c.PGCRPC); err != nil {
+		log.Error("seasongrpc NewClientt error(%v)", err)
+	}
+	return
+}
+
+// Season bangumi Season.
+func (d *Dao) Season(c context.Context, aid, mid int64, ip string) (s *bangumi.Season, err error) {
+	params := url.Values{}
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("type", "av")
+	params.Set("build", "app-interface")
+	params.Set("platform", "Golang")
+	var res struct {
+		Code   int             `json:"code"`
+		Result *bangumi.Season `json:"result"`
+	}
+	if err = d.client.Get(c, d.season, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.season+"?"+params.Encode())
+		return
+	}
+	s = res.Result
+	return
+}
+
+// BPInfo get bp info data.
+func (d *Dao) BPInfo(c context.Context, aid, mid int64, ip string) (data json.RawMessage, err error) {
+	params := url.Values{}
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("build", "app-interface")
+	params.Set("platform", "Golang")
+	var res struct {
+		Code int             `json:"code"`
+		Data json.RawMessage `json:"data"`
+	}
+	if err = d.client.Get(c, d.bp, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.bp+"?"+params.Encode())
+		return
+	}
+	data = res.Data
+	return
+}
+
+// Movie bangumi Movie
+func (d *Dao) Movie(c context.Context, aid, mid int64, build int, mobiApp, device, ip string) (m *bangumi.Movie, err error) {
+	params := url.Values{}
+	params.Set("id", strconv.FormatInt(aid, 10))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("build", strconv.Itoa(build))
+	params.Set("device", device)
+	params.Set("mobi_app", mobiApp)
+	params.Set("platform", "Golang")
+	var res struct {
+		Code   int            `json:"code"`
+		Result *bangumi.Movie `json:"result"`
+	}
+	if err = d.client.Get(c, d.movie, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.movie+"?"+params.Encode())
+		return
+	}
+	m = res.Result
+	return
+}
+
+// Concern get concern data from api.
+func (d *Dao) Concern(c context.Context, mid, vmid int64, pn, ps int) (ss []*bangumi.Season, total int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("taid", strconv.FormatInt(vmid, 10))
+	params.Set("page", strconv.Itoa(pn))
+	params.Set("pagesize", strconv.Itoa(ps))
+	params.Set("build", "app-interface")
+	params.Set("platform", "Golang")
+	var res struct {
+		Code   int               `json:"code"`
+		Total  string            `json:"count"`
+		Result []*bangumi.Season `json:"result"`
+	}
+	if err = d.client.Get(c, d.concern, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.concern+"?"+params.Encode())
+		return
+	}
+	ss = res.Result
+	total, _ = strconv.Atoi(res.Total)
+	return
+}
+
+// HasFollows get bngumi tab.
+func (d *Dao) HasFollows(c context.Context, mid int64) (has bool, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("type", "2,3,5")
+	var res struct {
+		Code   int `json:"code"`
+		Result int `json:"result"`
+	}
+	if err = d.client.Get(c, d.hasFollows, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.hasFollows+"?"+params.Encode())
+		return
+	}
+	if res.Result == 1 {
+		has = true
+	}
+	return
+}
+
+// Card bangumi card.
+func (d *Dao) Card(c context.Context, mid int64, sids []int64) (s map[string]*bangumi.Card, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("season_ids", xstr.JoinInts(sids))
+	var res struct {
+		Code   int                      `json:"code"`
+		Result map[string]*bangumi.Card `json:"result"`
+	}
+	if err = d.client.Get(c, d.card, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.card+"?"+params.Encode())
+		return
+	}
+	s = res.Result
+	return
+}
+
+// FavDisplay fav tab display or not.
+func (d *Dao) FavDisplay(c context.Context, mid int64) (bangumi, cinema int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code   int `json:"code"`
+		Result struct {
+			Bangumi int `json:"bangumi"`
+			Cinema  int `json:"cinema"`
+		} `json:"result"`
+	}
+	if err = d.client.Get(c, d.favDisplay, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.favDisplay+"?"+params.Encode())
+		return
+	}
+	bangumi = res.Result.Bangumi
+	cinema = res.Result.Cinema
+	return
+}

app/interface/main/app-interface/dao/bangumi/dao_test.go

@@ -0,0 +1,123 @@
+package bangumi
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-interface")
+		flag.Set("conf_token", "1mWvdEwZHmCYGoXJCVIdszBOPVdtpXb3")
+		flag.Set("tree_id", "2688")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}
+
+// go test -conf="../../app-interface-example.toml"  -v -test.run TestSeason
+func TestSeason(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		aid = int64(1)
+		ip  = ""
+	)
+	convey.Convey("Season", t, func(ctx convey.C) {
+		_, err := d.Season(c, aid, mid, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			err = nil
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+// go test -conf="../../app-interface-example.toml"  -v -test.run TestBPInfo
+func TestBPInfo(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		aid = int64(1)
+		ip  = ""
+	)
+	convey.Convey("BPInfo", t, func(ctx convey.C) {
+		_, err := d.BPInfo(c, aid, mid, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			err = nil
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+// go test -conf="../../app-interface-example.toml"  -v -test.run TestMovie
+func TestMovie(t *testing.T) {
+	var (
+		c         = context.TODO()
+		mid       = int64(1)
+		aid       = int64(1)
+		build     = 123
+		mobileApp = "android"
+		device    = "android"
+		ip        = ""
+	)
+	convey.Convey("Movie", t, func(ctx convey.C) {
+		_, err := d.Movie(c, aid, mid, build, mobileApp, device, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			err = nil
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+// go test -conf="../../app-interface-example.toml"  -v -test.run TestConcern
+func TestConcern(t *testing.T) {
+	var (
+		c    = context.TODO()
+		mid  = int64(1)
+		vmid = int64(1)
+		pn   = 1
+		ps   = 5
+	)
+	convey.Convey("Concern", t, func(ctx convey.C) {
+		_, _, err := d.Concern(c, mid, vmid, pn, ps)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			err = nil
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestFavDisplay(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("Concern", t, func(ctx convey.C) {
+		_, _, err := d.FavDisplay(c, mid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			err = nil
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/app-interface/dao/bangumi/grpc.go

@@ -0,0 +1,22 @@
+package bangumi
+
+import (
+	"context"
+
+	seasongrpc "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1"
+	"go-common/library/log"
+)
+
+// Cards get bangumis.
+func (d *Dao) Cards(ctx context.Context, seasonIds []int32) (res map[int32]*seasongrpc.CardInfoProto, err error) {
+	arg := &seasongrpc.SeasonInfoReq{
+		SeasonIds: seasonIds,
+	}
+	info, err := d.rpcClient.Cards(ctx, arg)
+	if err != nil {
+		log.Error("d.rpcClient.Cards error(%v)", err)
+		return nil, err
+	}
+	res = info.Cards
+	return
+}

app/interface/main/app-interface/dao/bplus/BUILD

@@ -0,0 +1,70 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "api_test.go",
+        "dao_test.go",
+        "databus_test.go",
+        "redis_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model:go_default_library",
+        "//app/interface/main/app-interface/model/space:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+        "//vendor/gopkg.in/h2non/gock.v1:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "dao.go",
+        "databus.go",
+        "redis.go",
+    ],
+    importpath = "go-common/app/interface/main/app-interface/dao/bplus",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model:go_default_library",
+        "//app/interface/main/app-interface/model/bplus:go_default_library",
+        "//app/interface/main/app-interface/model/space:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//library/time:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/bplus/api.go

@@ -0,0 +1,381 @@
+package bplus
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/model/bplus"
+	"go-common/library/ecode"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_favorPlus     = "/user_ex/v1/Fav/getFavList"
+	_clips         = "/clip/v1/video/blist"
+	_allbums       = "/link_draw/v1/Doc/photo_list_ones"
+	_allClip       = "/clip_ext/v1/video/all"
+	_allAlbum      = "/link_draw/v1/Doc/photo_all_ones"
+	_clipDetail    = "/clip_ext/v0/video/getDetailForSpace"
+	_albumDetail   = "/link_draw_ex/v0/Doc/details"
+	_groupsCount   = "/link_group/v1/member/created_groups_num"
+	_dynamic       = "/dynamic_svr/v0/dynamic_svr/space_intro"
+	_dunamicCount  = "/dynamic_svr/v0/dynamic_svr/space_dy_num"
+	_dynamicDetail = "/dynamic_detail/v0/Dynamic/details"
+)
+
+// DynamicCount return dynamic count
+func (d *Dao) DynamicCount(c context.Context, mid int64) (count int64, err error) {
+	params := url.Values{}
+	params.Set("uids", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Items []struct {
+				Mid int64 `json:"uid"`
+				Num int64 `json:"num"`
+			} `json:"items"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.dynamicCount, "", params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.dynamicCount+"?"+params.Encode())
+		return
+	}
+	if len(res.Data.Items) == 0 {
+		return
+	}
+	for _, item := range res.Data.Items {
+		if item.Mid != mid {
+			continue
+		}
+		count = item.Num
+		break
+	}
+	return
+}
+
+// FavClips get fav from B+ api.
+func (d *Dao) FavClips(c context.Context, mid int64, accessKey, actionKey, device, mobiApp, platform string, build, pn, ps int) (cs *bplus.Clips, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	params.Set("access_key", accessKey)
+	params.Set("actionKey", actionKey)
+	params.Set("build", strconv.Itoa(build))
+	params.Set("device", device)
+	params.Set("mobi_app", mobiApp)
+	params.Set("platform", platform)
+	params.Set("biz_type", strconv.Itoa(bplus.CLIPS))
+	params.Set("page", strconv.Itoa(pn))
+	params.Set("pagesize", strconv.Itoa(ps))
+	var res struct {
+		Code    int          `json:"code"`
+		Msg     string       `json:"msg"`
+		Message string       `json:"message"`
+		Data    *bplus.Clips `json:"data"`
+	}
+	if err = d.client.Get(c, d.favorPlus, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.favorPlus+"?"+params.Encode())
+		return
+	}
+	cs = res.Data
+	return
+}
+
+// FavAlbums get fav from B+ api.
+func (d *Dao) FavAlbums(c context.Context, mid int64, accessKey, actionKey, device, mobiApp, platform string, build, pn, ps int) (as *bplus.Albums, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	params.Set("access_key", accessKey)
+	params.Set("actionKey", actionKey)
+	params.Set("build", strconv.Itoa(build))
+	params.Set("device", device)
+	params.Set("mobi_app", mobiApp)
+	params.Set("platform", platform)
+	params.Set("biz_type", strconv.Itoa(bplus.ALBUMS))
+	params.Set("page", strconv.Itoa(pn))
+	params.Set("pagesize", strconv.Itoa(ps))
+	var res struct {
+		Code    int           `json:"code"`
+		Msg     string        `json:"msg"`
+		Message string        `json:"message"`
+		Data    *bplus.Albums `json:"data"`
+	}
+	if err = d.client.Get(c, d.favorPlus, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.favorPlus+"?"+params.Encode())
+		return
+	}
+	as = res.Data
+	return
+}
+
+// Clips .
+func (d *Dao) Clips(c context.Context, vmid int64, pos, size int) (cs []*bplus.Clip, more, offset int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(vmid, 10))
+	params.Set("next_offset", strconv.Itoa(pos))
+	params.Set("page_size", strconv.Itoa(size))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			More   int           `json:"has_more"`
+			Offset int           `json:"next_offset"`
+			Item   []*bplus.Clip `json:"items"`
+		}
+	}
+	if err = d.client.Get(c, d.clips, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.clips+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		cs = res.Data.Item
+		more = res.Data.More
+		offset = res.Data.Offset
+	}
+	return
+}
+
+// Albums get album list form api .
+func (d *Dao) Albums(c context.Context, vmid int64, pos, size int) (as []*bplus.Album, more, offset int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(vmid, 10))
+	params.Set("next_offset", strconv.Itoa(pos))
+	params.Set("page_size", strconv.Itoa(size))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			More   int            `json:"has_more"`
+			Offset int            `json:"next_offset"`
+			Item   []*bplus.Album `json:"items"`
+		}
+	}
+	if err = d.client.Get(c, d.albums, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.albums+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		as = res.Data.Item
+		more = res.Data.More
+		offset = res.Data.Offset
+	}
+	return
+}
+
+// AllClip .
+func (d *Dao) AllClip(c context.Context, vmid int64, size int) (cs []*bplus.Clip, count int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(vmid, 10))
+	params.Set("page_size", strconv.Itoa(size))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Count int           `json:"total_count"`
+			Item  []*bplus.Clip `json:"items"`
+		}
+	}
+	if err = d.client.Get(c, d.allClip, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.allClip+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		cs = res.Data.Item
+		count = res.Data.Count
+	}
+	return
+}
+
+// AllAlbum .
+func (d *Dao) AllAlbum(c context.Context, vmid int64, size int) (as []*bplus.Album, count int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(vmid, 10))
+	params.Set("page_size", strconv.Itoa(size))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Count int            `json:"total_count"`
+			Item  []*bplus.Album `json:"items"`
+		}
+	}
+	if err = d.client.Get(c, d.allAlbum, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.allAlbum+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		as = res.Data.Item
+		count = res.Data.Count
+	}
+	return
+}
+
+// ClipDetail .
+func (d *Dao) ClipDetail(c context.Context, ids []int64) (cs map[int64]*bplus.Clip, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("ids", xstr.JoinInts(ids))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Item []*bplus.Clip `json:"items"`
+		}
+	}
+	if err = d.client.Get(c, d.clipDetail, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.clipDetail+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		cs = make(map[int64]*bplus.Clip, len(res.Data.Item))
+		for _, clip := range res.Data.Item {
+			cs[clip.ID] = clip
+		}
+	}
+	return
+}
+
+// AlbumDetail .
+func (d *Dao) AlbumDetail(c context.Context, vmid int64, ids []int64) (as map[int64]*bplus.Album, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(vmid, 10))
+	params.Set("ids", xstr.JoinInts(ids))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Item []*bplus.Album `json:"items"`
+		}
+	}
+	if err = d.client.Get(c, d.albumDetail, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.albumDetail+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		as = make(map[int64]*bplus.Album, len(res.Data.Item))
+		for _, album := range res.Data.Item {
+			as[album.ID] = album
+		}
+	}
+	return
+}
+
+// GroupsCount .
+func (d *Dao) GroupsCount(c context.Context, mid, vmid int64) (count int, err error) {
+	var (
+		req *http.Request
+		ip  = metadata.String(c, metadata.RemoteIP)
+	)
+	params := url.Values{}
+	params.Set("master_uid", strconv.FormatInt(vmid, 10))
+	if req, err = d.client.NewRequest(http.MethodGet, d.groupsCount, ip, params); err != nil {
+		return
+	}
+	req.Header.Set("X-BiliLive-UID", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Num int `json:"num"`
+		}
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		err = errors.Wrapf(err, "url(%s) header(X-BiliLive-UID:%s)", req.URL.String(), req.Header.Get("X-BiliLive-UID"))
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrapf(ecode.Int(res.Code), "url(%s) header(X-BiliLive-UID:%s)", req.URL.String(), req.Header.Get("X-BiliLive-UID"))
+		return
+	}
+	if res.Data != nil {
+		count = res.Data.Num
+	}
+	return
+}
+
+// Dynamic .
+func (d *Dao) Dynamic(c context.Context, uid int64) (has bool, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(uid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Reuslt int `json:"result"`
+		}
+	}
+	if err = d.client.Get(c, d.dynamic, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.dynamic+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil && res.Data.Reuslt == 1 {
+		has = true
+	}
+	return
+}
+
+// DynamicDetails get dynamic details by ids.
+func (d *Dao) DynamicDetails(c context.Context, ids []int64, from string) (details map[int64]*bplus.Detail, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("from", from)
+	for _, id := range ids {
+		params.Add("dynamic_ids[]", strconv.FormatInt(id, 10))
+	}
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			List []*bplus.Detail `json:"list"`
+		} `json:"data"`
+	}
+	details = make(map[int64]*bplus.Detail)
+	if err = d.client.Get(c, d.dynamicDetail, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.dynamicDetail+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		for _, detail := range res.Data.List {
+			if detail.ID != 0 {
+				details[detail.ID] = detail
+			}
+		}
+	}
+	return
+}

app/interface/main/app-interface/dao/bplus/api_test.go

@@ -0,0 +1,115 @@
+package bplus
+
+import (
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// TestDynamicCount dao ut.
+func TestDynamicCount(t *testing.T) {
+	Convey("get DynamicCount", t, func() {
+		_, err := dao.DynamicCount(ctx(), 27515258)
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestFavClips dao ut.
+func TestFavClips(t *testing.T) {
+	Convey("get FavClips", t, func() {
+		_, err := dao.FavClips(ctx(), 27515258, "da6863c38e83fc7a035c8f7a7d9b1c11", "appkey", "phone", "iphone", "ios", 8230, 1, 20)
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestFavAlbums dao ut.
+func TestFavAlbums(t *testing.T) {
+	Convey("get FavAlbums", t, func() {
+		_, err := dao.FavAlbums(ctx(), 27515258, "da6863c38e83fc7a035c8f7a7d9b1c11", "appkey", "phone", "iphone", "ios", 8230, 1, 20)
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestClips dao ut.
+func TestClips(t *testing.T) {
+	Convey("get Clips", t, func() {
+		_, _, _, err := dao.Clips(ctx(), 27515258, 1, 20)
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestAlbums dao ut.
+func TestAlbums(t *testing.T) {
+	Convey("get Albums", t, func() {
+		_, _, _, err := dao.Albums(ctx(), 27515258, 1, 20)
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestAllClip dao ut.
+func TestAllClip(t *testing.T) {
+	Convey("get AllClip", t, func() {
+		_, _, err := dao.AllClip(ctx(), 27515258, 20)
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestAllAlbum dao ut.
+func TestAllAlbum(t *testing.T) {
+	Convey("get AllAlbum", t, func() {
+		_, _, err := dao.AllAlbum(ctx(), 27515258, 20)
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestClipDetail dao ut.
+func TestClipDetail(t *testing.T) {
+	Convey("get ClipDetail", t, func() {
+		_, err := dao.ClipDetail(ctx(), []int64{27515258})
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestAlbumDetail dao ut.
+func TestAlbumDetail(t *testing.T) {
+	Convey("get AlbumDetail", t, func() {
+		_, err := dao.AlbumDetail(ctx(), 27515258, []int64{27515258})
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestGroupsCount dao ut.
+func TestGroupsCount(t *testing.T) {
+	Convey("get GroupsCount", t, func() {
+		_, err := dao.GroupsCount(ctx(), 27515258, 27515258)
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestDynamic dao ut.
+func TestDynamic(t *testing.T) {
+	Convey("get Dynamic", t, func() {
+		_, err := dao.Dynamic(ctx(), 27515258)
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestDynamicDetails dao ut.
+func TestDynamicDetails(t *testing.T) {
+	Convey("get DynamicDetails", t, func() {
+		_, err := dao.DynamicDetails(ctx(), []int64{27515258}, "search")
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-interface/dao/bplus/dao.go

@@ -0,0 +1,49 @@
+package bplus
+
+import (
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/library/cache/redis"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/queue/databus"
+)
+
+// Dao is favorite dao
+type Dao struct {
+	client        *httpx.Client
+	favorPlus     string
+	clips         string
+	albums        string
+	allClip       string
+	allAlbum      string
+	clipDetail    string
+	albumDetail   string
+	groupsCount   string
+	dynamic       string
+	dynamicCount  string
+	dynamicDetail string
+	// redis
+	redis *redis.Pool
+	// databus
+	pub *databus.Databus
+}
+
+// New initial favorite dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:        httpx.NewClient(c.HTTPBPlus),
+		favorPlus:     c.Host.APILiveCo + _favorPlus,
+		clips:         c.Host.VC + _clips,
+		albums:        c.Host.VC + _allbums,
+		allClip:       c.Host.VC + _allClip,
+		allAlbum:      c.Host.VC + _allAlbum,
+		clipDetail:    c.Host.VC + _clipDetail,
+		albumDetail:   c.Host.VC + _albumDetail,
+		groupsCount:   c.Host.VC + _groupsCount,
+		dynamic:       c.Host.VC + _dynamic,
+		dynamicCount:  c.Host.VC + _dunamicCount,
+		dynamicDetail: c.Host.VC + _dynamicDetail,
+		redis:         redis.NewPool(c.Redis.Contribute.Config),
+		pub:           databus.New(c.ContributePub),
+	}
+	return
+}

app/interface/main/app-interface/dao/bplus/dao_test.go

@@ -0,0 +1,51 @@
+package bplus
+
+import (
+	"context"
+	"flag"
+	"go-common/app/interface/main/app-interface/conf"
+	"os"
+	"strings"
+	"testing"
+	// "go-common/app/interface/main/app-interface/model/search"
+
+	"gopkg.in/h2non/gock.v1"
+)
+
+var (
+	dao *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+// TestMain dao ut.
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-interface")
+		flag.Set("conf_token", "1mWvdEwZHmCYGoXJCVIdszBOPVdtpXb3")
+		flag.Set("tree_id", "2688")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/app-interface-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	dao = New(conf.Conf)
+	os.Exit(m.Run())
+	// time.Sleep(time.Second)
+}
+
+func httpMock(method, url string) *gock.Request {
+	r := gock.New(url)
+	r.Method = strings.ToUpper(method)
+	return r
+}

app/interface/main/app-interface/dao/bplus/databus.go

@@ -0,0 +1,27 @@
+package bplus
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/model/space"
+	"go-common/library/net/metadata"
+	xtime "go-common/library/time"
+
+	"github.com/pkg/errors"
+)
+
+// NotifyContribute .
+func (d *Dao) NotifyContribute(c context.Context, vmid int64, attrs *space.Attrs, ctime xtime.Time) (err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	value := struct {
+		Vmid  int64        `json:"vmid"`
+		Attrs *space.Attrs `json:"attrs"`
+		CTime xtime.Time   `json:"ctime"`
+		IP    string       `json:"ip"`
+	}{vmid, attrs, ctime, ip}
+	if err = d.pub.Send(c, strconv.FormatInt(vmid, 10), value); err != nil {
+		err = errors.Wrapf(err, "%v", value)
+	}
+	return
+}

app/interface/main/app-interface/dao/bplus/databus_test.go

@@ -0,0 +1,21 @@
+package bplus
+
+import (
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-interface/model/space"
+	xtime "go-common/library/time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// TestNotifyContribute dao ut.
+func TestNotifyContribute(t *testing.T) {
+	Convey("get DynamicCount", t, func() {
+		var attrs *space.Attrs
+		err := dao.NotifyContribute(ctx(), 27515258, attrs, xtime.Time(time.Now().Unix()))
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-interface/dao/bplus/redis.go

@@ -0,0 +1,206 @@
+package bplus
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/model"
+	"go-common/app/interface/main/app-interface/model/space"
+	"go-common/library/cache/redis"
+	"go-common/library/log"
+	xtime "go-common/library/time"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_prefixContributeAttr = "cba_"
+	_prefixContribute     = "cb_"
+)
+
+func keyContributeAttr(vmid int64) string {
+	return _prefixContributeAttr + strconv.FormatInt(vmid, 10)
+}
+
+func keyContribute(vmid int64) string {
+	return _prefixContribute + strconv.FormatInt(vmid, 10)
+}
+
+// AddContributeCache .
+func (d *Dao) AddContributeCache(c context.Context, vmid int64, attrs *space.Attrs, items []*space.Item) (err error) {
+	var attr int32
+	conn := d.redis.Get(c)
+	key := keyContribute(vmid)
+	defer conn.Close()
+	for _, item := range items {
+		score := item.CTime.Time().Unix()
+		item.FormatKey()
+		if err = conn.Send("ZADD", key, score, item.Member); err != nil {
+			err = errors.Wrapf(err, "conn.Send(ZADD,%s,%d,%d)", key, score, item.Member)
+			return
+		}
+	}
+	keyAttr := keyContributeAttr(vmid)
+	if attrs != nil {
+		if attrs.Archive {
+			attr = model.AttrSet(attr, model.AttrYes, model.AttrBitArchive)
+		}
+		if attrs.Article {
+			attr = model.AttrSet(attr, model.AttrYes, model.AttrBitArticle)
+		}
+		if attrs.Clip {
+			attr = model.AttrSet(attr, model.AttrYes, model.AttrBitClip)
+		}
+		if attrs.Album {
+			attr = model.AttrSet(attr, model.AttrYes, model.AttrBitAlbum)
+		}
+		if attrs.Audio {
+			attr = model.AttrSet(attr, model.AttrYes, model.AttrBitAudio)
+		}
+	}
+	if err = conn.Send("SET", keyAttr, attr); err != nil {
+		err = errors.Wrapf(err, "conn.Send(SET,%s,%d)", keyAttr, attr)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		return
+	}
+	for i := 0; i < len(items)+1; i++ {
+		if _, err = conn.Receive(); err != nil {
+			return
+		}
+	}
+	return
+}
+
+// RangeContributeCache .
+func (d *Dao) RangeContributeCache(c context.Context, vmid int64, pn, ps int) (items []*space.Item, err error) {
+	conn := d.redis.Get(c)
+	key := keyContribute(vmid)
+	start := (pn - 1) * ps
+	stop := pn*ps - 1
+	defer conn.Close()
+	var vs []interface{}
+	if vs, err = redis.Values(conn.Do("ZREVRANGE", key, start, stop, "WITHSCORES")); err != nil {
+		err = errors.Wrapf(err, "conn.Do(ZREVRANGE,%s,%d,%d)", key, start, stop)
+		return
+	} else if len(vs) == 0 {
+		return
+	}
+	items = make([]*space.Item, 0, ps)
+	for len(vs) > 0 {
+		var (
+			member int64
+			score  int64
+		)
+		if vs, err = redis.Scan(vs, &member, &score); err != nil {
+			log.Error("redis.Scan(%v) error(%v)", vs, err)
+			err = nil
+			continue
+		}
+		if member != 0 && score != 0 {
+			item := &space.Item{Member: member, CTime: xtime.Time(score)}
+			item.ParseKey()
+			if item.Goto != "" {
+				items = append(items, item)
+			}
+		}
+	}
+	return
+}
+
+func (d *Dao) RangeContributionCache(c context.Context, vmid int64, cursor *model.Cursor) (items []*space.Item, err error) {
+	conn := d.redis.Get(c)
+	key := keyContribute(vmid)
+	defer conn.Close()
+	var (
+		vs          []interface{}
+		rank        int64
+		start, stop int64
+	)
+	if cursor.MoveUpward() || cursor.MoveDownward() {
+		if rank, err = redis.Int64(conn.Do("ZREVRANK", key, cursor.Current)); err != nil {
+			if err == redis.ErrNil {
+				err = nil
+				return
+			}
+			err = errors.Wrapf(err, "conn.Do(ZREVRANK,%s,%d)", key, cursor.Current)
+			return
+		}
+	}
+	if cursor.Latest() {
+		start = 0
+		stop = rank + int64(cursor.Size) - 1
+	} else if cursor.MoveUpward() {
+		if rank == 0 {
+			return
+		}
+		if start = rank - int64(cursor.Size); start < 0 {
+			start = 0
+		}
+		stop = rank - 1
+	} else if cursor.MoveDownward() {
+		start = rank + 1
+		stop = rank + int64(cursor.Size)
+	}
+	if vs, err = redis.Values(conn.Do("ZREVRANGE", key, start, stop, "WITHSCORES")); err != nil {
+		err = errors.Wrapf(err, "conn.Do(ZREVRANGE,%s,%d,%d)", key, start, stop)
+		return
+	}
+	if len(vs) == 0 {
+		return
+	}
+	items = make([]*space.Item, 0, len(vs))
+	for len(vs) > 0 {
+		var (
+			member int64
+			score  int64
+		)
+		if vs, err = redis.Scan(vs, &member, &score); err != nil {
+			log.Error("redis.Scan(%v) error(%v)", vs, err)
+			err = nil
+			continue
+		}
+		if member != 0 && score != 0 {
+			item := &space.Item{Member: member, CTime: xtime.Time(score)}
+			item.ParseKey()
+			if item.Goto != "" {
+				items = append(items, item)
+			}
+		}
+	}
+	return
+}
+
+// AttrCache .
+func (d *Dao) AttrCache(c context.Context, vmid int64) (attrs *space.Attrs, err error) {
+	var attr int64
+	conn := d.redis.Get(c)
+	key := keyContributeAttr(vmid)
+	if attr, err = redis.Int64(conn.Do("GET", key)); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "conn.Do(GET,%s)", key)
+		return
+	}
+	conn.Close()
+	attrs = &space.Attrs{}
+	if model.AttrVal(int32(attr), model.AttrBitArchive) == model.AttrYes {
+		attrs.Archive = true
+	}
+	if model.AttrVal(int32(attr), model.AttrBitArticle) == model.AttrYes {
+		attrs.Article = true
+	}
+	if model.AttrVal(int32(attr), model.AttrBitClip) == model.AttrYes {
+		attrs.Clip = true
+	}
+	if model.AttrVal(int32(attr), model.AttrBitAlbum) == model.AttrYes {
+		attrs.Album = true
+	}
+	if model.AttrVal(int32(attr), model.AttrBitAudio) == model.AttrYes {
+		attrs.Audio = true
+	}
+	return
+}

app/interface/main/app-interface/dao/bplus/redis_test.go

@@ -0,0 +1,51 @@
+package bplus
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// TestKeyContributeAttr dao ut.
+func TestKeyContributeAttr(t *testing.T) {
+	Convey("keyContributeAttr", t, func(ctx C) {
+		key := keyContributeAttr(int64(123456))
+		ctx.Convey("key should not be equal to 123456", func(ctx C) {
+			ctx.So(key, ShouldEqual, "cba_123456")
+		})
+	})
+}
+
+// TestKeyContribute dao ut.
+func TestKeyContribute(t *testing.T) {
+	Convey("keyContribute", t, func(ctx C) {
+		key := keyContribute(int64(123456))
+		ctx.Convey("key should not be equal to 123456", func(ctx C) {
+			ctx.So(key, ShouldEqual, "cb_123456")
+		})
+	})
+}
+
+// TestRangeContributeCache dao ut.
+func TestRangeContributeCache(t *testing.T) {
+	Convey("RangeContributeCache", t, func(ctx C) {
+		_, err := dao.RangeContributeCache(context.Background(), 123456, 1, 20)
+		ctx.Convey("Then err should not be nil.", func(ctx C) {
+			ctx.So(err, ShouldNotBeNil)
+		})
+	})
+}
+
+// TestRangeContributionCache dao ut.
+func TestRangeContributionCache(t *testing.T) {
+	Convey("RangeContributionCache", t, func(ctx C) {
+		var cursor = &model.Cursor{}
+		_, err := dao.RangeContributionCache(context.Background(), 123456, cursor)
+		ctx.Convey("Then err should not be nil.", func(ctx C) {
+			ctx.So(err, ShouldNotBeNil)
+		})
+	})
+}

app/interface/main/app-interface/dao/coin/BUILD

@@ -0,0 +1,50 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/coin",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/archive/api/gorpc:go_default_library",
+        "//app/service/main/archive/model/archive:go_default_library",
+        "//app/service/main/coin/api:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/metadata: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-interface/dao/coin/dao.go

@@ -0,0 +1,84 @@
+package coin
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/service/main/archive/api"
+	arcrpc "go-common/app/service/main/archive/api/gorpc"
+	"go-common/app/service/main/archive/model/archive"
+	coinclient "go-common/app/service/main/coin/api"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+)
+
+// Dao is coin dao
+type Dao struct {
+	coinClient coinclient.CoinClient
+	arcRPC     *arcrpc.Service2
+}
+
+// New initial coin dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		arcRPC: arcrpc.New2(c.ArchiveRPC),
+	}
+	var err error
+	if d.coinClient, err = coinclient.NewClient(c.CoinClient); err != nil {
+		panic(err)
+	}
+	return
+}
+
+//CoinList coin archive list
+func (d *Dao) CoinList(c context.Context, mid int64, pn, ps int) (coinArc []*api.Arc, count int, err error) {
+	var (
+		coinReply *coinclient.ListReply
+		aids      []int64
+		arcs      map[int64]*api.Arc
+		ip        = metadata.String(c, metadata.RemoteIP)
+	)
+	coinArc = make([]*api.Arc, 0)
+	if coinReply, err = d.coinClient.List(c, &coinclient.ListReq{Mid: mid, Business: "archive", Ts: time.Now().Unix()}); err != nil {
+		log.Error("CoinList s.coinClient.List(%d) error(%v)", mid, err)
+		err = nil
+		return
+	}
+	existAids := make(map[int64]int64, len(coinReply.List))
+	for _, v := range coinReply.List {
+		if _, ok := existAids[v.Aid]; ok {
+			continue
+		}
+		aids = append(aids, v.Aid)
+		existAids[v.Aid] = v.Aid
+	}
+	count = len(aids)
+	start := (pn - 1) * ps
+	end := pn * ps
+	switch {
+	case start > count:
+		aids = aids[:0]
+	case end >= count:
+		aids = aids[start:]
+	default:
+		aids = aids[start:end]
+	}
+	if len(aids) == 0 {
+		return
+	}
+	if arcs, err = d.arcRPC.Archives3(c, &archive.ArgAids2{Aids: aids, RealIP: ip}); err != nil {
+		log.Error("CoinList s.arc.Archives3(%v) error(%v)", aids, err)
+		err = nil
+		return
+	}
+	for _, aid := range aids {
+		if arc, ok := arcs[aid]; ok && arc.IsNormal() {
+			if arc.Access >= 10000 {
+				arc.Stat.View = 0
+			}
+			coinArc = append(coinArc, arc)
+		}
+	}
+	return
+}

app/interface/main/app-interface/dao/coin/dao_test.go

@@ -0,0 +1,30 @@
+package coin
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-interface-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+}
+
+func Test_CoinList(t *testing.T) {
+	Convey("should get Archives", t, func() {
+		_, _, err := d.CoinList(context.Background(), 1, 3, 4)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-interface/dao/community/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["community_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/community",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/community:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/community/community_test.go

@@ -0,0 +1,35 @@
+package community
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// go test -conf="../../app-interface-example.toml"  -v -test.run TestCommunity
+func TestCommunity(t *testing.T) {
+	Convey("TestCommuity", t, func() {
+
+	})
+	err := conf.Init()
+	if err != nil {
+		return
+	}
+	dao := New(conf.Conf)
+	community, _, err := dao.Community(context.TODO(), 28009145, "2e3950631afd879592de5e2ee34c7293", "android", 1, 20)
+	if err != nil {
+		t.Errorf("dao.Community error(%v)", err)
+		return
+	}
+	result, err := json.Marshal(community)
+	if err != nil {
+		t.Errorf("json.Marshal error(%v)", err)
+		return
+	}
+	fmt.Printf("test community (%v) \n", string(result))
+}

app/interface/main/app-interface/dao/community/dao.go

@@ -0,0 +1,66 @@
+package community
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/community"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_comm = "/api/query.my.community.list.do"
+)
+
+// Dao is community dao
+type Dao struct {
+	client    *httpx.Client
+	community string
+}
+
+// New initial community dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:    httpx.NewClient(c.HTTPIm9),
+		community: c.Host.Im9 + _comm,
+	}
+	return
+}
+
+// Community get community data from api.
+func (d *Dao) Community(c context.Context, mid int64, ak, platform string, pn, ps int) (co []*community.Community, count int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("actionKey", "appkey")
+	params.Set("data_type", "2")
+	params.Set("access_key", ak)
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("page_no", strconv.Itoa(pn))
+	params.Set("page_size", strconv.Itoa(ps))
+	params.Set("platform", platform)
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Count  int                    `json:"total_count"`
+			Result []*community.Community `json:"result"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.community, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.community+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		co = res.Data.Result
+		count = res.Data.Count
+	}
+	return
+}

app/interface/main/app-interface/dao/elec/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["elec_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/elec",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/elec:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/elec/dao.go

@@ -0,0 +1,59 @@
+package elec
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/elec"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_elec          = "/api/elec/info/query"
+	_elecMonthRank = "1"
+)
+
+// Dao is elec dao.
+type Dao struct {
+	client *httpx.Client
+	elec   string
+}
+
+// New elec dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPClient),
+		elec:   c.Host.Elec + _elec,
+	}
+	return
+}
+
+func (d *Dao) Info(c context.Context, mid, paymid int64) (data *elec.Info, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("pay_mid", strconv.FormatInt(paymid, 10))
+	params.Set("type", _elecMonthRank)
+	var res struct {
+		Code int        `json:"code"`
+		Data *elec.Info `json:"data"`
+	}
+	if err = d.client.Get(c, d.elec, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		if res.Code == 500011 {
+			return
+		}
+		err = errors.Wrap(ecode.Int(res.Code), d.elec+"?"+params.Encode())
+		return
+	}
+	data = res.Data
+	return
+}

app/interface/main/app-interface/dao/elec/elec_test.go

@@ -0,0 +1,35 @@
+package elec
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// go test -conf="../../app-interface-example.toml"  -v -test.run TestElec
+func TestElec(t *testing.T) {
+	Convey("TestElec", t, func() {
+
+	})
+	err := conf.Init()
+	if err != nil {
+		return
+	}
+	dao := New(conf.Conf)
+	elec, err := dao.Info(context.TODO(), 5461533, 15555180)
+	if err != nil {
+		t.Errorf("dao.Elec error(%v)", err)
+		return
+	}
+	result, err := json.Marshal(elec)
+	if err != nil {
+		t.Errorf("json.Marshal error(%v)", elec)
+		return
+	}
+	fmt.Printf("test elec (%v) \n", string(result))
+}

app/interface/main/app-interface/dao/favorite/BUILD

@@ -0,0 +1,50 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/favorite",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/favorite:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/favorite/dao.go

@@ -0,0 +1,100 @@
+package favorite
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/favorite"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_folder      = "/x/internal/v2/fav/folder"
+	_folderVideo = "/x/internal/v2/fav/video"
+)
+
+// Dao is favorite dao
+type Dao struct {
+	client     *httpx.Client
+	favor      string
+	favorVideo string
+}
+
+// New initial favorite dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:     httpx.NewClient(c.HTTPClient),
+		favor:      c.Host.APICo + _folder,
+		favorVideo: c.Host.APICo + _folderVideo,
+	}
+	return
+}
+
+// Folders get favorite floders from api.
+func (d *Dao) Folders(c context.Context, mid, vmid int64, mobiApp string, build int, mediaList bool) (fs []*favorite.Folder, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("vmid", strconv.FormatInt(vmid, 10))
+	params.Set("mobi_app", mobiApp)
+	// params.Set("build", strconv.Itoa(build))
+	if mediaList {
+		params.Set("medialist", "1")
+	}
+	var res struct {
+		Code int                `json:"code"`
+		Data []*favorite.Folder `json:"data"`
+	}
+	if err = d.client.Get(c, d.favor, ip, params, &res); err != nil {
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("Folders url(%s) response(%s)", d.favor+"?"+params.Encode(), b)
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.favor+"?"+params.Encode())
+		return
+	}
+	fs = res.Data
+	return
+}
+
+// FolderVideo get favorite floders from UGC api.
+func (d *Dao) FolderVideo(c context.Context, accessKey, actionKey, device, mobiApp, platform, keyword, order string, build, tid, pn, ps int, mid, fid, vmid int64) (fav *favorite.Video, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("access_key", accessKey)
+	params.Set("actionKey", actionKey)
+	params.Set("build", strconv.Itoa(build))
+	params.Set("device", device)
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("fid", strconv.FormatInt(fid, 10))
+	params.Set("tid", strconv.Itoa(tid))
+	params.Set("keyword", keyword)
+	params.Set("order", order)
+	params.Set("pn", strconv.Itoa(pn))
+	params.Set("ps", strconv.Itoa(ps))
+	params.Set("mobi_app", mobiApp)
+	params.Set("platform", platform)
+	params.Set("vmid", strconv.FormatInt(vmid, 10))
+	var res struct {
+		Code int             `json:"code"`
+		Data *favorite.Video `json:"data"`
+	}
+	if err = d.client.Get(c, d.favorVideo, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.favorVideo+"?"+params.Encode())
+		return
+	}
+	fav = res.Data
+	return
+}

app/interface/main/app-interface/dao/favorite/dao_test.go

@@ -0,0 +1,55 @@
+package favorite
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	dao *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-interface")
+		flag.Set("conf_token", "1mWvdEwZHmCYGoXJCVIdszBOPVdtpXb3")
+		flag.Set("tree_id", "2688")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/app-interface-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	dao = New(conf.Conf)
+	os.Exit(m.Run())
+	// time.Sleep(time.Second)
+}
+
+func TestDao_Folders(t *testing.T) {
+	Convey("folder", t, func() {
+		gotFs, err := dao.Folders(context.Background(), 1, 1, "android", 0, true)
+		So(gotFs, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDao_FolderVideo(t *testing.T) {
+	Convey("folder video", t, func() {
+		gotFav, err := dao.FolderVideo(context.Background(), "", "", "", "", "", "", "", 0, 0, 1, 20, 1, 0, 1)
+		So(gotFav, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-interface/dao/history/BUILD

@@ -0,0 +1,55 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/history",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/history:go_default_library",
+        "//app/interface/main/history/model:go_default_library",
+        "//app/interface/main/history/rpc/client:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/interface/openplatform/article/rpc/client:go_default_library",
+        "//app/service/main/archive/api/gorpc:go_default_library",
+        "//app/service/main/archive/model/archive:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/history/dao.go

@@ -0,0 +1,142 @@
+package history
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	model "go-common/app/interface/main/app-interface/model/history"
+	hismodle "go-common/app/interface/main/history/model"
+	hisrpc "go-common/app/interface/main/history/rpc/client"
+	artmodle "go-common/app/interface/openplatform/article/model"
+	artrpc "go-common/app/interface/openplatform/article/rpc/client"
+	arcrpc "go-common/app/service/main/archive/api/gorpc"
+	arcmodle "go-common/app/service/main/archive/model/archive"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_apiPGC = "/internal_api/get_eps_v2"
+)
+
+// Dao is history dao
+type Dao struct {
+	client     *bm.Client
+	historyRPC *hisrpc.Service
+	arcRPC     *arcrpc.Service2
+	artRPC     *artrpc.Service
+	pgcAPI     string
+}
+
+// New initial history dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:     bm.NewClient(c.HTTPClient),
+		historyRPC: hisrpc.New(c.HistoryRPC),
+		arcRPC:     arcrpc.New2(c.ArchiveRPC),
+		artRPC:     artrpc.New(c.ArticleRPC),
+		pgcAPI:     c.Host.Bangumi + _apiPGC,
+	}
+	return
+}
+
+// History get history
+func (d *Dao) History(c context.Context, mid int64, pn, ps int) (res []*hismodle.Resource, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &hismodle.ArgHistories{Mid: mid, Pn: pn, Ps: ps, RealIP: ip}
+	if res, err = d.historyRPC.History(c, arg); err != nil {
+		err = errors.Wrapf(err, "d.historyRPC.History(%+v)", arg)
+	}
+	return
+}
+
+// Archive get archive info
+func (d *Dao) Archive(c context.Context, aids []int64) (info map[int64]*arcmodle.View3, err error) {
+	arg := &arcmodle.ArgAids2{Aids: aids}
+	if info, err = d.arcRPC.Views3(c, arg); err != nil {
+		err = errors.Wrapf(err, "d.arcRPC.Views3(%+v)", arg)
+	}
+	return
+}
+
+// PGC get PGC info
+func (d *Dao) PGC(c context.Context, epid, platform string, build, mid int64) (info map[int64]*model.PGCRes, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("ep_ids", epid)
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("build", strconv.FormatInt(build, 10))
+	params.Set("platform", platform)
+	var res struct {
+		Code int             `json:"code"`
+		Data []*model.PGCRes `json:"result"`
+	}
+	if err = d.client.Get(c, d.pgcAPI, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.pgcAPI+"?"+params.Encode())
+		return
+	}
+	info = make(map[int64]*model.PGCRes, len(res.Data))
+	for _, v := range res.Data {
+		v.Title = v.Season.Title
+		info[v.EpID] = v
+	}
+	return
+}
+
+// Article get articl info
+func (d *Dao) Article(c context.Context, articleIDs []int64) (info map[int64]*artmodle.Meta, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &artmodle.ArgAids{Aids: articleIDs, RealIP: ip}
+	if info, err = d.artRPC.ArticleMetas(c, arg); err != nil {
+		err = errors.Wrapf(err, "d.artRPC.ArticleMetas(%+v)", arg)
+	}
+	return
+}
+
+// HistoryByTP histroy by tp
+func (d *Dao) HistoryByTP(c context.Context, mid int64, pn, ps int, tp int8) (res []*hismodle.Resource, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &hismodle.ArgHistories{Mid: mid, Pn: pn, Ps: ps, RealIP: ip, TP: tp}
+	if res, err = d.historyRPC.History(c, arg); err != nil {
+		err = errors.Wrapf(err, "d.historyRPC.History(%+v)", arg)
+	}
+	return
+}
+
+// Cursor 5.28游标由MaxOid+MaxTP唯一确定 改为 由ViewAt唯一确定（防止客户端改动对客户端仍用max字段）
+func (d *Dao) Cursor(c context.Context, mid, max int64, ps int, tp int8, businesses []string) (res []*hismodle.Resource, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &hismodle.ArgCursor{Mid: mid, Max: max, Ps: ps, RealIP: ip, TP: tp, ViewAt: max, Businesses: businesses}
+	if res, err = d.historyRPC.HistoryCursor(c, arg); err != nil {
+		err = errors.Wrapf(err, "d.historyRPC.HistoryCursor(%+v)", arg)
+	}
+	return
+}
+
+// Del for history
+func (d *Dao) Del(c context.Context, mid int64, hisRes []*hismodle.Resource) (err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &hismodle.ArgDelete{Mid: mid, RealIP: ip, Resources: hisRes}
+	if err = d.historyRPC.Delete(c, arg); err != nil {
+		err = errors.Wrapf(err, "d.historyRPC.Delete(%+v)", arg)
+	}
+	return
+}
+
+// Clear for history
+func (d *Dao) Clear(c context.Context, mid int64, businesses []string) (err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &hismodle.ArgClear{Mid: mid, RealIP: ip, Businesses: businesses}
+	if err = d.historyRPC.Clear(c, arg); err != nil {
+		err = errors.Wrapf(err, "d.historyRPC.Clear(%+v)", arg)
+	}
+	return
+}

app/interface/main/app-interface/dao/history/dao_test.go

@@ -0,0 +1,56 @@
+package history
+
+import (
+	"context"
+	"go-common/app/interface/main/app-interface/conf"
+	"testing"
+
+	"flag"
+	"path/filepath"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/app-interface-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+}
+
+func WithDao(f func(d *Dao)) func() {
+	return func() {
+		Reset(func() {})
+		f(d)
+	}
+}
+
+func TestDao_ArchiveInfo(t *testing.T) {
+	Convey("ArchiveInfo", t, WithDao(func(d *Dao) {
+		_, err := d.Archive(context.TODO(), []int64{1, 2})
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestDao_ArticleInfo(t *testing.T) {
+	Convey("ArticleInfo", t, WithDao(func(d *Dao) {
+		_, err := d.Article(context.TODO(), []int64{1, 2})
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestDao_PGCInfo(t *testing.T) {
+	Convey("PGCInfo", t, WithDao(func(d *Dao) {
+		_, err := d.PGC(context.TODO(), "1", "1", 111, 27515256)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestDao_GetList(t *testing.T) {
+	Convey("GetList", t, WithDao(func(d *Dao) {
+		_, err := d.History(context.TODO(), 27515256, 1, 20)
+		So(err, ShouldBeNil)
+	}))
+}

app/interface/main/app-interface/dao/live/BUILD

@@ -0,0 +1,50 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/live",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/live:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/live/dao.go

@@ -0,0 +1,228 @@
+package live
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/live"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_live        = "/AppRoom/getRoomInfo"
+	_medalStatus = "/fans_medal/v1/medal/get_medal_opened"
+	_appMRoom    = "/room/v1/Room/rooms_for_app_index"
+	_statusInfo  = "/room/v1/Room/get_status_info_by_uids"
+	_visibleInfo = "/rc/v1/Glory/get_visible"
+	_usersInfo   = "/user/v3/User/getMultiple"
+	_LiveByRID   = "/room/v2/Room/get_by_ids"
+)
+
+// Dao is space dao
+type Dao struct {
+	client      *httpx.Client
+	live        string
+	medalStatus string
+	appMRoom    string
+	statusInfo  string
+	visibleInfo string
+	userInfo    string
+	liveByRID   string
+}
+
+// New initial space dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:      httpx.NewClient(c.HTTPLive),
+		live:        c.Host.APILiveCo + _live,
+		medalStatus: c.Host.APILiveCo + _medalStatus,
+		appMRoom:    c.Host.APILiveCo + _appMRoom,
+		statusInfo:  c.Host.APILiveCo + _statusInfo,
+		visibleInfo: c.Host.APILiveCo + _visibleInfo,
+		userInfo:    c.Host.APILiveCo + _usersInfo,
+		liveByRID:   c.Host.APILiveCo + _LiveByRID,
+	}
+	return
+}
+
+// Live is space live data.
+func (d *Dao) Live(c context.Context, mid int64, platform string) (live json.RawMessage, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("platform", platform)
+	var res struct {
+		Code int             `json:"code"`
+		Data json.RawMessage `json:"data"`
+	}
+	if err = d.client.Get(c, d.live, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.live+"?"+params.Encode())
+		return
+	}
+	live = res.Data
+	return
+}
+
+// MedalStatus for live
+func (d *Dao) MedalStatus(c context.Context, mid int64) (status int, err error) {
+	var (
+		req *http.Request
+		res struct {
+			Code int `json:"code"`
+			Data *struct {
+				MasterStatus int `json:"master_status"`
+			} `json:"data"`
+		}
+		ip = metadata.String(c, metadata.RemoteIP)
+	)
+	if req, err = d.client.NewRequest("GET", d.medalStatus, ip, nil); err != nil {
+		return
+	}
+	req.Header.Set("X-BILILIVE-UID", strconv.FormatInt(mid, 10))
+	if err = d.client.Do(c, req, &res); err != nil {
+		err = errors.Wrapf(err, "url(%s) header(X-BiliLive-UID:%s)", req.URL.String(), req.Header.Get("X-BiliLive-UID"))
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrapf(ecode.Int(res.Code), "url(%s) header(X-BiliLive-UID:%s)", req.URL.String(), req.Header.Get("X-BiliLive-UID"))
+		return
+	}
+	if res.Data != nil {
+		status = res.Data.MasterStatus
+	}
+	return
+}
+
+// AppMRoom for live
+func (d *Dao) AppMRoom(c context.Context, roomids []int64) (rs map[int64]*live.Room, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("room_ids", xstr.JoinInts(roomids))
+	var res struct {
+		Code int          `json:"code"`
+		Data []*live.Room `json:"data"`
+	}
+	if err = d.client.Get(c, d.appMRoom, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.appMRoom+"?"+params.Encode())
+		return
+	}
+	rs = make(map[int64]*live.Room, len(res.Data))
+	for _, r := range res.Data {
+		rs[r.RoomID] = r
+	}
+	return
+}
+
+// StatusInfo for live
+func (d *Dao) StatusInfo(c context.Context, mids []int64) (status map[int64]*live.Status, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	for _, mid := range mids {
+		params.Add("uids[]", strconv.FormatInt(mid, 10))
+	}
+	params.Set("filter_offline", "1")
+	var res struct {
+		Code int                    `json:"code"`
+		Data map[int64]*live.Status `json:"data"`
+	}
+	if err = d.client.Get(c, d.statusInfo, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.statusInfo+"?"+params.Encode())
+		return
+	}
+	status = res.Data
+	return
+}
+
+// Glory for live search
+func (d *Dao) Glory(c context.Context, uid int64) (glory []*live.Glory, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(uid, 10))
+	var res struct {
+		Code int           `json:"code"`
+		Data []*live.Glory `json:"data"`
+	}
+	if err = d.client.Get(c, d.visibleInfo, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.visibleInfo+"?"+params.Encode())
+		return
+	}
+	glory = res.Data
+	return
+}
+
+// UserInfo for live search
+func (d *Dao) UserInfo(c context.Context, uids []int64) (userInfo map[int64]map[string]*live.Exp, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	for _, uid := range uids {
+		params.Set("uids[]", strconv.FormatInt(uid, 10))
+	}
+	params.Set("attributes[]", "exp")
+	var res struct {
+		Code int                            `json:"code"`
+		Data map[int64]map[string]*live.Exp `json:"data"`
+	}
+	if err = d.client.Get(c, d.userInfo, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.userInfo+"?"+params.Encode())
+		return
+	}
+	userInfo = res.Data
+	return
+}
+
+// LiveByRIDs get live info by room_ids.
+func (d *Dao) LiveByRIDs(c context.Context, roomIDs []int64) (info map[int64]*live.RoomInfo, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	for _, id := range roomIDs {
+		params.Add("ids[]", strconv.FormatInt(id, 10))
+	}
+	params.Add("fields[]", "roomid")
+	params.Add("fields[]", "title")
+	params.Add("fields[]", "cover")
+	params.Add("fields[]", "user_cover")
+	params.Add("fields[]", "uid")
+	params.Add("fields[]", "uname")
+	params.Add("fields[]", "area_v2_name")
+	params.Add("fields[]", "live_status")
+	params.Add("fields[]", "broadcast_type")
+	params.Add("fields[]", "short_id")
+	params.Add("need_broadcast_type", "1")
+	var res struct {
+		Code int                      `json:"code"`
+		Data map[int64]*live.RoomInfo `json:"data"`
+	}
+	if err = d.client.Get(c, d.liveByRID, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.liveByRID+"?"+params.Encode())
+		return
+	}
+	info = res.Data
+	return
+}

app/interface/main/app-interface/dao/live/dao_test.go

@@ -0,0 +1,44 @@
+package live
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-interface-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+}
+
+func Test_Live(t *testing.T) {
+	Convey("should get live", t, func() {
+		_, err := d.Live(context.Background(), 1, "")
+		So(err, ShouldBeNil)
+	})
+}
+
+func Test_MedalStatus(t *testing.T) {
+	Convey("should get MedalStatus", t, func() {
+		_, err := d.MedalStatus(context.Background(), 1)
+		So(err, ShouldBeNil)
+	})
+}
+
+func Test_AppMRoom(t *testing.T) {
+	Convey("should get AppMRoom", t, func() {
+		_, err := d.AppMRoom(context.Background(), []int64{1, 2})
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-interface/dao/location/BUILD

@@ -0,0 +1,46 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/location",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/service/main/location/model:go_default_library",
+        "//app/service/main/location/rpc/client:go_default_library",
+        "//library/log: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-interface/dao/location/dao.go

@@ -0,0 +1,32 @@
+package location
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-interface/conf"
+	locmdl "go-common/app/service/main/location/model"
+	locrpc "go-common/app/service/main/location/rpc/client"
+	"go-common/library/log"
+)
+
+// Dao is location dao.
+type Dao struct {
+	// rpc
+	locRPC *locrpc.Service
+}
+
+// New new a location dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// rpc
+		locRPC: locrpc.New(c.LocationRPC),
+	}
+	return
+}
+
+func (d *Dao) Info(c context.Context, ipaddr string) (info *locmdl.Info, err error) {
+	if info, err = d.locRPC.Info(c, &locmdl.ArgIP{IP: ipaddr}); err != nil {
+		log.Error("%v", err)
+	}
+	return
+}

app/interface/main/app-interface/dao/location/dao_test.go

@@ -0,0 +1,37 @@
+package location
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-interface-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestInfo(t *testing.T) {
+	Convey("get Info", t, func() {
+		res, err := d.Info(ctx(), "127.0.0.1")
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-interface/dao/mall/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/mall",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/mall/dao.go

@@ -0,0 +1,48 @@
+package mall
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const _favCount = "/mall-ugc/ugc/vote/user/wishcount"
+
+type Dao struct {
+	client   *bm.Client
+	favCount string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:   bm.NewClient(c.HTTPClient),
+		favCount: c.Host.Mall + _favCount,
+	}
+	return
+}
+
+func (d *Dao) FavCount(c context.Context, mid int64) (count int32, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int   `json:"code"`
+		Data int32 `json:"data"`
+	}
+	if err = d.client.Get(c, d.favCount, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.favCount+"?"+params.Encode())
+		return
+	}
+	count = res.Data
+	return
+}

app/interface/main/app-interface/dao/mall/dao_test.go

@@ -0,0 +1,50 @@
+package mall
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-interface")
+		flag.Set("conf_token", "1mWvdEwZHmCYGoXJCVIdszBOPVdtpXb3")
+		flag.Set("tree_id", "2688")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}
+
+func TestFavCount(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, err := d.FavCount(c, mid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/app-interface/dao/member/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/member",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/member/dao.go

@@ -0,0 +1,51 @@
+package member
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+type Dao struct {
+	c      *conf.Config
+	client *httpx.Client
+	member string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:      c,
+		client: httpx.NewClient(c.HTTPClient),
+		member: c.Host.APICo + "/x/internal/creative/app/pre",
+	}
+	return
+}
+
+// Creative get user bcoin  doc:http://info.bilibili.co/display/coding/internal-creative#internal-creative-APP%E4%B8%AA%E4%BA%BA%E4%B8%AD%E5%BF%83
+func (d *Dao) Creative(c context.Context, mid int64) (isUp, show int, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			IsUp int `json:"is_up"`
+			Show int `json:"show"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.member, "", params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.member+"?"+params.Encode())
+		return
+	}
+	isUp = res.Data.IsUp
+	show = res.Data.Show
+	return
+}

app/interface/main/app-interface/dao/member/dao_test.go

@@ -0,0 +1,33 @@
+package member
+
+import (
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestNew(t *testing.T) {
+	Convey("TestNew", t, func() {
+
+	})
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotD := New(tt.args.c); !reflect.DeepEqual(gotD, tt.wantD) {
+				t.Errorf("New() = %v, want %v", gotD, tt.wantD)
+			}
+		})
+	}
+}

app/interface/main/app-interface/dao/pay/BUILD

@@ -0,0 +1,48 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/pay",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/pay:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/pay/dao.go

@@ -0,0 +1,96 @@
+package pay
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/pay"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+type Dao struct {
+	c      *conf.Config
+	client *httpx.Client
+	wallet string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:      c,
+		client: httpx.NewClient(c.HTTPClient),
+		wallet: c.Host.Pay + "/wallet-int/wallet/getUserWalletInfo",
+	}
+	return
+}
+
+// UserWalletInfo get user bcoin  doc:http://info.bilibili.co/pages/viewpage.action?pageId=7559096
+func (d *Dao) UserWalletInfo(c context.Context, mid int64, platform string) (availableBp float64, err error) {
+	var plat int
+	if platform == "ios" {
+		plat = 1
+	} else if platform == "android" {
+		plat = 2
+	} else {
+		err = fmt.Errorf("platform(%s) error", platform)
+		return
+	}
+	params := url.Values{}
+	params.Set("customerId", "10006")
+	params.Set("platformType", strconv.Itoa(plat))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("traceId", strconv.FormatInt(time.Now().Unix(), 10))
+	params.Set("timestamp", strconv.FormatInt(time.Now().UnixNano()/1000, 10))
+	params.Set("signType", "MD5")
+	params.Set("appkey", d.c.HTTPClient.Key)
+	type pJSON struct {
+		CustomerID   string `json:"customerId"`
+		PlatformType int    `json:"platformType"`
+		Mid          int64  `json:"mid"`
+		TraceID      string `json:"traceId"`
+		Timestamp    string `json:"timestamp"`
+		SignType     string `json:"signType"`
+		Appkey       string `json:"appkey"`
+		Sign         string `json:"sign"`
+	}
+	tmp := params.Encode() + d.c.HTTPClient.Secret
+	if strings.IndexByte(tmp, '+') > -1 {
+		tmp = strings.Replace(tmp, "+", "%20", -1)
+	}
+	mh := md5.Sum([]byte(tmp))
+	sign := hex.EncodeToString(mh[:])
+	p := &pJSON{
+		CustomerID:   "10006",
+		PlatformType: plat,
+		Mid:          mid,
+		TraceID:      params.Get("traceId"),
+		Timestamp:    params.Get("timestamp"),
+		SignType:     params.Get("signType"),
+		Appkey:       params.Get("appkey"),
+		Sign:         sign,
+	}
+	bs, _ := json.Marshal(p)
+	req, _ := http.NewRequest("POST", d.wallet, strings.NewReader(string(bs)))
+	req.Header.Set("Content-Type", "application/json")
+	var wallet *pay.UserWallet
+	if err = d.client.Do(c, req, &wallet); err != nil {
+		return
+	}
+	if wallet.Code != 0 {
+		err = errors.Wrap(ecode.Int(wallet.Code), d.wallet+"?"+params.Encode())
+		return
+	}
+	availableBp = wallet.Data.AvailableBp
+	return
+}

app/interface/main/app-interface/dao/pay/dao_test.go

@@ -0,0 +1,33 @@
+package pay
+
+import (
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestNew(t *testing.T) {
+	Convey("TestNew", t, func() {
+
+	})
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotD := New(tt.args.c); !reflect.DeepEqual(gotD, tt.wantD) {
+				t.Errorf("New() = %v, want %v", gotD, tt.wantD)
+			}
+		})
+	}
+}

app/interface/main/app-interface/dao/relation/BUILD

@@ -0,0 +1,48 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/relation",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/service/main/relation/model:go_default_library",
+        "//app/service/main/relation/rpc/client:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/relation/dao.go

@@ -0,0 +1,77 @@
+package relation
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-interface/conf"
+	relation "go-common/app/service/main/relation/model"
+	relationrpc "go-common/app/service/main/relation/rpc/client"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+type Dao struct {
+	relationRPC *relationrpc.Service
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		relationRPC: relationrpc.New(c.RelationRPC),
+	}
+	return
+}
+
+// Stat get mid relation stat
+func (d *Dao) Stat(c context.Context, mid int64) (stat *relation.Stat, err error) {
+	stat, err = d.relationRPC.Stat(c, &relation.ArgMid{Mid: mid})
+	if err != nil {
+		err = errors.Wrapf(err, "%v", mid)
+	}
+	return
+}
+
+func (d *Dao) FollowersUnread(c context.Context, vmid int64) (res bool, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &relation.ArgMid{Mid: vmid, RealIP: ip}
+	if res, err = d.relationRPC.FollowersUnread(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) Followings(c context.Context, vmid int64) (res []*relation.Following, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &relation.ArgMid{Mid: vmid, RealIP: ip}
+	if res, err = d.relationRPC.Followings(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) Relations(c context.Context, mid int64, fids []int64) (res map[int64]*relation.Following, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &relation.ArgRelations{Mid: mid, Fids: fids, RealIP: ip}
+	if res, err = d.relationRPC.Relations(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) Tag(c context.Context, mid, tid int64) (res []int64, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &relation.ArgTagId{Mid: mid, TagId: tid, RealIP: ip}
+	if res, err = d.relationRPC.Tag(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) FollowersUnreadCount(c context.Context, mid int64) (res int64, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &relation.ArgMid{Mid: mid, RealIP: ip}
+	if res, err = d.relationRPC.FollowersUnreadCount(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

app/interface/main/app-interface/dao/relation/dao_test.go

@@ -0,0 +1,119 @@
+package relation
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-interface")
+		flag.Set("conf_token", "1mWvdEwZHmCYGoXJCVIdszBOPVdtpXb3")
+		flag.Set("tree_id", "2688")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/app-interface-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+	// time.Sleep(time.Second)
+}
+
+func TestStat(t *testing.T) {
+	var (
+		c   = context.Background()
+		mid = int64(1)
+	)
+	convey.Convey("Stat", t, func(ctx convey.C) {
+		_, err := d.Stat(c, mid)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestFollowersUnread(t *testing.T) {
+	var (
+		c   = context.Background()
+		mid = int64(1)
+	)
+	convey.Convey("FollowersUnread", t, func(ctx convey.C) {
+		_, err := d.FollowersUnread(c, mid)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestFollowings(t *testing.T) {
+	var (
+		c   = context.Background()
+		mid = int64(1)
+	)
+	convey.Convey("Followings", t, func(ctx convey.C) {
+		_, err := d.Followings(c, mid)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestRelations(t *testing.T) {
+	var (
+		c    = context.Background()
+		mid  = int64(1)
+		fids = []int64{1}
+	)
+	convey.Convey("Relations", t, func(ctx convey.C) {
+		_, err := d.Relations(c, mid, fids)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestTag(t *testing.T) {
+	var (
+		c   = context.Background()
+		mid = int64(1)
+		tid = int64(1)
+	)
+	convey.Convey("Tag", t, func(ctx convey.C) {
+		_, err := d.Tag(c, mid, tid)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestFollowersUnreadCount(t *testing.T) {
+	var (
+		c   = context.Background()
+		mid = int64(2)
+	)
+	convey.Convey("FollowersUnreadCount", t, func(ctx convey.C) {
+		_, err := d.FollowersUnreadCount(c, mid)
+		ctx.Convey("Then err should be nil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/app-interface/dao/resource/BUILD

@@ -0,0 +1,48 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/resource",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/service/main/resource/model:go_default_library",
+        "//app/service/main/resource/rpc/client:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/metadata: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-interface/dao/resource/dao.go

@@ -0,0 +1,56 @@
+package resource
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-interface/conf"
+	resmdl "go-common/app/service/main/resource/model"
+	resrpc "go-common/app/service/main/resource/rpc/client"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+)
+
+type Dao struct {
+	c *conf.Config
+	// rpc
+	resRPC *resrpc.Service
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c: c,
+		// rpc
+		resRPC: resrpc.New(c.ResourceRPC),
+	}
+	return
+}
+
+// Banner get search banner
+func (d *Dao) Banner(c context.Context, mobiApp, device, network, channel, buvid, adExtra, resIDStr string, build int, plat int8, mid int64) (res map[int][]*resmdl.Banner, err error) {
+	var (
+		bs *resmdl.Banners
+		ip = metadata.String(c, metadata.RemoteIP)
+	)
+	arg := &resmdl.ArgBanner{
+		MobiApp: mobiApp,
+		Device:  device,
+		Network: network,
+		Channel: channel,
+		IP:      ip,
+		Buvid:   buvid,
+		AdExtra: adExtra,
+		ResIDs:  resIDStr,
+		Build:   build,
+		Plat:    plat,
+		MID:     mid,
+		IsAd:    true,
+	}
+	if bs, err = d.resRPC.Banners(c, arg); err != nil || bs == nil {
+		log.Error("d.resRPC.Banners(%v) error(%v) or bs is nil", arg, err)
+		return
+	}
+	if len(bs.Banner) > 0 {
+		res = bs.Banner
+	}
+	return
+}

app/interface/main/app-interface/dao/resource/dao_test.go

@@ -0,0 +1,37 @@
+package resource
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-interface-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestResBanner(t *testing.T) {
+	Convey("Banner", t, func() {
+		res, err := d.Banner(ctx(), "", "", "", "", "", "", "", 1, 1, 1)
+		So(res, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-interface/dao/search/BUILD

@@ -0,0 +1,62 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+        "//vendor/gopkg.in/h2non/gock.v1:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/search",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/dao/archive:go_default_library",
+        "//app/interface/main/app-interface/dao/bangumi:go_default_library",
+        "//app/interface/main/app-interface/dao/live:go_default_library",
+        "//app/interface/main/app-interface/model:go_default_library",
+        "//app/interface/main/app-interface/model/bangumi:go_default_library",
+        "//app/interface/main/app-interface/model/live:go_default_library",
+        "//app/interface/main/app-interface/model/search:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/location/model:go_default_library",
+        "//app/service/main/location/rpc/client:go_default_library",
+        "//app/service/openplatform/pgc-season/api/grpc/season/v1:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/search/dao_test.go

@@ -0,0 +1,368 @@
+package search
+
+import (
+	"context"
+	"flag"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-interface/conf"
+	// "go-common/app/interface/main/app-interface/model/search"
+
+	. "github.com/smartystreets/goconvey/convey"
+	"gopkg.in/h2non/gock.v1"
+)
+
+var (
+	dao *Dao
+)
+
+// TestMain dao ut.
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-interface")
+		flag.Set("conf_token", "1mWvdEwZHmCYGoXJCVIdszBOPVdtpXb3")
+		flag.Set("tree_id", "2688")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/app-interface-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	dao = New(conf.Conf)
+	os.Exit(m.Run())
+	// time.Sleep(time.Second)
+}
+
+func httpMock(method, url string) *gock.Request {
+	r := gock.New(url)
+	r.Method = strings.ToUpper(method)
+	return r
+}
+
+// TestDao_Search dao ut.
+func TestDao_Search(t *testing.T) {
+	Convey("get Search", t, func() {
+		res, _, err := dao.Search(ctx(), 1, 2, "iphone", "phone", "1", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", "123",
+			"0", "1", "1", "1", "1", "1", int8(1), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 8160, 20, 1, false, time.Now(), false, false)
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDao_Season dao ut.
+func TestDao_Season(t *testing.T) {
+	Convey("get Season", t, func() {
+		res, err := dao.Season(ctx(), 1, 2, "123", "iphone", "phone", "1", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", "1", int8(1), 8190, 1, 20, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDaoUpper dao ut.
+func TestDaoUpper(t *testing.T) {
+	var (
+		c          = context.Background()
+		mid        = int64(1)
+		keyword    = "iphone"
+		mobiApp    = "iphone"
+		device     = "1"
+		platform   = "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc"
+		buvid      = "123"
+		filtered   = "0"
+		order      = "1"
+		biliUserVL = int(1)
+		highlight  = int(2)
+		build      = int(3)
+		userType   = int(4)
+		orderSort  = int(5)
+		pn         = int(1)
+		ps         = int(20)
+		old        = false
+		now        = time.Now()
+	)
+	Convey("Upper", t, func(ctx C) {
+		dao.client.SetTransport(gock.DefaultTransport)
+		ctx.Convey("When everthing goes positive", func(ctx C) {
+			// httpMock("GET", dao.main).Reply(200).JSON(`{"code":0,"seid":"something","numPages":1,"result":[]}`)
+			httpMock("GET", dao.main).Reply(200).JSON(`{"code":0,"seid":"something","numPages":1,"result":[{"mid":1,"uanme":"something","name":"something","official_verify":{"type":1,"desc":"something"},"usign":"something","fans":1,"videos":1,"level":1,"upic":"something","numPages":20,"res":[{"play":null,"dm":1,"pubdate":45321,"title":"something","aid":1,"pic":"something","arcurl":"something","duration":"something","is_pay":1}],"is_live":1,"room_id":1,"is_upuser":1}]}`)
+			res, err := dao.Upper(c, mid, keyword, mobiApp, device, platform, buvid, filtered, order, biliUserVL, highlight, build, userType, orderSort, pn, ps, old, now)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldBeNil)
+				ctx.So(res, ShouldNotBeEmpty)
+			})
+		})
+		ctx.Convey("When filtered is \"1\"", func(ctx C) {
+			filtered = "1"
+			httpMock("GET", dao.main).Reply(200).JSON(`{"code":0,"seid":"something","numPages":1,"result":[]}`)
+			res, err := dao.Upper(c, mid, keyword, mobiApp, device, platform, buvid, filtered, order, biliUserVL, highlight, build, userType, orderSort, pn, ps, old, now)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldBeNil)
+				ctx.So(res, ShouldNotBeEmpty)
+			})
+		})
+		ctx.Convey("When res.Code != ecode.OK.Code()", func(ctx C) {
+			httpMock("GET", dao.main).Reply(200).JSON(`{"code":-1,"seid":"something","numPages":1,"result":[]}`)
+			_, err := dao.Upper(c, mid, keyword, mobiApp, device, platform, buvid, filtered, order, biliUserVL, highlight, build, userType, orderSort, pn, ps, old, now)
+			ctx.Convey("Then err should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldNotBeNil)
+			})
+		})
+		ctx.Convey("When http request failed", func(ctx C) {
+			httpMock("GET", dao.main).Reply(500)
+			_, err := dao.Upper(c, mid, keyword, mobiApp, device, platform, buvid, filtered, order, biliUserVL, highlight, build, userType, orderSort, pn, ps, old, now)
+			ctx.Convey("Then err should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+// TestDaoMovieByType dao ut.
+func TestDaoMovieByType(t *testing.T) {
+	var (
+		c        = context.Background()
+		mid      = int64(0)
+		zoneid   = int64(0)
+		keyword  = "iphone"
+		mobiApp  = "phone"
+		device   = "1"
+		platform = "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc"
+		buvid    = "123"
+		filtered = "0"
+		plat     = int8(1)
+		build    = 1
+		pn       = 1
+		ps       = 1
+		now      = time.Now()
+	)
+	Convey("MovieByType", t, func(ctx C) {
+		dao.client.SetTransport(gock.DefaultTransport)
+		ctx.Convey("When everything goes positive", func(ctx C) {
+			httpMock("GET", dao.main).Reply(200).JSON(`{"code":0,"seid":"something","numPages":1,"result":[]}`)
+			res, err := dao.MovieByType(c, mid, zoneid, keyword, mobiApp, device, platform, buvid, filtered, plat, build, pn, ps, now)
+			ctx.Convey("Then err should be nil. res should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldBeNil)
+				ctx.So(res, ShouldNotBeEmpty)
+			})
+		})
+		ctx.Convey("When res.Code != ecode.OK.Code()", func(ctx C) {
+			httpMock("GET", dao.main).Reply(200).JSON(`{"code":-1,"seid":"something","numPages":1,"result":[]}`)
+			_, err := dao.MovieByType(c, mid, zoneid, keyword, mobiApp, device, platform, buvid, filtered, plat, build, pn, ps, now)
+			ctx.Convey("Then err should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldNotBeNil)
+			})
+		})
+		ctx.Convey("When http request failed", func(ctx C) {
+			httpMock("GET", dao.main).Reply(500)
+			_, err := dao.MovieByType(c, mid, zoneid, keyword, mobiApp, device, platform, buvid, filtered, plat, build, pn, ps, now)
+			ctx.Convey("Then err should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+// TestDaoLiveByType dao ut.
+func TestDaoLiveByType(t *testing.T) {
+	var (
+		c        = context.Background()
+		mid      = int64(1)
+		zoneid   = int64(1)
+		keyword  = "iphone"
+		mobiApp  = "phone"
+		device   = "1"
+		platform = "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc"
+		buvid    = "123"
+		filtered = "0"
+		order    = "1"
+		sType    = "1"
+		plat     = int8(1)
+		build    = 1
+		pn       = 1
+		ps       = 20
+		now      = time.Now()
+	)
+	Convey("LiveByType", t, func(ctx C) {
+		dao.client.SetTransport(gock.DefaultTransport)
+		ctx.Convey("When everything goes positive", func(ctx C) {
+			httpMock("GET", dao.main).Reply(200).JSON(`{"code":0,"seid":"something","numPages":1,"result":[]}`)
+			res, err := dao.LiveByType(c, mid, zoneid, keyword, mobiApp, device, platform, buvid, filtered, order, sType, plat, build, pn, ps, now)
+			ctx.Convey("Then err should be nil. res should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldBeNil)
+				ctx.So(res, ShouldNotBeEmpty)
+			})
+		})
+		ctx.Convey("When res.Code != ecode.OK.Code()", func(ctx C) {
+			httpMock("GET", dao.main).Reply(200).JSON(`{"code":-1,"seid":"something","numPages":1,"result":[]}`)
+			_, err := dao.LiveByType(c, mid, zoneid, keyword, mobiApp, device, platform, buvid, filtered, order, sType, plat, build, pn, ps, now)
+			ctx.Convey("Then err should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldNotBeNil)
+			})
+		})
+		ctx.Convey("When http request failed", func(ctx C) {
+			httpMock("GET", dao.main).Reply(500)
+			_, err := dao.LiveByType(c, mid, zoneid, keyword, mobiApp, device, platform, buvid, filtered, order, sType, plat, build, pn, ps, now)
+			ctx.Convey("Then err should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldNotBeNil)
+			})
+		})
+
+	})
+}
+
+// TestDao_Live dao ut.
+func TestDao_Live(t *testing.T) {
+	Convey("get Live", t, func() {
+		res, err := dao.Live(ctx(), 1, "iphone", "phone", "1", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", "123", "0", "1", 8190, 1, 20)
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDao_LiveAll dao ut.
+func TestDao_LiveAll(t *testing.T) {
+	Convey("get LiveAll", t, func() {
+		res, err := dao.LiveAll(ctx(), 1, "iphone", "phone", "1", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", "123", "0", "1", 8190, 1, 20)
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDao_ArticleByType dao ut.
+func TestDao_ArticleByType(t *testing.T) {
+	Convey("get ArticleByType", t, func() {
+		res, err := dao.ArticleByType(ctx(), 1, 12313, "iphone", "phone", "1", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", "123", "0", "1", "2", int8(1), 1, 8190, 1, 1, 20, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDao_HotSearch dao ut.
+func TestDao_HotSearch(t *testing.T) {
+	Convey("get HotSearch", t, func() {
+		res, err := dao.HotSearch(ctx(), "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", 123152242, 8190, 10, "iphone", "phone", "ios", time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDao_Suggest dao ut.
+func TestDao_Suggest(t *testing.T) {
+	Convey("get Suggest", t, func() {
+		res, err := dao.Suggest(ctx(), 12313, "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", "123", 8190, "iphone", "phone", time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDao_Suggest2 dao ut.
+func TestDao_Suggest2(t *testing.T) {
+	Convey("get Suggest2", t, func() {
+		res, err := dao.Suggest2(ctx(), 12313, "ios", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", "123", 8190, "iphone", time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDao_Suggest3 dao ut.
+func TestDao_Suggest3(t *testing.T) {
+	Convey("get Suggest3", t, func() {
+		res, err := dao.Suggest3(ctx(), 12313, "ios", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", "123", "phone", 8190, 1, "iphone", time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDao_Season2 dao ut.
+func TestDao_Season2(t *testing.T) {
+	Convey("get Season2", t, func() {
+		res, err := dao.Season2(ctx(), 12313, "test", "iphone", "phone", "ios", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", 1, 8220, 1, 20)
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDao_MovieByType2 dao ut.
+func TestDao_MovieByType2(t *testing.T) {
+	Convey("get MovieByType2", t, func() {
+		res, err := dao.MovieByType2(ctx(), 12313, "test", "iphone", "phone", "ios", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", 1, 8220, 1, 20)
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+// TestDaoUser dao ut.
+func TestDaoUser(t *testing.T) {
+	Convey("get User", t, func() {
+		_, err := dao.User(ctx(), 12313, "test", "iphone", "phone", "ios", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", "1", "total", "search", 1, 8220, 1, 1, 1, 20, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+// TestDao_Video dao ut.
+func TestDao_Video(t *testing.T) {
+	Convey("get Video", t, func() {
+		res, err := dao.Video(ctx(), 12313, "test", "iphone", "phone", "ios", "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc", 1, 8220, 1, 20)
+		err = nil
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+func ctx() context.Context {
+	return context.Background()
+}
+
+// TestDaoRecommend dao ut.
+func TestDaoRecommend(t *testing.T) {
+	var (
+		c        = context.Background()
+		mid      = int64(1)
+		build    = 1
+		from     = 0
+		show     = 1
+		buvid    = "123"
+		platform = "6E657F43-A770-4F7B-A6AE-FDFFCA8ED46216837infoc"
+		mobiApp  = "phone"
+		device   = "1"
+	)
+	Convey("Recommend", t, func(ctx C) {
+		dao.client.SetTransport(gock.DefaultTransport)
+		ctx.Convey("When res.Code != ecode.OK.Code()", func(ctx C) {
+			httpMock("GET", dao.rcmdNoResult).Reply(200).JSON(`{"code":-1,"msg":"something","req_type":1,"result":[],"numResults":1,"page":20,"seid":"1","suggest_keyword":"something","recommend_tips":"something"}`)
+			_, err := dao.Recommend(c, mid, build, from, show, buvid, platform, mobiApp, device)
+			ctx.Convey("Then err should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldNotBeNil)
+			})
+		})
+		ctx.Convey("When http request failed", func(ctx C) {
+			httpMock("GET", dao.rcmdNoResult).Reply(500)
+			_, err := dao.Recommend(c, mid, build, from, show, buvid, platform, mobiApp, device)
+			ctx.Convey("Then err should not be nil.", func(ctx C) {
+				ctx.So(err, ShouldNotBeNil)
+			})
+		})
+
+	})
+}

app/interface/main/app-interface/dao/shop/BUILD

@@ -0,0 +1,51 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/shop:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/shop",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/shop:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/shop/dao.go

@@ -0,0 +1,55 @@
+package shop
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/shop"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const _info = "/api/merchants/shop/info"
+
+type Dao struct {
+	client *httpx.Client
+	info   string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPClient),
+		info:   c.Host.Show + _info,
+	}
+	return
+}
+
+func (d *Dao) Info(c context.Context, mid int64, mobiApp, device string, build int) (info *shop.Info, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("mobi_app", mobiApp)
+	params.Set("device", device)
+	params.Set("build", strconv.Itoa(build))
+	var res struct {
+		Code int        `json:"errno"`
+		Data *shop.Info `json:"data"`
+	}
+	if err = d.client.Get(c, d.info, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		if res.Code == 130000 {
+			return
+		}
+		err = errors.Wrap(ecode.Int(res.Code), d.info+"?"+params.Encode())
+		return
+	}
+	info = res.Data
+	return
+}

app/interface/main/app-interface/dao/shop/dao_test.go

@@ -0,0 +1,65 @@
+package shop
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/shop"
+	httpx "go-common/library/net/http/blademaster"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotD := New(tt.args.c)
+			So(gotD, ShouldResemble, tt.wantD)
+		})
+	}
+}
+
+func TestDao_Info(t *testing.T) {
+	type fields struct {
+		client *httpx.Client
+		info   string
+	}
+	type args struct {
+		c       context.Context
+		mid     int64
+		mobiApp string
+		device  string
+		build   int
+	}
+	tests := []struct {
+		name     string
+		fields   fields
+		args     args
+		wantInfo *shop.Info
+		wantErr  error
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			d := &Dao{
+				client: tt.fields.client,
+				info:   tt.fields.info,
+			}
+			gotInfo, err := d.Info(tt.args.c, tt.args.mid, tt.args.mobiApp, tt.args.device, tt.args.build)
+			So(gotInfo, ShouldResemble, tt.wantInfo)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}

app/interface/main/app-interface/dao/sidebar/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/sidebar",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/service/main/resource/model:go_default_library",
+        "//app/service/main/resource/rpc/client:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/sidebar/dao.go

@@ -0,0 +1,32 @@
+package sidebar
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-interface/conf"
+	resmodel "go-common/app/service/main/resource/model"
+	resrpc "go-common/app/service/main/resource/rpc/client"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is sidebar dao
+type Dao struct {
+	resRPC *resrpc.Service
+}
+
+// New initial sidebar dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		resRPC: resrpc.New(c.ResourceRPC),
+	}
+	return
+}
+
+// Sidebars from resource service
+func (d *Dao) Sidebars(c context.Context) (res *resmodel.SideBars, err error) {
+	if res, err = d.resRPC.SideBars(c); err != nil {
+		err = errors.Wrapf(err, "d.resRPC.SideBars(%+v)")
+	}
+	return
+}

app/interface/main/app-interface/dao/sidebar/dao_test.go

@@ -0,0 +1,35 @@
+package sidebar
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/app-interface-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+}
+
+func WithDao(f func(d *Dao)) func() {
+	return func() {
+		Reset(func() {})
+		f(d)
+	}
+}
+
+func TestDao_Sidebar(t *testing.T) {
+	Convey("ArchiveInfo", t, WithDao(func(d *Dao) {
+		_, err := d.Sidebars(context.TODO())
+		So(err, ShouldBeNil)
+	}))
+}

app/interface/main/app-interface/dao/sp/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/sp",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/sp:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata: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-interface/dao/sp/dao.go

@@ -0,0 +1,47 @@
+package sp
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/sp"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+const (
+	_specil = "/sp/list"
+)
+
+// Dao is favorite dao
+type Dao struct {
+	client *httpx.Client
+	specil string
+}
+
+// New initial favorite dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPClient),
+		specil: c.Host.APICo + _specil,
+	}
+	return
+}
+
+// Specil get specil from old BiliWEB api.
+func (d *Dao) Specil(c context.Context, accessKey, actionKey, device, mobiApp, platform string, build, pn, ps int) (res *sp.Specil, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("access_key", accessKey)
+	params.Set("actionKey", actionKey)
+	params.Set("build", strconv.Itoa(build))
+	params.Set("device", device)
+	params.Set("mobi_app", mobiApp)
+	params.Set("page", strconv.Itoa(pn))
+	params.Set("pagesize", strconv.Itoa(ps))
+	params.Set("platform", platform)
+	err = d.client.Get(c, d.specil, ip, params, &res)
+	return
+}

app/interface/main/app-interface/dao/sp/dao_test.go

@@ -0,0 +1,33 @@
+package sp
+
+import (
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestNew(t *testing.T) {
+	Convey("TestNew", t, func() {
+
+	})
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotD := New(tt.args.c); !reflect.DeepEqual(gotD, tt.wantD) {
+				t.Errorf("New() = %v, want %v", gotD, tt.wantD)
+			}
+		})
+	}
+}

app/interface/main/app-interface/dao/space/BUILD

@@ -0,0 +1,50 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/space",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/space:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/space/dao.go

@@ -0,0 +1,130 @@
+package space
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/space"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_space             = "/x/internal/space/setting"
+	_video             = "/api/member/getVideo"
+	_uploadTopPhotoURL = "/api/member/getUploadTopPhoto"
+	_report            = "/api/report/add"
+	_blacklist         = "/x/internal/space/blacklist"
+)
+
+// Dao is space dao
+type Dao struct {
+	client     *httpx.Client
+	clientSync *httpx.Client
+	space      string
+	video      string
+	report     string
+	// space api
+	uploadTop string
+	blacklist string
+}
+
+// New initial space dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:     httpx.NewClient(c.HTTPClient),
+		clientSync: httpx.NewClient(c.HTTPWrite),
+		space:      c.Host.APICo + _space,
+		video:      c.Host.Space + _video,
+		report:     c.Host.Space + _report,
+		uploadTop:  c.Host.Space + _uploadTopPhotoURL,
+		blacklist:  c.Host.APICo + _blacklist,
+	}
+	return
+}
+
+// Setting get setting data from  api.
+func (d *Dao) Setting(c context.Context, mid int64) (setting *space.Setting, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Privacy *space.Setting `json:"privacy"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.space, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.space+"?"+params.Encode())
+	}
+	setting = res.Data.Privacy
+	return
+}
+
+// SpaceMob space mobile
+func (d *Dao) SpaceMob(c context.Context, mid, vmid int64, platform, device string) (us *space.Mob, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("vmid", strconv.FormatInt(vmid, 10))
+	params.Set("platform", platform)
+	params.Set("device", device)
+	var res struct {
+		Code int        `json:"code"`
+		Data *space.Mob `json:"data"`
+	}
+	if err = d.client.Get(c, d.uploadTop, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.uploadTop+"?"+params.Encode())
+		return
+	}
+	us = res.Data
+	return
+}
+
+// Report report
+func (d *Dao) Report(c context.Context, mid int64, reason, ak string) (err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("access_key", ak)
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("reason", reason)
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.report, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.report+"?"+params.Encode())
+	}
+	return
+}
+
+// Blacklist is.
+func (d *Dao) Blacklist(c context.Context) (list map[int64]struct{}, err error) {
+	var res struct {
+		Code int                `json:"code"`
+		Data map[int64]struct{} `json:"data"`
+	}
+	if err = d.clientSync.Get(c, d.blacklist, "", nil, &res); err != nil {
+		err = errors.Wrap(ecode.Int(res.Code), d.blacklist)
+		return
+	}
+	b, _ := json.Marshal(res)
+	log.Error("Blacklist url(%s) response(%s)", d.blacklist, b)
+	list = res.Data
+	return
+}

app/interface/main/app-interface/dao/space/dao_test.go

@@ -0,0 +1,71 @@
+package space
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	dao *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-interface")
+		flag.Set("conf_token", "1mWvdEwZHmCYGoXJCVIdszBOPVdtpXb3")
+		flag.Set("tree_id", "2688")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/app-interface-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	dao = New(conf.Conf)
+	os.Exit(m.Run())
+	// time.Sleep(time.Second)
+}
+
+// go test -conf="../../app-interface-test.toml"  -v -test.run TestSetting
+func TestDao_Setting(t *testing.T) {
+	Convey("TestSetting", t, func() {
+		setting, err := dao.Setting(context.Background(), 2)
+		So(setting, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDao_Blacklist(t *testing.T) {
+	Convey("Blacklist", t, func() {
+		gotFs, err := dao.Blacklist(context.Background())
+		So(gotFs, ShouldBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDao_Report(t *testing.T) {
+	Convey("TestReport", t, func() {
+		err := dao.Report(context.Background(), 1, "12", "123")
+		So(err, ShouldNotBeNil)
+	})
+}
+
+func TestDao_SpaceMob(t *testing.T) {
+	Convey("SpaceMob", t, func() {
+		gotMob, err := dao.SpaceMob(context.Background(), 1, 2, "", "")
+		So(gotMob, ShouldBeNil)
+		So(err, ShouldNotBeNil)
+	})
+}

app/interface/main/app-interface/dao/tag/BUILD

@@ -0,0 +1,54 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/tag:go_default_library",
+        "//app/interface/main/tag/rpc/client:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/tag",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/tag:go_default_library",
+        "//app/interface/main/tag/model:go_default_library",
+        "//app/interface/main/tag/rpc/client:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/tag/dao.go

@@ -0,0 +1,88 @@
+package tag
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	tagmdl "go-common/app/interface/main/app-interface/model/tag"
+	tag "go-common/app/interface/main/tag/model"
+	tagrpc "go-common/app/interface/main/tag/rpc/client"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_mInfo = "/x/internal/tag/minfo"
+)
+
+// Dao is tag dao
+type Dao struct {
+	tagRPC *tagrpc.Service
+	client *httpx.Client
+	mInfo  string
+}
+
+// New initial tag dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		tagRPC: tagrpc.New2(c.TagRPC),
+		client: httpx.NewClient(c.HTTPClient),
+		mInfo:  c.Host.APICo + _mInfo,
+	}
+	return
+}
+
+// ArcTags get tags data from api.
+func (d *Dao) ArcTags(c context.Context, aid, mid int64, ip string) (ts []*tagmdl.Tag, err error) {
+	arg := &tag.ArgAid{Aid: aid, Mid: mid, RealIP: ip}
+	tags, err := d.tagRPC.ArcTags(c, arg)
+	if err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+		return
+	}
+	if len(tags) == 0 {
+		return
+	}
+	ts = make([]*tagmdl.Tag, 0, len(tags))
+	for _, t := range tags {
+		tag := &tagmdl.Tag{
+			TagID:     t.ID,
+			Name:      t.Name,
+			Cover:     t.Cover,
+			Likes:     t.Likes,
+			Hates:     t.Hates,
+			Liked:     t.Liked,
+			Hated:     t.Hated,
+			Attribute: t.Attribute,
+		}
+		ts = append(ts, tag)
+	}
+	return
+}
+
+// TagInfos get tag infos by tagIds
+func (d *Dao) TagInfos(c context.Context, tags []int64, mid int64) (tagMyInfo []*tagmdl.Tag, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("tag_id", xstr.JoinInts(tags))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int           `json:"code"`
+		Data []*tagmdl.Tag `json:"data"`
+	}
+	if err = d.client.Get(c, d.mInfo, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.mInfo+"?"+params.Encode())
+		return
+	}
+	tagMyInfo = res.Data
+	return
+}

app/interface/main/app-interface/dao/tag/dao_test.go

@@ -0,0 +1,68 @@
+package tag
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+	tagmdl "go-common/app/interface/main/app-interface/model/tag"
+	tagrpc "go-common/app/interface/main/tag/rpc/client"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotD := New(tt.args.c)
+			So(gotD, ShouldEqual, tt.wantD)
+		})
+	}
+}
+
+func TestDao_ArcTags(t *testing.T) {
+	type fields struct {
+		tagRPC *tagrpc.Service
+	}
+	type args struct {
+		c   context.Context
+		aid int64
+		mid int64
+		ip  string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantTs  []*tagmdl.Tag
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				tagRPC: tt.fields.tagRPC,
+			}
+			gotTs, err := d.ArcTags(tt.args.c, tt.args.aid, tt.args.mid, tt.args.ip)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.ArcTags() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotTs, tt.wantTs) {
+				t.Errorf("Dao.ArcTags() = %v, want %v", gotTs, tt.wantTs)
+			}
+		})
+	}
+}

app/interface/main/app-interface/dao/thumbup/BUILD

@@ -0,0 +1,48 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/thumbup",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/service/main/thumbup/model:go_default_library",
+        "//app/service/main/thumbup/rpc/client:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/thumbup/dao.go

@@ -0,0 +1,43 @@
+package thumbup
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-interface/conf"
+	thumbup "go-common/app/service/main/thumbup/model"
+	thumbuprpc "go-common/app/service/main/thumbup/rpc/client"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is tag dao
+type Dao struct {
+	thumbupRPC *thumbuprpc.Service
+}
+
+// New initial tag dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		thumbupRPC: thumbuprpc.New(c.ThumbupRPC),
+	}
+	return
+}
+
+// UserLikes user likes list
+func (d *Dao) UserTotalLike(c context.Context, mid int64, business string, pn, ps int) (res []*thumbup.ItemLikeRecord, count int, err error) {
+	var (
+		likes *thumbup.UserTotalLike
+		ip    = metadata.String(c, metadata.RemoteIP)
+	)
+	arg := &thumbup.ArgUserLikes{Mid: mid, Business: business, Pn: pn, Ps: ps, RealIP: ip}
+	if likes, err = d.thumbupRPC.UserTotalLike(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+		return
+	}
+	if likes != nil {
+		res = likes.List
+		count = likes.Total
+	}
+	return
+}

app/interface/main/app-interface/dao/thumbup/dao_test.go

@@ -0,0 +1,33 @@
+package thumbup
+
+import (
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestNew(t *testing.T) {
+	Convey("TestNew", t, func() {
+
+	})
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotD := New(tt.args.c); !reflect.DeepEqual(gotD, tt.wantD) {
+				t.Errorf("New() = %v, want %v", gotD, tt.wantD)
+			}
+		})
+	}
+}

app/interface/main/app-interface/dao/ticket/BUILD

@@ -0,0 +1,47 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/ticket",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/ticket/dao.go

@@ -0,0 +1,48 @@
+package ticket
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const _favCount = "/api/ticket/user/favcountinner"
+
+type Dao struct {
+	client   *bm.Client
+	favCount string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:   bm.NewClient(c.HTTPClient),
+		favCount: c.Host.Show + _favCount,
+	}
+	return
+}
+
+func (d *Dao) FavCount(c context.Context, mid int64) (count int32, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int   `json:"errno"`
+		Data int32 `json:"data"`
+	}
+	if err = d.client.Get(c, d.favCount, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.favCount+"?"+params.Encode())
+		return
+	}
+	count = res.Data
+	return
+}

app/interface/main/app-interface/dao/ticket/dao_test.go

@@ -0,0 +1,52 @@
+package ticket
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-interface")
+		flag.Set("conf_token", "1mWvdEwZHmCYGoXJCVIdszBOPVdtpXb3")
+		flag.Set("tree_id", "2688")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}
+
+func TestFavCount(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(27515233)
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		count, err := d.FavCount(c, mid)
+		fmt.Printf("%d", count)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/app-interface/dao/topic/BUILD

@@ -0,0 +1,51 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/interface/main/app-interface/dao/topic",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-interface/conf:go_default_library",
+        "//app/interface/main/app-interface/model/topic:go_default_library",
+        "//app/service/main/favorite/api:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors: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-interface/dao/topic/dao.go

@@ -0,0 +1,79 @@
+package topic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-interface/conf"
+	"go-common/app/interface/main/app-interface/model/topic"
+	fav "go-common/app/service/main/favorite/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const _topic = "/x/internal/v2/fav/topic"
+
+// Dao is topic dao
+type Dao struct {
+	client *httpx.Client
+	topic  string
+	favRPC fav.FavoriteClient
+}
+
+// New initial topic dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPClient),
+		topic:  c.Host.APICo + _topic,
+	}
+	var err error
+	d.favRPC, err = fav.New(c.FavClient)
+	if err != nil {
+		panic(fmt.Sprintf("fav NewClient error(%v)", err))
+	}
+	return
+}
+
+// Topic get topic list from UGC api.
+func (d *Dao) Topic(c context.Context, accessKey, actionKey, device, mobiApp, platform string, build, ps, pn int, mid int64) (t *topic.Topic, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("access_key", accessKey)
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("actionKey", actionKey)
+	params.Set("build", strconv.Itoa(build))
+	params.Set("device", device)
+	params.Set("mobi_app", mobiApp)
+	params.Set("platform", platform)
+	params.Set("ps", strconv.Itoa(ps))
+	params.Set("pn", strconv.Itoa(pn))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int          `json:"code"`
+		Data *topic.Topic `json:"data"`
+	}
+	if err = d.client.Get(c, d.topic, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.topic+"?"+params.Encode())
+		return
+	}
+	t = res.Data
+	return
+}
+
+// UserFolder is
+func (d *Dao) UserFolder(c context.Context, mid int64, typ int32) (userFolder *fav.UserFolderReply, err error) {
+	if userFolder, err = d.favRPC.UserFolder(c, &fav.UserFolderReq{Typ: typ, Mid: mid}); err != nil {
+		log.Error("d.favRPC.UserFolder error(%+v)", err)
+		return
+	}
+	return
+}

app/interface/main/app-interface/dao/topic/dao_test.go

@@ -0,0 +1,74 @@
+package topic
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-interface/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-interface")
+		flag.Set("conf_token", "1mWvdEwZHmCYGoXJCVIdszBOPVdtpXb3")
+		flag.Set("tree_id", "2688")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/app-interface-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+	// time.Sleep(time.Second)
+}
+
+func TestTopic(t *testing.T) {
+	var (
+		c         = context.TODO()
+		accessKey = ""
+		actionKey = ""
+		device    = ""
+		mobiApp   = ""
+		platform  = ""
+		build     = 111
+		ps        = 5
+		pn        = 1
+		mid       = int64(1)
+	)
+	convey.Convey("Topic", t, func(ctx convey.C) {
+		_, err := d.Topic(c, accessKey, actionKey, device, mobiApp, platform, build, ps, pn, mid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestUserFolder(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		typ = int32(4)
+	)
+	convey.Convey("UserFolder", t, func(ctx convey.C) {
+		_, err := d.UserFolder(c, mid, typ)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}