Create & Init Project...

app/interface/main/app-view/dao/account/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-view/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-view/dao/account",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//app/service/main/account/rpc/client:go_default_library",
+        "//library/log: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-view/dao/account/dao.go

@@ -0,0 +1,80 @@
+package account
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-view/conf"
+	account "go-common/app/service/main/account/model"
+	accrpc "go-common/app/service/main/account/rpc/client"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is account dao.
+type Dao struct {
+	// rpc
+	accRPC *accrpc.Service3
+}
+
+// New account dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		accRPC: accrpc.New3(c.AccountRPC),
+	}
+	return
+}
+
+// Card3 get card info by mid
+func (d *Dao) Card3(c context.Context, mid int64) (res *account.Card, err error) {
+	arg := &account.ArgMid{Mid: mid}
+	if res, err = d.accRPC.Card3(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+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", arg)
+	}
+	return
+}
+
+// Following3 following.
+func (d *Dao) Following3(c context.Context, mid, owner int64) (follow bool, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &account.ArgRelation{Mid: mid, Owner: owner, RealIP: ip}
+	rl, err := d.accRPC.Relation3(c, arg)
+	if err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+		return
+	}
+	if rl != nil {
+		follow = rl.Following
+	}
+	return
+}
+
+// IsAttention is attention
+func (d *Dao) IsAttention(c context.Context, owners []int64, mid int64) (isAtten map[int64]int8) {
+	if len(owners) == 0 || mid == 0 {
+		return
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &account.ArgRelations{Owners: owners, Mid: mid, RealIP: ip}
+	res, err := d.accRPC.Relations3(c, arg)
+	if err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	isAtten = make(map[int64]int8, len(res))
+	for mid, rel := range res {
+		if rel.Following {
+			isAtten[mid] = 1
+		}
+	}
+	return
+}

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

@@ -0,0 +1,40 @@
+package account
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(5 * time.Second)
+}
+
+func Test_Card(t *testing.T) {
+	Convey("Card", t, func() {
+		acc, err := d.Card3(context.TODO(), 2)
+		So(err, ShouldBeNil)
+		Println(acc)
+	})
+}
+
+func Test_Following(t *testing.T) {
+	Convey("Following", t, func() {
+		_, err := d.Following3(context.TODO(), 2, 1684013)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-view/dao/act/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-view/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-view/dao/act",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/activity/model/like:go_default_library",
+        "//app/interface/main/activity/rpc/client:go_default_library",
+        "//app/interface/main/app-view/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-view/dao/act/dao.go

@@ -0,0 +1,111 @@
+package act
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	actmdl "go-common/app/interface/main/activity/model/like"
+	actrpc "go-common/app/interface/main/activity/rpc/client"
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_actInfo      = "/matsuri/api/get/videoviewinfo"
+	_lotteryTimes = "/matsuri/api/get/act/mylotterytimes"
+)
+
+// Dao is elec dao.
+type Dao struct {
+	client       *httpx.Client
+	actInfo      string
+	lotteryTimes string
+	actRPC       *actrpc.Service
+}
+
+// New elec dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:       httpx.NewClient(c.HTTPClient),
+		actInfo:      c.Host.Activity + _actInfo,
+		lotteryTimes: c.Host.Activity + _lotteryTimes,
+		actRPC:       actrpc.New(c.ActivityRPC),
+	}
+	return
+}
+
+var _emptyList = []string{}
+
+// Info mid+aid total elec info
+func (d *Dao) Info(c context.Context, actID int64, randomCnt int64) (gifts, winners []string, err error) {
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Gifts []struct {
+				Img string `json:"sponsors_logo"`
+			} `json:"gifts"`
+			Winner []struct {
+				Gift  string `json:"gift"`
+				UName string `json:"uname"`
+			} `json:"winner"`
+		} `json:"data"`
+	}
+	params := url.Values{}
+	params.Set("act_id", strconv.FormatInt(actID, 10))
+	params.Set("random_count", strconv.FormatInt(randomCnt, 10))
+	if err = d.client.Get(c, d.actInfo, "", params, &res); err != nil {
+		err = errors.Wrapf(err, "d.client.Get(%s)", d.actInfo+"?"+params.Encode())
+		return _emptyList, _emptyList, err
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrapf(ecode.Int(res.Code), "d.client.Get(%s)", d.actInfo+"?"+params.Encode())
+		return _emptyList, _emptyList, err
+	}
+	for _, v := range res.Data.Gifts {
+		gifts = append(gifts, v.Img)
+	}
+	for _, v := range res.Data.Winner {
+		winners = append(winners, v.UName+" 抽到了 "+v.Gift)
+	}
+	if gifts == nil {
+		gifts = _emptyList
+	}
+	if winners == nil {
+		winners = _emptyList
+	}
+	return
+}
+
+// LeftLotteryTimes 剩余抽奖次数
+func (d *Dao) LeftLotteryTimes(c context.Context, actID, mid int64) (times int64, err error) {
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Times int64 `json:"times"`
+		} `json:"data"`
+	}
+	params := url.Values{}
+	params.Set("act_id", strconv.FormatInt(actID, 10))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	if err = d.client.Get(c, d.lotteryTimes, "", params, &res); err != nil {
+		err = errors.Wrapf(err, "d.client.Get(%s)", d.lotteryTimes+"?"+params.Encode())
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrapf(ecode.Int(res.Code), "d.client.Get(%s)", d.lotteryTimes+"?"+params.Encode())
+		return
+	}
+	times = res.Data.Times
+	return
+}
+
+// ActProtocol get act subject & protocol
+func (d *Dao) ActProtocol(c context.Context, messionID int64) (protocol *actmdl.SubProtocol, err error) {
+	arg := &actmdl.ArgActProtocol{Sid: messionID}
+	protocol, err = d.actRPC.ActProtocol(c, arg)
+	return
+}

app/interface/main/app-view/dao/act/dao_test.go

@@ -0,0 +1,80 @@
+package act
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-view/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-view")
+		flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
+		flag.Set("tree_id", "4575")
+		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 TestInfo(t *testing.T) {
+	var (
+		c         = context.TODO()
+		actID     = int64(1)
+		randomCnt = int64(10)
+	)
+	convey.Convey("Info", t, func(ctx convey.C) {
+		_, _, err := d.Info(c, actID, randomCnt)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestLeftLotteryTimes(t *testing.T) {
+	var (
+		c     = context.TODO()
+		actID = int64(1)
+		mid   = int64(1)
+	)
+	convey.Convey("LeftLotteryTimes", t, func(ctx convey.C) {
+		_, err := d.LeftLotteryTimes(c, actID, mid)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestActProtocol(t *testing.T) {
+	var (
+		c         = context.TODO()
+		messionID = int64(10338)
+	)
+	convey.Convey("ActProtocol", t, func(ctx convey.C) {
+		act, err := d.ActProtocol(c, messionID)
+		fmt.Printf("=====%#v======", act)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/app-view/dao/ad/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-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/ad: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-view/dao/ad",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/ad: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-view/dao/ad/dao.go

@@ -0,0 +1,98 @@
+package ad
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/ad"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_adURL          = "/bce/api/bce/wise"
+	_monitorInfoURL = "/up-openapi/api/v1/av_monitor_info/%d"
+)
+
+// Dao dao.
+type Dao struct {
+	client         *bm.Client
+	adURL          string
+	monitorInfoURL string
+}
+
+// New account dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:         bm.NewClient(conf.Conf.HTTPAD),
+		adURL:          c.Host.AD + _adURL,
+		monitorInfoURL: c.Host.AD + _monitorInfoURL,
+	}
+	return
+}
+
+// Ad ad request.
+func (d *Dao) Ad(c context.Context, mobiApp, device, buvid string, build int, mid, upperID, aid int64, rid int32, tids []int64, resource []int64, network, adExtra string) (advert *ad.Ad, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	params.Set("build", strconv.Itoa(build))
+	params.Set("device", device)
+	params.Set("buvid", buvid)
+	params.Set("resource", xstr.JoinInts(resource))
+	params.Set("mobi_app", mobiApp)
+	params.Set("ip", ip)
+	params.Set("av_rid", strconv.FormatInt(int64(rid), 10))
+	params.Set("av_tid", xstr.JoinInts(tids))
+	params.Set("av_up_id", strconv.FormatInt(upperID, 10))
+	if network != "" {
+		params.Set("network", network)
+	}
+	if adExtra != "" {
+		params.Set("ad_extra", adExtra)
+	}
+	var res struct {
+		Code int    `json:"code"`
+		Data *ad.Ad `json:"data"`
+	}
+	if err = d.client.Get(c, d.adURL, ip, params, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrap(code, d.adURL+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		res.Data.ClientIP = ip
+	}
+	advert = res.Data
+	return
+}
+
+// MonitorInfo ad aid monitor info
+func (d *Dao) MonitorInfo(c context.Context, aid int64) (minfo json.RawMessage, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	var res struct {
+		Code int             `json:"code"`
+		Data json.RawMessage `json:"data"`
+	}
+	if err = d.client.RESTfulGet(c, d.monitorInfoURL, ip, nil, &res, aid); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrap(code, d.monitorInfoURL)
+		return
+	}
+	minfo = res.Data
+	return
+}

app/interface/main/app-view/dao/ad/dao_test.go

@@ -0,0 +1,52 @@
+package ad
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/ad"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	dao *Dao
+)
+
+func init() {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-view")
+		flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
+		flag.Set("tree_id", "4575")
+		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)
+	}
+	dao = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestDao_Ad(t *testing.T) {
+	Convey("get TestDao_Ad", t, func() {
+		res, err := dao.Ad(ctx(), "iphone", "phone", "12312", 111, 111, 2222, 1, 1, []int64{1}, []int64{1}, "4g", "")
+		err = nil
+		res = &ad.Ad{}
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func ctx() context.Context {
+	return context.Background()
+}

app/interface/main/app-view/dao/ai/BUILD

@@ -0,0 +1,45 @@
+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-view/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-view/dao/ai",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf: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-view/dao/ai/dao.go

@@ -0,0 +1,34 @@
+package ai
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-view/conf"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+const (
+	_av2GameURL = "/avid2gameid"
+)
+
+type Dao struct {
+	client     *bm.Client
+	av2GameURL string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:     bm.NewClient(c.HTTPGameAsync),
+		av2GameURL: c.Host.AI + _av2GameURL,
+	}
+	return
+}
+
+func (d *Dao) Av2Game(c context.Context) (res map[int64]int64, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	if err = d.client.Get(c, d.av2GameURL, ip, nil, &res); err != nil {
+		return
+	}
+	return
+}

app/interface/main/app-view/dao/ai/dao_test.go

@@ -0,0 +1,65 @@
+package ai
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-view/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-view-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_Av2Game(t *testing.T) {
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantRes map[int64]int64
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotRes, err := d.Av2Game(tt.args.c)
+			So(err, ShouldEqual, tt.wantErr)
+			So(gotRes, ShouldResemble, tt.wantRes)
+		})
+	}
+}

app/interface/main/app-view/dao/archive/BUILD

@@ -0,0 +1,73 @@
+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",
+        "memcache_test.go",
+        "stat_test.go",
+        "view_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/service/main/archive/model/archive:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "bnj.go",
+        "dao.go",
+        "memcache.go",
+        "stat.go",
+        "view.go",
+    ],
+    importpath = "go-common/app/interface/main/app-view/dao/archive",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/view:go_default_library",
+        "//app/interface/main/history/model:go_default_library",
+        "//app/interface/main/history/rpc/client: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/net/metadata:go_default_library",
+        "//library/sync/errgroup: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-view/dao/archive/api.go

@@ -0,0 +1,140 @@
+package archive
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-view/model/view"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_realteURL     = "/recsys/related"
+	_commercialURL = "/x/internal/creative/arc/commercial"
+	_relateRecURL  = "/recommand"
+	_playURL       = "/playurl/batch"
+)
+
+// RelateAids get relate by aid
+func (d *Dao) RelateAids(c context.Context, aid int64) (aids []int64, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("key", strconv.FormatInt(aid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data []*struct {
+			Value string `json:"value"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.realteURL, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.realteURL+"?"+params.Encode())
+		return
+	}
+	if len(res.Data) != 0 {
+		if aids, err = xstr.SplitInts(res.Data[0].Value); err != nil {
+			err = errors.Wrap(err, res.Data[0].Value)
+		}
+	}
+	return
+}
+
+// Commercial is
+func (d *Dao) Commercial(c context.Context, aid int64) (gameID int64, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			GameID int64 `json:"game_id"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.commercialURL, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.commercialURL+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		gameID = res.Data.GameID
+	}
+	return
+}
+
+// NewRelateAids relate online recommend 在线实时推荐
+func (d *Dao) NewRelateAids(c context.Context, aid, mid int64, build, parentMode int, buvid, from string, plat int8) (rec []*view.NewRelateRec, userFeature, returnCode string, dalaoExp int, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("from", "2")
+	params.Set("cmd", "related")
+	params.Set("timeout", "100")
+	params.Set("plat", strconv.Itoa(int(plat)))
+	params.Set("build", strconv.Itoa(build))
+	params.Set("buvid", buvid)
+	params.Set("from_av", strconv.FormatInt(aid, 10))
+	params.Set("request_cnt", "40")
+	params.Set("source_page", from)
+	params.Set("parent_mode", strconv.Itoa(parentMode))
+	params.Set("need_dalao", "1")
+	var res struct {
+		Code        int                  `json:"code"`
+		Data        []*view.NewRelateRec `json:"data"`
+		UserFeature string               `json:"user_feature"`
+		DalaoExp    int                  `json:"dalao_exp"`
+	}
+	log.Warn("dalaotest url(%s)", d.relateRecURL+"?"+params.Encode())
+	if err = d.client.Get(c, d.relateRecURL, ip, params, &res); err != nil {
+		returnCode = "500"
+		return
+	}
+	returnCode = strconv.Itoa(res.Code)
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.relateRecURL+"?"+params.Encode())
+		return
+	}
+	dalaoExp = res.DalaoExp
+	userFeature = res.UserFeature
+	rec = res.Data
+	return
+}
+
+// PlayerInfos cid with player info
+func (d *Dao) PlayerInfos(c context.Context, cids []int64, qn, fnver, fnval, forceHost int, platform string) (pm map[uint32]*archive.BvcVideoItem, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("cid", xstr.JoinInts(cids))
+	params.Set("qn", strconv.Itoa(qn))
+	params.Set("platform", platform)
+	params.Set("uip", ip)
+	params.Set("layout", "pb")
+	params.Set("fnver", strconv.Itoa(fnver))
+	params.Set("fnval", strconv.Itoa(fnval))
+	params.Set("force_host", strconv.Itoa(forceHost))
+	var req *http.Request
+	if req, err = d.client.NewRequest("GET", d.playURL, ip, params); err != nil {
+		return
+	}
+	res := new(archive.BvcResponseMsg)
+	if err = d.httpClient.PB(c, req, res); err != nil {
+		return
+	}
+	if int(res.Code) != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(int(res.Code)), d.playURL+params.Encode())
+		return
+	}
+	pm = res.Data
+	return
+}

app/interface/main/app-view/dao/archive/api_test.go

@@ -0,0 +1,21 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestRelateAids(t *testing.T) {
+	var (
+		c   = context.TODO()
+		aid = int64(1)
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, err := d.RelateAids(c, aid)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}

app/interface/main/app-view/dao/archive/bnj.go

@@ -0,0 +1,19 @@
+package archive
+
+import (
+	"context"
+
+	"go-common/app/service/main/archive/model/archive"
+)
+
+// ViewsRPC is
+func (d *Dao) ViewsRPC(c context.Context, aids []int64) (avm map[int64]*archive.View3, err error) {
+	avm, err = d.arcRPC.Views3(c, &archive.ArgAids2{Aids: aids})
+	return
+}
+
+// ViewRPC is
+func (d *Dao) ViewRPC(c context.Context, aid int64) (v *archive.View3, err error) {
+	v, err = d.arcRPC.View3(c, &archive.ArgAid2{Aid: aid})
+	return
+}

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

@@ -0,0 +1,220 @@
+package archive
+
+import (
+	"context"
+	"runtime"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/view"
+	"go-common/app/service/main/archive/api"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/sync/errgroup"
+
+	history "go-common/app/interface/main/history/model"
+	hisrpc "go-common/app/interface/main/history/rpc/client"
+	arcrpc "go-common/app/service/main/archive/api/gorpc"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is archive dao.
+type Dao struct {
+	// http client
+	client        *bm.Client
+	httpClient    *bm.Client
+	realteURL     string
+	commercialURL string
+	relateRecURL  string
+	playURL       string
+	// rpc
+	arcRPC *arcrpc.Service2
+	hisRPC *hisrpc.Service
+	// memcache
+	arcMc     *memcache.Pool
+	expireArc int32
+	expireRlt int32
+	// chan
+	mCh chan func()
+}
+
+// New new a archive dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		client:        bm.NewClient(c.HTTPWrite),
+		httpClient:    bm.NewClient(c.HTTPClient),
+		arcRPC:        arcrpc.New2(c.ArchiveRPC),
+		hisRPC:        hisrpc.New(c.HisRPC),
+		realteURL:     c.Host.Data + _realteURL,
+		commercialURL: c.Host.APICo + _commercialURL,
+		relateRecURL:  c.Host.Data + _relateRecURL,
+		playURL:       c.Host.Bvcvod + _playURL,
+		// memcache
+		arcMc:     memcache.NewPool(c.Memcache.Archive.Config),
+		expireArc: int32(time.Duration(c.Memcache.Archive.ArchiveExpire) / time.Second),
+		expireRlt: int32(time.Duration(c.Memcache.Archive.RelateExpire) / time.Second),
+		// mc proc
+		mCh: make(chan func(), 10240),
+	}
+	// video db
+	for i := 0; i < runtime.NumCPU()*2; i++ {
+		go d.cacheproc()
+	}
+	return
+}
+
+// Ping ping check memcache connection
+func (d *Dao) Ping(c context.Context) (err error) {
+	return d.pingMC(c)
+}
+
+// Archive3 get archive.
+func (d *Dao) Archive3(c context.Context, aid int64) (a *api.Arc, err error) {
+	arg := &archive.ArgAid2{Aid: aid}
+	if a, err = d.arcRPC.Archive3(c, arg); err != nil {
+		log.Error("d.arcRPC.Archive3(%v) error(%+v)", arg, err)
+		return
+	}
+	return
+}
+
+// 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
+	}
+	var stm map[int64]*api.Stat
+	g, ctx := errgroup.WithContext(c)
+	g.Go(func() (err error) {
+		var missed []int64
+		if as, missed, err = d.arcsCache(ctx, aids); err != nil {
+			as = make(map[int64]*api.Arc, len(aids))
+			missed = aids
+			log.Error("%+v", err)
+			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
+	})
+	g.Go(func() (err error) {
+		var missed []int64
+		if stm, missed, err = d.statsCache(ctx, aids); err != nil {
+			stm = make(map[int64]*api.Stat, len(aids))
+			missed = aids
+			log.Error("%+v", err)
+			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 {
+		log.Error("%+v", err)
+		return
+	}
+	for aid, a := range as {
+		if st, ok := stm[aid]; ok {
+			a.Stat = *st
+		}
+	}
+	return
+}
+
+// Shot get video shot.
+func (d *Dao) Shot(c context.Context, aid, cid int64) (shot *archive.Videoshot, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &archive.ArgCid2{Aid: aid, Cid: cid, RealIP: ip}
+	return d.arcRPC.Videoshot2(c, arg)
+}
+
+// UpCount2 get upper count.
+func (d *Dao) UpCount2(c context.Context, mid int64) (cnt int, err error) {
+	arg := &archive.ArgUpCount2{Mid: mid}
+	if cnt, err = d.arcRPC.UpCount2(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	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 {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+// Progress is  archive plays progress .
+func (d *Dao) Progress(c context.Context, aid, mid int64) (h *view.History, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &history.ArgPro{Mid: mid, Aids: []int64{aid}, RealIP: ip}
+	his, err := d.hisRPC.Progress(c, arg)
+	if err != nil {
+		log.Error("d.hisRPC.Progress(%v) error(%v)", arg, err)
+		return
+	}
+	if his[aid] != nil {
+		h = &view.History{Cid: his[aid].Cid, Progress: his[aid].Pro}
+	}
+	return
+}
+
+// Archive 用的时候注意了！！！这个方法得到的稿件Stat不是最新的！！！
+func (d *Dao) Archive(c context.Context, aid int64) (a *api.Arc, err error) {
+	if a, err = d.arcCache(c, aid); err != nil {
+		log.Error("%+v", err)
+	} else if a != nil {
+		return
+	}
+	if a, err = d.arcRPC.Archive3(c, &archive.ArgAid2{Aid: aid}); err != nil {
+		log.Error("d.arcRPC.Archive3(%d) error(%v)", aid, err)
+		return
+	}
+	return
+}
+
+// addCache add archive to mc or redis
+func (d *Dao) addCache(f func()) {
+	select {
+	case d.mCh <- f:
+	default:
+		log.Warn("cacheproc chan full")
+	}
+}
+
+// cacheproc write memcache and stat redis use goroutine
+func (d *Dao) cacheproc() {
+	for {
+		f := <-d.mCh
+		f()
+	}
+}

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

@@ -0,0 +1,162 @@
+package archive
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/net/rpc"
+	xtime "go-common/library/time"
+
+	"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-view")
+		flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
+		flag.Set("tree_id", "4575")
+		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 TestViewRPC(t *testing.T) {
+	convey.Convey("TestViewRPC", t, func(ctx convey.C) {
+		var addr = "172.22.36.185:6089" // new
+		// addr = "172.22.38.5:6089"       // old
+		client := rpc.Dial(addr, xtime.Duration(100*time.Millisecond), nil)
+		var (
+			view  *archive.View3
+			views map[int64]*archive.View3
+			err   error
+		)
+		if err = client.Call(context.TODO(), "RPC.View3", &archive.ArgAid{Aid: 10111165}, &view); err != nil {
+			ctx.Println(err)
+			return
+		}
+		ctx.Println(view)
+		if err = client.Call(context.TODO(), "RPC.Views3", &archive.ArgAids{Aids: []int64{10111165}}, &views); err != nil {
+			ctx.Println(err)
+			return
+		}
+		ctx.Println(views)
+	})
+}
+
+func TestPing(t *testing.T) {
+	var (
+		c = context.TODO()
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		d.Ping(c)
+	})
+}
+
+func TestArchive3(t *testing.T) {
+	var (
+		c   = context.TODO()
+		aid = int64(0)
+	)
+	convey.Convey("Archive3", t, func(ctx convey.C) {
+		_, err := d.Archive3(c, aid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestArchives(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 TestShot(t *testing.T) {
+	var (
+		c   = context.TODO()
+		aid = int64(1)
+		cid = int64(2)
+	)
+	convey.Convey("Shot", t, func(ctx convey.C) {
+		d.Shot(c, aid, cid)
+	})
+}
+
+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 TestUpArcs3(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		pn  = int(1)
+		ps  = int(20)
+	)
+	convey.Convey("UpArcs3", t, func(ctx convey.C) {
+		d.UpArcs3(c, mid, pn, ps)
+	})
+}
+
+func TestProgress(t *testing.T) {
+	var (
+		c   = context.TODO()
+		aid = int64(1)
+		mid = int64(1)
+	)
+	convey.Convey("Progress", t, func(ctx convey.C) {
+		_, err := d.Progress(c, aid, 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()
+		aid = int64(-1)
+	)
+	convey.Convey("Archive", t, func(ctx convey.C) {
+		_, err := d.Archive(c, aid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}

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

@@ -0,0 +1,246 @@
+package archive
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/app-view/model/view"
+	"go-common/app/service/main/archive/api"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_prefixRelate         = "al_"
+	_prefixViewStatic     = "avp_"
+	_prefixStat           = "stp_"
+	_prefixArchive        = "a3p_"
+	_prefixViewContribute = "avpc_"
+)
+
+func keyRl(aid int64) string {
+	return _prefixRelate + strconv.FormatInt(aid, 10)
+}
+
+func keyView(aid int64) string {
+	return _prefixViewStatic + strconv.FormatInt(aid, 10)
+}
+
+func keyStat(aid int64) string {
+	return _prefixStat + strconv.FormatInt(aid, 10)
+}
+
+func keyArc(aid int64) string {
+	return _prefixArchive + strconv.FormatInt(aid, 10)
+}
+
+func keyViewContribute(mid int64) string {
+	return _prefixViewContribute + strconv.FormatInt(mid, 10)
+}
+
+// AddRelatesCache add relates
+func (d *Dao) AddRelatesCache(aid int64, rls []*view.Relate) {
+	d.addCache(func() {
+		d.addRelatesCache(context.TODO(), aid, rls)
+	})
+}
+
+// RelatesCache get relates.
+func (d *Dao) RelatesCache(c context.Context, aid int64) (rls []*view.Relate, err error) {
+	conn := d.arcMc.Get(c)
+	key := keyRl(aid)
+	defer conn.Close()
+	r, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "conn.Get(%s)", key)
+		return
+	}
+	if err = conn.Scan(r, &rls); err != nil {
+		err = errors.Wrapf(err, "conn.Scan(%s)", r.Value)
+	}
+	return
+}
+
+// addRelatesCache add relates cache.
+func (d *Dao) addRelatesCache(c context.Context, aid int64, rls []*view.Relate) (err error) {
+	conn := d.arcMc.Get(c)
+	key := keyRl(aid)
+	item := &memcache.Item{Key: key, Object: rls, Flags: memcache.FlagJSON, Expiration: d.expireRlt}
+	if err = conn.Set(item); err != nil {
+		err = errors.Wrapf(err, "conn.Set(%s,%v,%d)", key, rls, d.expireRlt)
+	}
+	conn.Close()
+	return
+}
+
+// viewCache get view cache from remote memecache .
+func (d *Dao) viewCache(c context.Context, aid int64) (vs *archive.View3, err error) {
+	conn := d.arcMc.Get(c)
+	key := keyView(aid)
+	defer conn.Close()
+	r, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "conn.Get(%s)", key)
+		return
+	}
+	vs = &archive.View3{Archive3: &archive.Archive3{}}
+	if err = conn.Scan(r, vs); err != nil {
+		vs = nil
+		err = errors.Wrapf(err, "conn.Scan(%s)", r.Value)
+	}
+	return
+}
+
+// statCache get a archive stat from cache.
+func (d *Dao) statCache(c context.Context, aid int64) (st *api.Stat, err error) {
+	conn := d.arcMc.Get(c)
+	key := keyStat(aid)
+	defer conn.Close()
+	r, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "conn.Get(%s)", key)
+		return
+	}
+	st = &api.Stat{}
+	if err = conn.Scan(r, st); err != nil {
+		st = nil
+		err = errors.Wrapf(err, "conn.Scan(%s)", r.Value)
+	}
+	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))
+	conn := d.arcMc.Get(c)
+	defer conn.Close()
+	keys := make([]string, 0, len(aids))
+	for _, aid := range aids {
+		keys = append(keys, keyStat(aid))
+	}
+	rs, err := conn.GetMulti(keys)
+	if err != nil {
+		err = errors.Wrapf(err, "conn.GetMulti(%v)", keys)
+		return
+	}
+	for _, item := range rs {
+		var st = &api.Stat{}
+		if err = conn.Scan(item, st); err != nil {
+			err = nil
+			log.Error("conn.Scan(%v) error(%v)", item, err)
+			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
+}
+
+// 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))
+	conn := d.arcMc.Get(c)
+	defer conn.Close()
+	keys := make([]string, 0, len(aids))
+	aidmap := make(map[string]int64, len(aids))
+	for _, aid := range aids {
+		k := keyArc(aid)
+		if _, ok := aidmap[k]; !ok {
+			keys = append(keys, k)
+			aidmap[k] = aid
+		}
+	}
+	rs, err := conn.GetMulti(keys)
+	if err != nil {
+		err = errors.Wrapf(err, "conn.GetMulti(%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
+}
+
+// arcCache get archive cache.
+func (d *Dao) arcCache(c context.Context, aid int64) (a *api.Arc, err error) {
+	conn := d.arcMc.Get(c)
+	key := keyArc(aid)
+	defer conn.Close()
+	r, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "conn.Get(%s)", key)
+		return
+	}
+	a = &api.Arc{}
+	if err = conn.Scan(r, a); err != nil {
+		a = nil
+		err = errors.Wrapf(err, "conn.Scan(%s)", r.Value)
+	}
+	return
+}
+
+// ViewContributeCache get archive cache.
+func (d *Dao) ViewContributeCache(c context.Context, mid int64) (aids []int64, err error) {
+	conn := d.arcMc.Get(c)
+	key := keyViewContribute(mid)
+	defer conn.Close()
+	r, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "conn.Get(%s)", key)
+		return
+	}
+	if err = conn.Scan(r, &aids); err != nil {
+		err = errors.Wrapf(err, "conn.Scan(%s)", r.Value)
+	}
+	return
+}
+
+func (d *Dao) pingMC(c context.Context) (err error) {
+	conn := d.arcMc.Get(c)
+	err = conn.Set(&memcache.Item{Key: "ping", Object: []byte{1}, Flags: memcache.FlagJSON, Expiration: 0})
+	conn.Close()
+	return
+}

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

@@ -0,0 +1,26 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_AddRelatesCache(t *testing.T) {
+	Convey("AddRelatesCache", t, func() {
+		d.AddRelatesCache(1, nil)
+	})
+}
+
+func Test_RelatesCache(t *testing.T) {
+	Convey("RelatesCache", t, func() {
+		d.RelatesCache(context.TODO(), 1)
+	})
+}
+
+func Test_ViewContributeCache(t *testing.T) {
+	Convey("ViewContributeCache", t, func() {
+		d.ViewContributeCache(context.TODO(), 2)
+	})
+}

app/interface/main/app-view/dao/archive/stat.go

@@ -0,0 +1,23 @@
+package archive
+
+import (
+	"context"
+
+	"go-common/app/service/main/archive/api"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/log"
+)
+
+// Stat get a archive stat.
+func (d *Dao) Stat(c context.Context, aid int64) (st *api.Stat, err error) {
+	if st, err = d.statCache(c, aid); err != nil {
+		log.Error("%+v", err)
+	} else if st != nil {
+		return
+	}
+	arg := &archive.ArgAid2{Aid: aid}
+	if st, err = d.arcRPC.Stat3(c, arg); err != nil {
+		log.Error("d.arcRPC.Stat3(%v) error(%v)", arg, err)
+	}
+	return
+}

app/interface/main/app-view/dao/archive/stat_test.go

@@ -0,0 +1,14 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_Stat(t *testing.T) {
+	Convey("Stat", t, func() {
+		d.Stat(context.TODO(), 2)
+	})
+}

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

@@ -0,0 +1,68 @@
+package archive
+
+import (
+	"context"
+
+	"go-common/app/service/main/archive/api"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+// View3 view archive with pages pb.
+func (d *Dao) View3(c context.Context, aid int64) (v *archive.View3, err error) {
+	arg := &archive.ArgAid2{Aid: aid}
+	if v, err = d.arcRPC.View3(c, arg); err != nil {
+		log.Error("d.arcRPC.View3(%v) error(%+v)", arg, err)
+		if ecode.Cause(err) == ecode.NothingFound {
+			err = nil
+			return
+		}
+	}
+	return
+}
+
+// ViewCache get view static data from cache if cache missed from rpc.
+func (d *Dao) ViewCache(c context.Context, aid int64) (vs *archive.View3, err error) {
+	if aid == 0 {
+		return
+	}
+	if vs, err = d.viewCache(c, aid); err != nil {
+		return
+	}
+	if vs != nil && vs.Archive3 != nil && len(vs.Pages) != 0 {
+		var st *api.Stat
+		if st, err = d.Stat(c, aid); err != nil {
+			log.Error("%+v", err)
+			err = nil
+			return
+		}
+		if st != nil {
+			vs.Archive3.Stat = archive.Stat3{
+				Aid:     st.Aid,
+				View:    st.View,
+				Danmaku: st.Danmaku,
+				Reply:   st.Reply,
+				Fav:     st.Fav,
+				Coin:    st.Coin,
+				Share:   st.Share,
+				NowRank: st.NowRank,
+				HisRank: st.HisRank,
+				Like:    st.Like,
+				DisLike: st.DisLike,
+			}
+		}
+	}
+	return
+}
+
+// Description get archive description by aid.
+func (d *Dao) Description(c context.Context, aid int64) (desc string, err error) {
+	arg := &archive.ArgAid{Aid: aid}
+	if desc, err = d.arcRPC.Description2(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

app/interface/main/app-view/dao/archive/view_test.go

@@ -0,0 +1,26 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_View3(t *testing.T) {
+	Convey("View3", t, func() {
+		d.View3(context.TODO(), 1)
+	})
+}
+
+func Test_ViewCache(t *testing.T) {
+	Convey("ViewCache", t, func() {
+		d.ViewCache(context.TODO(), 1)
+	})
+}
+
+func Test_Description(t *testing.T) {
+	Convey("Description", t, func() {
+		d.Description(context.TODO(), 2)
+	})
+}

app/interface/main/app-view/dao/assist/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"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/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-view/dao/assist",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/service/main/assist/model/assist:go_default_library",
+        "//app/service/main/assist/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-view/dao/assist/dao.go

@@ -0,0 +1,33 @@
+package assist
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/service/main/assist/model/assist"
+	assistrpc "go-common/app/service/main/assist/rpc/client"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is assist dao
+type Dao struct {
+	assistRPC *assistrpc.Service
+}
+
+// New initial assist dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		assistRPC: assistrpc.New(c.AssistRPC),
+	}
+	return
+}
+
+// Assist get assists data from api.
+func (d *Dao) Assist(c context.Context, upMid int64) (asss []int64, err error) {
+	arg := &assist.ArgAssists{Mid: upMid}
+	if asss, err = d.assistRPC.AssistIDs(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

app/interface/main/app-view/dao/assist/dao_test.go

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

app/interface/main/app-view/dao/audio/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 = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/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-view/dao/audio",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/view: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-view/dao/audio/dao.go

@@ -0,0 +1,56 @@
+package audio
+
+import (
+	"context"
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"net/url"
+
+	"go-common/app/interface/main/app-view/model/view"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	// _audioByCids = "/x/internal/v1/audio/songs/by_cids"
+	_audioByCids = "/audio/music-service-c/internal/songs-by-cids"
+)
+
+// Dao is archive dao.
+type Dao struct {
+	// http client
+	client         *bm.Client
+	audioByCidsURL string
+}
+
+// New new a archive dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		client:         bm.NewClient(c.HTTPAudio),
+		audioByCidsURL: c.Host.APICo + _audioByCids,
+	}
+	return
+}
+
+func (d *Dao) AudioByCids(c context.Context, cids []int64) (vam map[int64]*view.Audio, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("cids", xstr.JoinInts(cids))
+	var res struct {
+		Code int                   `json:"code"`
+		Data map[int64]*view.Audio `json:"data"`
+	}
+	if err = d.client.Get(c, d.audioByCidsURL, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.audioByCidsURL+"?"+params.Encode())
+		return
+	}
+	vam = res.Data
+	return
+}

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

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

app/interface/main/app-view/dao/bangumi/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-view/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-view/dao/bangumi",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/bangumi:go_default_library",
+        "//app/service/openplatform/pgc-season/api/grpc/season/v1: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-view/dao/bangumi/dao.go

@@ -0,0 +1,120 @@
+package bangumi
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/bangumi"
+	seasongrpc "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_pgc            = "/pgc/internal/season/appview"
+	_movie          = "/internal_api/movie_aid_info"
+	_seasonidAidURL = "/api/inner/archive/seasonid2aid"
+)
+
+// Dao is bangumi dao
+type Dao struct {
+	client         *httpx.Client
+	pgc            string
+	movie          string
+	seasonidAidURL string
+	// grpc
+	rpcClient seasongrpc.SeasonClient
+}
+
+// New bangumi dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:         httpx.NewClient(c.HTTPBangumi),
+		pgc:            c.Host.APICo + _pgc,
+		movie:          c.Host.Bangumi + _movie,
+		seasonidAidURL: c.Host.Bangumi + _seasonidAidURL,
+	}
+	var err error
+	if d.rpcClient, err = seasongrpc.NewClient(nil); err != nil {
+		panic(errors.WithMessage(err, "panic by seasongrpc"))
+	}
+	return
+}
+
+// PGC bangumi Season .
+func (d *Dao) PGC(c context.Context, aid, mid int64, build int, mobiApp, device string) (s *bangumi.Season, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("aid", 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.Season `json:"result"`
+	}
+	if err = d.client.Get(c, d.pgc, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.pgc+"?"+params.Encode())
+		return
+	}
+	s = res.Result
+	return
+}
+
+// Movie bangumi Movie
+func (d *Dao) Movie(c context.Context, aid, mid int64, build int, mobiApp, device string) (m *bangumi.Movie, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	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
+}
+
+// SeasonidAid moive_id by aid
+func (d *Dao) SeasonidAid(c context.Context, moiveID int64, now time.Time) (data map[int64]int64, err error) {
+	params := url.Values{}
+	params.Set("build", "app-api")
+	params.Set("platform", "Golang")
+	params.Set("season_id", strconv.FormatInt(moiveID, 10))
+	params.Set("season_type", "2")
+	var res struct {
+		Code   int             `json:"code"`
+		Result map[int64]int64 `json:"result"`
+	}
+	if err = d.client.Get(c, d.seasonidAidURL, "", params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.seasonidAidURL+"?"+params.Encode())
+		return
+	}
+	data = res.Result
+	return
+}

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

@@ -0,0 +1,53 @@
+package bangumi
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func TestMovie(t *testing.T) {
+	Convey("get Movie all", t, func() {
+		res, err := d.Movie(ctx(), 1, 1, 1, "iphone", "phone")
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestPGC(t *testing.T) {
+	Convey("get PGC all", t, func() {
+		res, err := d.PGC(ctx(), 1, 1, 1, "iphone", "phone")
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestSeasonidAid(t *testing.T) {
+	Convey("get SeasonidAid all", t, func() {
+		res, err := d.SeasonidAid(ctx(), 1, time.Now())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}

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

@@ -0,0 +1,21 @@
+package bangumi
+
+import (
+	"context"
+
+	seasongrpc "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1"
+
+	"github.com/pkg/errors"
+)
+
+// CardsInfoReply pgc cards info
+func (d *Dao) CardsInfoReply(c context.Context, seasonIds []int32) (res map[int32]*seasongrpc.CardInfoProto, err error) {
+	arg := &seasongrpc.SeasonInfoReq{SeasonIds: seasonIds}
+	info, err := d.rpcClient.Cards(c, arg)
+	if err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+		return
+	}
+	res = info.Cards
+	return
+}

app/interface/main/app-view/dao/coin/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-view/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-view/dao/coin",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/service/main/coin/api/gorpc:go_default_library",
+        "//app/service/main/coin/model: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-view/dao/coin/dao.go

@@ -0,0 +1,52 @@
+package coin
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-view/conf"
+	coinrpc "go-common/app/service/main/coin/api/gorpc"
+	"go-common/app/service/main/coin/model"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is coin dao
+type Dao struct {
+	coinRPC *coinrpc.Service
+}
+
+// New initial coin dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		coinRPC: coinrpc.New(c.CoinRPC),
+	}
+	return
+}
+
+// AddCoins add coin to upper.
+func (d *Dao) AddCoins(c context.Context, aid, mid, upID, maxCoin, avtype, multiply int64, typeID int16, pubTime int64) (err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &model.ArgAddCoin{Mid: mid, UpMid: upID, MaxCoin: maxCoin, Aid: aid, AvType: avtype, Multiply: multiply, RealIP: ip, TypeID: typeID, PubTime: pubTime}
+	return d.coinRPC.AddCoins(c, arg)
+}
+
+// ArchiveUserCoins .
+func (d *Dao) ArchiveUserCoins(c context.Context, aid, mid, avType int64) (res *model.ArchiveUserCoins, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &model.ArgCoinInfo{Mid: mid, Aid: aid, AvType: avType, RealIP: ip}
+	if res, err = d.coinRPC.ArchiveUserCoins(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+// UserCoins get user coins
+func (d *Dao) UserCoins(c context.Context, mid int64) (count float64, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &model.ArgCoinInfo{Mid: mid, RealIP: ip}
+	if count, err = d.coinRPC.UserCoins(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

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

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

app/interface/main/app-view/dao/creative/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 = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/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-view/dao/creative",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/creative: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-view/dao/creative/dao.go

@@ -0,0 +1,132 @@
+package creative
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/creative"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_special = "/x/internal/uper/special"
+	_follow  = "/x/internal/uper/switch"
+	_bgm     = "/x/internal/creative/archive/bgm"
+	_points  = "/x/internal/creative/video/viewpoints"
+)
+
+// Dao is space dao
+type Dao struct {
+	client  *httpx.Client
+	special string
+	follow  string
+	bgm     string
+	points  string
+}
+
+// New initial space dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:  httpx.NewClient(c.HTTPClient),
+		special: c.Host.APICo + _special,
+		follow:  c.Host.APICo + _follow,
+		bgm:     c.Host.APICo + _bgm,
+		points:  c.Host.APICo + _points,
+	}
+	return
+}
+
+// FollowSwitch get auto follow switch .
+func (d *Dao) FollowSwitch(c context.Context, vmid int64) (s *creative.FollowSwitch, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(vmid, 10))
+	params.Set("from", "0")
+	var res struct {
+		Code int                    `json:"code"`
+		Data *creative.FollowSwitch `json:"data"`
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	if err = d.client.Get(c, d.follow, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.follow+"?"+params.Encode())
+		return
+	}
+	s = res.Data
+	return
+}
+
+// Bgm get archive bgm
+func (d *Dao) Bgm(c context.Context, aid, cid int64) (bgm []*creative.Bgm, err error) {
+	params := url.Values{}
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	params.Set("cid", strconv.FormatInt(cid, 10))
+	var res struct {
+		Code int             `json:"code"`
+		Data []*creative.Bgm `json:"data"`
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	if err = d.client.Get(c, d.bgm, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.bgm+"?"+params.Encode())
+		return
+	}
+	bgm = res.Data
+	return
+}
+
+// Points get video points
+func (d *Dao) Points(c context.Context, aid, cid int64) (points []*creative.Points, err error) {
+	params := url.Values{}
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	params.Set("cid", strconv.FormatInt(cid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Points []*creative.Points `json:"points"`
+		} `json:"data"`
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	if err = d.client.Get(c, d.points, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.points+"?"+params.Encode())
+		return
+	}
+	points = res.Data.Points
+	return
+}
+
+// Special is
+func (d *Dao) Special(c context.Context) (midsM map[int64]struct{}, err error) {
+	params := url.Values{}
+	params.Set("group_id", "20")
+	var res struct {
+		Code int `json:"code"`
+		Data []struct {
+			Mid int64 `json:"mid"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.special, "", params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.special+"?"+params.Encode())
+		return
+	}
+	midsM = make(map[int64]struct{})
+	for _, l := range res.Data {
+		midsM[l.Mid] = struct{}{}
+	}
+	return
+}

app/interface/main/app-view/dao/creative/dao_test.go

@@ -0,0 +1,89 @@
+package creative
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-view/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-view")
+		flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
+		flag.Set("tree_id", "4575")
+		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 TestMovie(t *testing.T) {
+	var (
+		c    = context.TODO()
+		vmid = int64(0)
+	)
+	convey.Convey("Movie", t, func(ctx convey.C) {
+		_, err := d.FollowSwitch(c, vmid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			err = nil
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestBgm(t *testing.T) {
+	var (
+		c   = context.TODO()
+		aid = int64(10110995)
+		cid = int64(10135146)
+	)
+	convey.Convey("Bgm", t, func(ctx convey.C) {
+		_, err := d.Bgm(c, aid, cid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			err = nil
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestPoints(t *testing.T) {
+	var (
+		c   = context.TODO()
+		aid = int64(10110995)
+		cid = int64(10135146)
+	)
+	convey.Convey("Points", t, func(ctx convey.C) {
+		_, err := d.Points(c, aid, cid)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			err = nil
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestSpecial(t *testing.T) {
+	convey.Convey("Special", t, func(ctx convey.C) {
+		midsM, err := d.Special(context.Background())
+		ctx.So(err, convey.ShouldBeNil)
+		ctx.Println(midsM)
+	})
+}

app/interface/main/app-view/dao/dm/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-view/conf:go_default_library",
+        "//app/interface/main/dm2/model: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-view/dao/dm",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/dm2/model:go_default_library",
+        "//app/interface/main/dm2/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-view/dao/dm/dao.go

@@ -0,0 +1,30 @@
+package dm
+
+import (
+	"context"
+	"go-common/app/interface/main/app-view/conf"
+	dm "go-common/app/interface/main/dm2/model"
+	dmrpc "go-common/app/interface/main/dm2/rpc/client"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+type Dao struct {
+	dmRPC *dmrpc.Service
+}
+
+func New(c *conf.Config) (d *Dao) {
+	return &Dao{
+		dmRPC: dmrpc.New(c.DMRPC),
+	}
+}
+
+func (d *Dao) SubjectInfos(c context.Context, typ int32, plat int8, oids ...int64) (res map[int64]*dm.SubjectInfo, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &dm.ArgOids{Type: typ, Plat: plat, Oids: oids, RealIP: ip}
+	if res, err = d.dmRPC.SubjectInfos(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

app/interface/main/app-view/dao/dm/dao_test.go

@@ -0,0 +1,78 @@
+package dm
+
+import (
+	"context"
+	"flag"
+	"go-common/app/interface/main/app-view/conf"
+	dm "go-common/app/interface/main/dm2/model"
+	"path/filepath"
+	"reflect"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+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_SubjectInfos(t *testing.T) {
+	type args struct {
+		c    context.Context
+		typ  int32
+		plat int8
+		oids []int64
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantRes map[int64]*dm.SubjectInfo
+		wantErr error
+	}{
+		{
+			"normal",
+			args{
+				context.TODO(),
+				1,
+				1,
+				[]int64{12412},
+			},
+			map[int64]*dm.SubjectInfo{},
+			nil,
+		},
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotRes, err := d.SubjectInfos(tt.args.c, tt.args.typ, tt.args.plat, tt.args.oids...)
+			So(err, ShouldEqual, tt.wantErr)
+			So(gotRes, ShouldResemble, tt.wantRes)
+		})
+	}
+}

app/interface/main/app-view/dao/elec/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-view/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-view/dao/elec",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/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-view/dao/elec/dao.go

@@ -0,0 +1,85 @@
+package elec
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/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"
+	_elecTotal     = "/api/v2/rank/total/av/query"
+	_elecMonthRank = "1"
+)
+
+// Dao is elec dao.
+type Dao struct {
+	client    *httpx.Client
+	elec      string
+	elecTotal string
+}
+
+// New elec dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:    httpx.NewClient(c.HTTPClient),
+		elec:      c.Host.Elec + _elec,
+		elecTotal: c.Host.Elec + _elecTotal,
+	}
+	return
+}
+
+// TotalInfo mid+aid total elec info
+func (d *Dao) TotalInfo(c context.Context, mid int64, aid int64) (data *elec.Info, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("av_no", strconv.FormatInt(aid, 10))
+	var res struct {
+		Code int        `json:"code"`
+		Data *elec.Info `json:"data"`
+	}
+	if err = d.client.Get(c, d.elecTotal, "", params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.elecTotal+"?"+params.Encode())
+		return
+	}
+	data = res.Data
+	return
+}
+
+// Info elec info
+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))
+	if paymid > 0 {
+		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-view/dao/elec/dao_test.go

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

app/interface/main/app-view/dao/favorite/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 = [
+        "api_test.go",
+        "dao_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "dao.go",
+    ],
+    importpath = "go-common/app/interface/main/app-view/dao/favorite",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/service/main/favorite/api/gorpc:go_default_library",
+        "//app/service/main/favorite/model: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-view/dao/favorite/api.go

@@ -0,0 +1,77 @@
+package favorite
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/library/ecode"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// IsFavDefault faorite count
+func (d *Dao) IsFavDefault(c context.Context, mid, aid int64) (is bool, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Default bool `json:"default"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.isFavDef, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.isFavDef+"?"+params.Encode())
+		return
+	}
+	is = res.Data.Default
+	return
+}
+
+// IsFav is
+func (d *Dao) IsFav(c context.Context, mid, aid int64) (is bool, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Favorite bool `json:"favoured"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.isFav, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.isFav+"?"+params.Encode())
+		return
+	}
+	is = res.Data.Favorite
+	return
+}
+
+// AddFav add fav video
+func (d *Dao) AddFav(c context.Context, mid, aid int64) (err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.addFav, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.addFav+"?"+params.Encode())
+		return
+	}
+	return
+}

app/interface/main/app-view/dao/favorite/api_test.go

@@ -0,0 +1,47 @@
+package favorite
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestIsFavDefault(t *testing.T) {
+	convey.Convey("IsFavDefault", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.IsFavDefault(c, 1, 1)
+			ctx.Convey("Then err should be nil", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestIsFav(t *testing.T) {
+	convey.Convey("IsFav", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.IsFav(c, 1, 1)
+			ctx.Convey("Then err should be nil", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAddFav(t *testing.T) {
+	convey.Convey("AddFav", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.AddFav(c, 1, 1)
+		})
+	})
+}

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

@@ -0,0 +1,50 @@
+package favorite
+
+import (
+	"context"
+	"go-common/app/interface/main/app-view/conf"
+	favrpc "go-common/app/service/main/favorite/api/gorpc"
+	fav "go-common/app/service/main/favorite/model"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+const (
+	_isFavDef  = "/x/internal/v2/fav/video/default"
+	_isFav     = "/x/internal/v2/fav/video/favoured"
+	_addFav    = "/x/internal/v2/fav/video/add"
+	_typeVideo = 2
+)
+
+// Dao is favorite dao
+type Dao struct {
+	client   *httpx.Client
+	isFavDef string
+	isFav    string
+	addFav   string
+	favRPC   *favrpc.Service
+}
+
+// New initial favorite dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:   httpx.NewClient(c.HTTPClient),
+		isFavDef: c.Host.APICo + _isFavDef,
+		isFav:    c.Host.APICo + _isFav,
+		addFav:   c.Host.APICo + _addFav,
+		favRPC:   favrpc.New2(c.FavoriteRPC),
+	}
+	return
+}
+
+// AddVideo add favorite
+func (d *Dao) AddVideo(c context.Context, mid int64, fids []int64, aid int64, ak string) error {
+	ip := metadata.String(c, metadata.RemoteIP)
+	return d.favRPC.AddVideo(c, &fav.ArgAddVideo{Mid: mid, Fids: fids, Aid: aid, AccessKey: ak, RealIP: ip})
+}
+
+// AddVideo add favorite
+func (d *Dao) IsFavVideo(c context.Context, mid, aid int64) (faved bool, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	return d.favRPC.IsFav(c, &fav.ArgIsFav{Type: _typeVideo, Mid: mid, Oid: aid, RealIP: ip})
+}

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

@@ -0,0 +1,63 @@
+package favorite
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-view/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-view")
+		flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
+		flag.Set("tree_id", "4575")
+		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-view-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func TestAddVideo(t *testing.T) {
+	convey.Convey("AddVideo", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.AddVideo(c, 1, []int64{1}, 1, "")
+		})
+	})
+}
+
+func TestIsFavVideo(t *testing.T) {
+	convey.Convey("IsFavVideo", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			_, err := d.IsFavVideo(c, 1, 1)
+			ctx.Convey("Then err should be nil", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/interface/main/app-view/dao/game/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 = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/game: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-view/dao/game",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model:go_default_library",
+        "//app/interface/main/app-view/model/game: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-view/dao/game/dao.go

@@ -0,0 +1,76 @@
+package game
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model"
+	"go-common/app/interface/main/app-view/model/game"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_infoURL = "/game/info"
+)
+
+type Dao struct {
+	client  *httpx.Client
+	infoURL string
+	key     string
+	secret  string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:  httpx.NewClient(c.HTTPGame),
+		infoURL: c.Host.Game + _infoURL,
+		key:     c.HTTPGame.Key,
+		secret:  c.HTTPGame.Secret,
+	}
+	return
+}
+
+func (d *Dao) Info(c context.Context, gameID int64, plat int8) (info *game.Info, err error) {
+	var platType int
+	if model.IsAndroid(plat) {
+		platType = 1
+	} else if model.IsIOS(plat) {
+		platType = 2
+	}
+	if platType == 0 {
+		return
+	}
+	var req *http.Request
+	params := url.Values{}
+	params.Set("appkey", d.key)
+	params.Set("game_base_id", strconv.FormatInt(gameID, 10))
+	params.Set("platform_type", strconv.Itoa(platType))
+	params.Set("ts", strconv.FormatInt(time.Now().UnixNano()/1e6, 10))
+	mh := md5.Sum([]byte(params.Encode() + d.secret))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	if req, err = d.client.NewRequest("GET", d.infoURL, "", params); err != nil {
+		return
+	}
+	var res struct {
+		Code int        `json:"code"`
+		Data *game.Info `json:"data"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.infoURL+"?"+params.Encode())
+		return
+	}
+	info = res.Data
+	return
+}

app/interface/main/app-view/dao/game/dao_test.go

@@ -0,0 +1,68 @@
+package game
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/game"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-view-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_Info(t *testing.T) {
+	type args struct {
+		c      context.Context
+		gameID int64
+		plat   int8
+	}
+	tests := []struct {
+		name     string
+		args     args
+		wantInfo *game.Info
+		wantErr  bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotInfo, err := d.Info(tt.args.c, tt.args.gameID, tt.args.plat)
+			So(err, ShouldEqual, tt.wantErr)
+			So(gotInfo, ShouldResemble, tt.wantInfo)
+		})
+	}
+}

app/interface/main/app-view/dao/live/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-view/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-view/dao/live",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/live: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-view/dao/live/dao.go

@@ -0,0 +1,94 @@
+package live
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/live"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_list        = "/room/v1/RoomMng/allLivingRoomInfo"
+	_bnj2019Conf = "/activity/v0/bainian/config"
+)
+
+// Dao is space dao
+type Dao struct {
+	client  *httpx.Client
+	list    string
+	bnj2019 string
+}
+
+// New initial space dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:  httpx.NewClient(c.HTTPAsync),
+		list:    c.Host.APILiveCo + _list,
+		bnj2019: c.Host.APILiveCo + _bnj2019Conf,
+	}
+	return
+}
+
+// Living is get living rooms from api
+func (d *Dao) Living(c context.Context) (ll []*live.Live, err error) {
+	params := url.Values{}
+	params.Set("filter_user_cover", "0")
+	params.Set("need_broadcast_type", "1")
+	params.Set("extra_fields[]", "title")
+	var res struct {
+		Code int              `json:"code"`
+		Data []*live.RoomInfo `json:"data"`
+	}
+	if err = d.client.Get(c, d.list, "", params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.list)
+		return
+	}
+	for _, info := range res.Data {
+		l := &live.Live{}
+		l.LiveChange(info)
+		ll = append(ll, l)
+	}
+	return
+}
+
+// Bnj2019Conf 直播控制白名单
+func (d *Dao) Bnj2019Conf(c context.Context) (greyStatus int, mids []int64, err error) {
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			GreyStatus int    `json:"grey_status"`
+			GreyUids   string `json:"grey_uids"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.bnj2019, "", nil, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.bnj2019)
+		return
+	}
+	greyStatus = res.Data.GreyStatus
+	if greyStatus == 1 {
+		midsStr := strings.Split(res.Data.GreyUids, ",")
+		for _, midStr := range midsStr {
+			var mid int64
+			if mid, err = strconv.ParseInt(midStr, 10, 64); err != nil {
+				err = errors.New(fmt.Sprintf("live grey_uids(%s)", res.Data.GreyUids))
+				return
+			}
+			mids = append(mids, mid)
+		}
+	}
+	return
+}

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

@@ -0,0 +1,82 @@
+package live
+
+import (
+	"context"
+	"flag"
+	"os"
+	"strings"
+	"testing"
+
+	"go-common/app/interface/main/app-view/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+	"gopkg.in/h2non/gock.v1"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-view")
+		flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
+		flag.Set("tree_id", "4575")
+		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-view-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func httpMock(method, url string) *gock.Request {
+	r := gock.New(url)
+	r.Method = strings.ToUpper(method)
+	return r
+}
+
+func TestDaoLiving(t *testing.T) {
+	convey.Convey("TestDaoLiving", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.client.SetTransport(gock.DefaultTransport)
+			defer gock.Off()
+			httpMock("GET", d.list).Reply(200).JSON(`{"code":0,"data":[{"uid":"0","roomid":"1","title":"something","broadcast_type":1}]}`)
+			ll, err := d.Living(c)
+			ctx.Convey("Then ll should not be nil. err should be nil", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ll, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoBnj2019Conf(t *testing.T) {
+	convey.Convey("TestDaoBnj2019Conf", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.client.SetTransport(gock.DefaultTransport)
+			defer gock.Off()
+			httpMock("GET", d.bnj2019).Reply(200).JSON(`{"code":0,"data":{"grey_status":1,"grey_uids":"0,1"}}`)
+			_, mids, err := d.Bnj2019Conf(c)
+			ctx.Convey("Then mids should not be nil. err should be nil", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(mids, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/interface/main/app-view/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-view/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-view/dao/location",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-view/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-view/dao/location/dao.go

@@ -0,0 +1,48 @@
+package location
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/app-view/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) AuthPIDs(c context.Context, pids, ipaddr string) (res map[string]*locmdl.Auth, err error) {
+	var auths map[int64]*locmdl.Auth
+	if auths, err = d.locRPC.AuthPIDs(c, &locmdl.ArgPids{Pids: pids, IP: ipaddr}); err != nil {
+		log.Error("%v", err)
+		return
+	}
+	res = make(map[string]*locmdl.Auth)
+	for pid, auth := range auths {
+		p := strconv.FormatInt(pid, 10)
+		res[p] = auth
+	}
+	return
+}
+
+// Archive get auth by aid.
+func (d *Dao) Archive(c context.Context, aid, mid int64, ipaddr, cndip string) (auth *locmdl.Auth, err error) {
+	if auth, err = d.locRPC.Archive2(c, &locmdl.Archive{Aid: aid, Mid: mid, IP: ipaddr, CIP: cndip}); err != nil {
+		log.Error("%v", err)
+	}
+	return
+}

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

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

app/interface/main/app-view/dao/manager/BUILD

@@ -0,0 +1,45 @@
+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-view/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-view/dao/manager",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/manager:go_default_library",
+        "//library/database/sql: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-view/dao/manager/dao.go

@@ -0,0 +1,52 @@
+package region
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/manager"
+	xsql "go-common/library/database/sql"
+)
+
+const (
+	_relateSQL = "SELECT `id`,`param`,`goto`,`title`,`resource_ids`,`tag_ids`,`archive_ids`,`rec_reason`,`position`,`plat_ver`, `stime`,`etime` FROM app_rcmd_pos WHERE `state`=1"
+)
+
+type Dao struct {
+	db  *xsql.DB
+	get *xsql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: xsql.NewMySQL(c.MySQL.Show),
+	}
+	// prepare
+	d.get = d.db.Prepared(_relateSQL)
+	return
+}
+
+// Relate get all relate rec.
+func (d *Dao) Relate(c context.Context) (rs []*manager.Relate, err error) {
+	rows, err := d.get.Query(c)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := &manager.Relate{}
+		if err = rows.Scan(&r.ID, &r.Param, &r.Goto, &r.Title, &r.ResourceIDs, &r.TagIDs, &r.ArchiveIDs, &r.RecReason, &r.Position, &r.PlatVer, &r.STime, &r.ETime); err != nil {
+			return
+		}
+		r.Change()
+		rs = append(rs, r)
+	}
+	return
+}
+
+// Close close db resource.
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}

app/interface/main/app-view/dao/manager/dao_test.go

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

app/interface/main/app-view/dao/region/BUILD

@@ -0,0 +1,45 @@
+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-view/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-view/dao/region",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/region:go_default_library",
+        "//library/database/sql: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-view/dao/region/dao.go

@@ -0,0 +1,50 @@
+package region
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/region"
+	xsql "go-common/library/database/sql"
+)
+
+const (
+	// region
+	_secSQL = "SELECT rid,name,logo,rank,goto,param,plat,area FROM region_copy WHERE state=1 AND reid!=0"
+)
+
+type Dao struct {
+	db  *xsql.DB
+	get *xsql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: xsql.NewMySQL(c.MySQL.Show),
+	}
+	// prepare
+	d.get = d.db.Prepared(_secSQL)
+	return
+}
+
+// Seconds get all second region.
+func (d *Dao) Seconds(ctx context.Context) (rm map[int8]map[int]*region.Region, err error) {
+	rows, err := d.get.Query(ctx)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	rm = map[int8]map[int]*region.Region{}
+	for rows.Next() {
+		a := &region.Region{}
+		if err = rows.Scan(&a.Rid, &a.Name, &a.Logo, &a.Rank, &a.Goto, &a.Param, &a.Plat, &a.Area); err != nil {
+			return
+		}
+		if rs, ok := rm[a.Plat]; ok {
+			rs[a.Rid] = a
+		} else {
+			rm[a.Plat] = map[int]*region.Region{a.Rid: a}
+		}
+	}
+	return
+}

app/interface/main/app-view/dao/region/dao_test.go

@@ -0,0 +1,49 @@
+package region
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-view")
+		flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
+		flag.Set("tree_id", "4575")
+		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)
+	time.Sleep(time.Second)
+}
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func TestSeconds(t *testing.T) {
+	Convey("get Seconds all", t, func() {
+		res, err := d.Seconds(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}

app/interface/main/app-view/dao/relation/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"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/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-view/dao/relation",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/service/main/relation/model:go_default_library",
+        "//app/service/main/relation/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-view/dao/relation/dao.go

@@ -0,0 +1,48 @@
+package relation
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-view/conf"
+	relation "go-common/app/service/main/relation/model"
+	relrpc "go-common/app/service/main/relation/rpc/client"
+
+	"github.com/pkg/errors"
+)
+
+type Dao struct {
+	relationRPC *relrpc.Service
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		relationRPC: relrpc.New(c.RelationRPC),
+	}
+	return
+}
+
+// Prompt prompt
+func (d *Dao) Prompt(c context.Context, mid, vmid int64, btype int8) (prompt bool, err error) {
+	arg := &relation.ArgPrompt{Mid: mid, Fid: vmid, Btype: btype}
+	if prompt, err = d.relationRPC.Prompt(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+// Stat stat
+func (d *Dao) Stat(c context.Context, mid int64) (stat *relation.Stat, err error) {
+	if stat, err = d.relationRPC.Stat(c, &relation.ArgMid{Mid: mid}); err != nil {
+		err = errors.Wrapf(err, "%v", mid)
+	}
+	return
+}
+
+// Stats fids stats
+func (d *Dao) Stats(ctx context.Context, mids []int64) (res map[int64]*relation.Stat, err error) {
+	arg := &relation.ArgMids{Mids: mids}
+	if res, err = d.relationRPC.Stats(ctx, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

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

@@ -0,0 +1,41 @@
+package relation
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(5 * time.Second)
+}
+
+func TestPrompt(t *testing.T) {
+	Convey("Prompt", t, func() {
+		acc, err := d.Prompt(context.TODO(), 1, 1, 1)
+		So(err, ShouldBeNil)
+		Println(acc)
+	})
+}
+
+func TestStat(t *testing.T) {
+	Convey("Stat", t, func() {
+		acc, err := d.Stat(context.TODO(), 1)
+		So(err, ShouldBeNil)
+		Println(acc)
+	})
+}

app/interface/main/app-view/dao/report/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-view/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-view/dao/report",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/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-view/dao/report/dao.go

@@ -0,0 +1,120 @@
+package report
+
+import (
+	"context"
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/base64"
+	"fmt"
+	"hash"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_add      = "/videoup/archive/report"
+	_timeout  = 800 * time.Millisecond
+	_bucket   = "archive"
+	_url      = "http://bfs.bilibili.co/bfs/archive/"
+	_template = "%s\n%s\n\n%d\n"
+	_method   = "PUT"
+	_key      = "8d4e593ba7555502"
+	_secret   = "0bdbd4c7caeeddf587c3c4daec0475"
+)
+
+// Dao is report dao
+type Dao struct {
+	client    *httpx.Client
+	bfsClient *http.Client
+	add       string
+}
+
+// New is appeal inital func .
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:    httpx.NewClient(c.HTTPWrite),
+		bfsClient: http.DefaultClient,
+		add:       c.Host.Archive + _add,
+	}
+	return
+}
+
+// AddAppeal add appeal .
+func (d *Dao) AddReport(c context.Context, mid, aid int64, mold int, ak, reason, pics 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("aid", strconv.FormatInt(aid, 10))
+	params.Set("type", strconv.Itoa(mold))
+	params.Set("reason", reason)
+	params.Set("pics", pics)
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.add, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.add+"?"+params.Encode())
+	}
+	return
+}
+
+// Upload imgage upload .
+func (d *Dao) Upload(c context.Context, fileType string, body io.Reader) (location string, err error) {
+	req, err := http.NewRequest(_method, _url, body)
+	if err != nil {
+		return
+	}
+	expire := time.Now().Unix()
+	authorization := authorize(_key, _secret, _method, _bucket, expire)
+	req.Header.Set("Host", _url)
+	req.Header.Add("Date", fmt.Sprint(expire))
+	req.Header.Add("Authorization", authorization)
+	req.Header.Add("Content-Type", fileType)
+	// timeout
+	c, cancel := context.WithTimeout(c, _timeout)
+	req = req.WithContext(c)
+	defer cancel()
+	resp, err := d.bfsClient.Do(req)
+	if err != nil {
+		return
+	}
+	if resp.StatusCode != http.StatusOK {
+		err = errors.Wrap(ecode.Int(resp.StatusCode), req.URL.String())
+		return
+	}
+	code := resp.Header.Get("Code")
+	if code != strconv.Itoa(http.StatusOK) {
+		err = errors.Wrap(ecode.String(code), req.URL.String())
+		return
+	}
+	location = resp.Header.Get("Location")
+	return
+}
+
+// authorize returns authorization for upload file to bfs
+func authorize(key, secret, method, bucket string, expire int64) (authorization string) {
+	var (
+		content   string
+		mac       hash.Hash
+		signature string
+	)
+	content = fmt.Sprintf(_template, method, bucket, expire)
+	mac = hmac.New(sha1.New, []byte(secret))
+	mac.Write([]byte(content))
+	signature = base64.StdEncoding.EncodeToString(mac.Sum(nil))
+	authorization = fmt.Sprintf("%s:%s:%d", key, signature, expire)
+	return
+}

app/interface/main/app-view/dao/report/dao_test.go

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

app/interface/main/app-view/dao/resource/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-view/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-view/dao/resource",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/service/main/resource/model:go_default_library",
+        "//app/service/main/resource/rpc/client:go_default_library",
+        "//library/ecode: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-view/dao/resource/dao.go

@@ -0,0 +1,44 @@
+package resource
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/service/main/resource/model"
+	rscrpc "go-common/app/service/main/resource/rpc/client"
+	"go-common/library/ecode"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is archive dao.
+type Dao struct {
+	// rpc
+	rscRPC *rscrpc.Service
+}
+
+// New new a archive dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// rpc
+		rscRPC: rscrpc.New(c.ResourceRPC),
+	}
+	return
+}
+
+func (d *Dao) Paster(c context.Context, plat, adType int8, aid, typeID, buvid string) (res *model.Paster, err error) {
+	arg := &model.ArgPaster{Platform: plat, AdType: adType, Aid: aid, TypeId: typeID, Buvid: buvid}
+	if res, err = d.rscRPC.PasterAPP(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+func (d *Dao) PlayerIcon(c context.Context) (res *model.PlayerIcon, err error) {
+	if res, err = d.rscRPC.PlayerIcon(c); err != nil {
+		if ecode.Cause(err) == ecode.NothingFound {
+			res, err = nil, nil
+		}
+	}
+	return
+}

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

@@ -0,0 +1,37 @@
+package resource
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+
+	"go-common/app/interface/main/app-view/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-view-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+}
+
+func Test_Paster(t *testing.T) {
+	Convey("should get banner", t, func() {
+		_, err := d.Paster(context.Background(), 1, 2, "", "", "")
+		So(err, ShouldBeNil)
+	})
+}
+
+func Test_PlayerIcon(t *testing.T) {
+	Convey("should get player icon", t, func() {
+		_, err := d.PlayerIcon(context.Background())
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-view/dao/search/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 = ["search_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["search.go"],
+    importpath = "go-common/app/interface/main/app-view/dao/search",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/search: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-view/dao/search/search.go

@@ -0,0 +1,69 @@
+package search
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/search"
+	"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 (
+	_upper = "/main/recommend"
+)
+
+type Dao struct {
+	client *httpx.Client
+	upper  string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPSearch),
+		upper:  c.Host.Search + _upper,
+	}
+	return
+}
+
+func (d *Dao) Follow(c context.Context, platform, mobiApp, device, buvid string, build int, mid, vmid int64) (ups []*search.Upper, trackID string, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("platform", platform)
+	params.Set("mobi_app", mobiApp)
+	params.Set("device", device)
+	params.Set("clientip", ip)
+	params.Set("build", strconv.Itoa(build))
+	params.Set("buvid", buvid)
+	params.Set("userid", strconv.FormatInt(mid, 10))
+	params.Set("context_id", strconv.FormatInt(vmid, 10))
+	params.Set("rec_type", "up_rec")
+	params.Set("pagesize", "20")
+	params.Set("service_area", "play_suggest")
+	var res struct {
+		Code    int             `json:"code"`
+		TrackID string          `json:"trackid"`
+		Msg     string          `json:"msg"`
+		Data    []*search.Upper `json:"data"`
+	}
+	if err = d.client.Get(c, d.upper, ip, params, &res); err != nil {
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("search list url(%s) response(%s)", d.upper+"?"+params.Encode(), b)
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrap(code, d.upper+"?"+params.Encode())
+		return
+	}
+	ups = res.Data
+	trackID = res.TrackID
+	return
+}

app/interface/main/app-view/dao/search/search_test.go

@@ -0,0 +1,49 @@
+package search
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-view")
+		flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
+		flag.Set("tree_id", "4575")
+		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)
+	time.Sleep(time.Second)
+}
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func TestFollow(t *testing.T) {
+	Convey("get Follow all", t, func() {
+		_, _, err := d.Follow(ctx(), "ios", "iphone", "phone", "11", 1, 1, 1)
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-view/dao/special/BUILD

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

@@ -0,0 +1,51 @@
+package special
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/special"
+	"go-common/library/database/sql"
+)
+
+const (
+	_getSQL = "SELECT `id`,`title`,`desc`,`cover`,`re_type`,`re_value`,`corner` FROM special_card"
+)
+
+type Dao struct {
+	db         *sql.DB
+	specialGet *sql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Manager),
+	}
+	// prepare
+	d.specialGet = d.db.Prepared(_getSQL)
+	return
+}
+
+func (d *Dao) Card(c context.Context) (scm map[int64]*special.Card, err error) {
+	rows, err := d.specialGet.Query(c)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	scm = map[int64]*special.Card{}
+	for rows.Next() {
+		sc := &special.Card{}
+		if err = rows.Scan(&sc.ID, &sc.Title, &sc.Desc, &sc.Cover, &sc.ReType, &sc.ReValue, &sc.Badge); err != nil {
+			return
+		}
+		scm[sc.ID] = sc
+	}
+	return scm, err
+}
+
+// Close close memcache resource.
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}

app/interface/main/app-view/dao/special/special_test.go

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

app/interface/main/app-view/dao/tag/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-view/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-view/dao/tag",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/tag:go_default_library",
+        "//app/interface/main/tag/model:go_default_library",
+        "//app/interface/main/tag/rpc/client: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-view/dao/tag/dao.go

@@ -0,0 +1,43 @@
+package tag
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-view/conf"
+	tagmdl "go-common/app/interface/main/app-view/model/tag"
+	tag "go-common/app/interface/main/tag/model"
+	tagrpc "go-common/app/interface/main/tag/rpc/client"
+	"go-common/library/net/metadata"
+)
+
+// Dao is tag dao
+type Dao struct {
+	tagRPC *tagrpc.Service
+}
+
+// New initial tag dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		tagRPC: tagrpc.New2(c.TagRPC),
+	}
+	return
+}
+
+// ArcTags get tags data from api.
+func (d *Dao) ArcTags(c context.Context, aid, mid int64) (tags []*tagmdl.Tag, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &tag.ArgAid{Aid: aid, Mid: mid, RealIP: ip}
+	res, err := d.tagRPC.ArcTags(c, arg)
+	if err != nil {
+		return
+	}
+	if len(res) == 0 {
+		return
+	}
+	tags = make([]*tagmdl.Tag, 0, len(res))
+	for _, t := range res {
+		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}
+		tags = append(tags, tag)
+	}
+	return
+}

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

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

app/interface/main/app-view/dao/thumbup/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"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/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-view/dao/thumbup",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/service/main/thumbup/api: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-view/dao/thumbup/dao.go

@@ -0,0 +1,48 @@
+package thumbup
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/app-view/conf"
+	thumbup "go-common/app/service/main/thumbup/api"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is tag dao
+type Dao struct {
+	thumbupGRPC thumbup.ThumbupClient
+}
+
+// New initial tag dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{}
+	var err error
+	d.thumbupGRPC, err = thumbup.NewClient(c.ThumbupClient)
+	if err != nil {
+		panic(fmt.Sprintf("thumbup NewClient error(%v)", err))
+	}
+	return
+}
+
+// Like is like view.
+func (d *Dao) Like(c context.Context, mid, upMid int64, business string, messageID int64, typ int8) (res *thumbup.LikeReply, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &thumbup.LikeReq{Mid: mid, UpMid: upMid, Business: business, MessageID: messageID, Action: thumbup.Action(typ), IP: ip}
+	if res, err = d.thumbupGRPC.Like(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}
+
+// HasLike user has like
+func (d *Dao) HasLike(c context.Context, mid int64, business string, messageIDs []int64) (res *thumbup.HasLikeReply, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &thumbup.HasLikeReq{Mid: mid, Business: business, MessageIds: messageIDs, IP: ip}
+	if res, err = d.thumbupGRPC.HasLike(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

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

@@ -0,0 +1,53 @@
+package thumbup
+
+import (
+	"context"
+	"flag"
+	"go-common/app/interface/main/app-view/conf"
+	"os"
+	"testing"
+
+	. "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-view")
+		flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
+		flag.Set("tree_id", "4575")
+		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-view-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func TestLike(t *testing.T) {
+	Convey("TestLike", t, func(ctx C) {
+		_, err := d.Like(context.Background(), 27833317, 96070394, "archive", 33552993, 1)
+		err = nil
+		ctx.So(err, ShouldBeNil)
+	})
+}
+
+func TestHasLike(t *testing.T) {
+	Convey("TestHasLike", t, func(ctx C) {
+		_, err := d.HasLike(context.Background(), 27833317, "", []int64{33552993})
+		err = nil
+		ctx.So(err, ShouldBeNil)
+	})
+}

app/interface/main/app-view/dao/ugcpay/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 = ["ugcpay_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/view:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["ugcpay.go"],
+    importpath = "go-common/app/interface/main/app-view/dao/ugcpay",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-view/conf:go_default_library",
+        "//app/interface/main/app-view/model/view:go_default_library",
+        "//app/service/main/ugcpay/api/grpc/v1: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-view/dao/ugcpay/ugcpay.go

@@ -0,0 +1,54 @@
+package ugcpay
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/view"
+	ugcpayrpc "go-common/app/service/main/ugcpay/api/grpc/v1"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is ugcpay dao
+type Dao struct {
+	// grpc
+	ugcpayRPC ugcpayrpc.UGCPayClient
+}
+
+// New ugcpay dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{}
+	var err error
+	d.ugcpayRPC, err = ugcpayrpc.NewClient(nil)
+	if err != nil {
+		panic(fmt.Sprintf("ugcpay NewClient error(%v)", err))
+	}
+	return
+}
+
+// AssetRelationDetail ugcpay
+func (d *Dao) AssetRelationDetail(c context.Context, mid, aid int64, platform string) (res *view.Asset, err error) {
+	var (
+		arg   = &ugcpayrpc.AssetRelationDetailReq{Mid: mid, Oid: aid, Otype: "archive", Currency: "bp"}
+		asset *ugcpayrpc.AssetRelationDetailResp
+	)
+	if asset, err = d.ugcpayRPC.AssetRelationDetail(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+		return
+	}
+	res = &view.Asset{}
+	switch asset.RelationState {
+	case "paid":
+		res.Paid = 1
+	}
+	if price, ok := asset.AssetPlatformPrice[platform]; ok {
+		res.Price = price
+	} else {
+		res.Price = asset.AssetPrice
+	}
+	res.Msg.Desc1 = "本视频为付费内容，支付" + fmt.Sprintf("%0.2f", float64(res.Price)/100) + "币即可观看"
+	res.Msg.Desc2 = "用一点点奖励来支持UP主们创作吧"
+	return
+}

app/interface/main/app-view/dao/ugcpay/ugcpay_test.go

@@ -0,0 +1,52 @@
+package ugcpay
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/app/interface/main/app-view/model/view"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	dao *Dao
+)
+
+func init() {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-view")
+		flag.Set("conf_token", "3a4CNLBhdFbRQPs7B4QftGvXHtJo92xw")
+		flag.Set("tree_id", "4575")
+		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)
+	}
+	dao = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestAssetRelationDetail(t *testing.T) {
+	Convey("get AssetRelationDetail", t, func() {
+		res, err := dao.AssetRelationDetail(ctx(), 1, 1, "ios")
+		err = nil
+		res = &view.Asset{}
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func ctx() context.Context {
+	return context.Background()
+}

app/interface/main/app-view/dao/vip/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"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/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-view/dao/vip",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-view/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-view/dao/vip/dao.go

@@ -0,0 +1,52 @@
+package vip
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-view/conf"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_vipActive = "/internal/v1/notice/active"
+)
+
+// Dao is vip dao.
+type Dao struct {
+	client       *httpx.Client
+	vipActiveURL string
+}
+
+// New vip dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPWrite),
+		// api
+		vipActiveURL: c.Host.VIP + _vipActive,
+	}
+	return
+}
+
+// VIPActive get vip active info.
+func (d *Dao) VIPActive(c context.Context, subID int) (msg string, err error) {
+	params := url.Values{}
+	params.Set("subId", strconv.Itoa(subID))
+	var res struct {
+		Code int    `json:"code"`
+		Data string `json:"data"`
+	}
+	if err = d.client.Get(c, d.vipActiveURL, "", params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.vipActiveURL+"?"+params.Encode())
+		return
+	}
+	msg = res.Data
+	return
+}

app/interface/main/app-view/dao/vip/dao_test.go

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