Initial commit

app/interface/main/app-feed/BUILD

@@ -0,0 +1,24 @@
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/interface/main/app-feed/cmd:all-srcs",
+        "//app/interface/main/app-feed/conf:all-srcs",
+        "//app/interface/main/app-feed/dao:all-srcs",
+        "//app/interface/main/app-feed/http:all-srcs",
+        "//app/interface/main/app-feed/model:all-srcs",
+        "//app/interface/main/app-feed/service/external:all-srcs",
+        "//app/interface/main/app-feed/service/feed:all-srcs",
+        "//app/interface/main/app-feed/service/ping:all-srcs",
+        "//app/interface/main/app-feed/service/region:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/app-feed/CONTRIBUTORS.md

@@ -0,0 +1,9 @@
+# Owner
+peiyifei
+liweijia
+
+# Author 
+zhangxin
+
+# Reviewer
+haoguanwei

app/interface/main/app-feed/OWNERS

@@ -0,0 +1,15 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- liweijia
+- peiyifei
+- zhangxin
+labels:
+- interface
+- interface/main/app-feed
+- main
+options:
+  no_parent_owners: true
+reviewers:
+- haoguanwei
+- zhangxin

app/interface/main/app-feed/README.md

@@ -0,0 +1,3 @@
+# go-common/app/service
+
+提供APP端首页、动态服务

app/interface/main/app-feed/cmd/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "cmd",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    data = ["app-feed-test.toml"],
+    importpath = "go-common/app/interface/main/app-feed/cmd",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//app/interface/main/app-feed/http:go_default_library",
+        "//library/ecode/tip:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/trace: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-feed/cmd/app-feed-test.toml

@@ -0,0 +1,367 @@
+# This is a TOML document. Boom.
+env     = "uat"
+tick    = "1m"
+
+[feed]
+feedCacheCount = 200
+liveFeedCount = 7
+# index
+[feed.index]
+    count = 10
+    iPadCount = 20
+    moePosition = 6
+    followPosition = 7
+    abnormal = false
+    interest = ["生活","游戏","影视","娱乐","二次元","音乐","科技","时尚","鬼畜","舞蹈"]
+[feed.cmResource]
+    "iphone"  = 1890
+    "android" = 1897
+    "ipad"    = 1975
+[feed.followMode]
+    title = "当前为首页推荐 - 关注模式（内测版）"
+    option = [
+        {title="通用模式",desc="开启后，推荐你可能感兴趣的内容",value=0},
+        {title="关注模式（内测版）",desc="开启后，仅显示关注UP主更新的视频",value=1}
+    ]
+[feed.followMode.card]
+    title = "启用首页推荐 - 关注模式（内测版）"
+    desc = "我们根据你对bilibili推荐的反馈，为你定制了关注模式。开启后，仅为你显示关注UP主更新的视频哦。尝试体验一下？"
+    button = ["暂不需要","立即开启"]
+
+[showInfoc]
+project = "app-feed"
+name = "show"
+proto = "tcp"
+addr = "172.18.21.101:5403"
+chanSize = 10240
+
+[tagInfoc]
+project = "app-feed"
+name = "tag"
+proto = "tcp"
+addr = "172.18.21.101:5403"
+chanSize = 10240
+
+[redirectInfoc]
+project = "app-feed"
+name = "redirect"
+proto = "tcp"
+addr = "172.18.21.101:5403"
+chanSize = 10240
+
+[showInfoc2]
+taskID = "000027"
+proto = "tcp"
+addr = "172.19.100.20:5401"
+chanSize = 10240
+
+[tagInfoc2]
+taskID = "000028"
+proto = "tcp"
+addr = "172.19.100.20:5401"
+chanSize = 10240
+
+[redirectInfoc2]
+taskID = "000029"
+proto = "tcp"
+addr = "172.19.100.20:5401"
+chanSize = 10240
+
+[host]
+live     = "http://live.bilibili.co"
+liveApi  = "http://api.live.bilibili.co"
+bangumi  = "http://bangumi.bilibili.co"
+data     = "http://data.bilibili.co"
+hetongzi = "http://hetongzi.bilibili.co"
+www      = "http://www.bilibili.com"
+apiCo    = "http://api.bilibili.co"
+api      = "http://api.bilibili.com"
+ad       = "http://cm.bilibili.co"
+activity = "http://matsuri.bilibili.co"
+rank     = ""
+show     = "http://show.bilibili.com"
+dynamic  = "http://api.vc.bilibili.com"
+dynamicCo  = "http://api.vc.bilibili.co"
+bigData  = "http://bigdata.bilibili.co"
+search   = "http://s.search.bilibili.co"
+
+[xlog]
+dir = "/data/log/app-feed"
+
+[app]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+
+[httpClient]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "30ms"
+timeout   = "100ms"
+keepAlive = "60s"
+timer     = 128
+[httpClient.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[httpClientAsyn]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "1s"
+timeout   = "2s"
+keepAlive = "60s"
+timer     = 10
+[httpClientAsyn.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[httpData]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "30ms"
+timeout   = "200ms"
+keepAlive = "60s"
+timer     = 1024
+[httpData.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[httpTag]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "50ms"
+timeout   = "200ms"
+keepAlive = "60s"
+timer = 10
+    [httpTag.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[httpAd]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "50ms"
+timeout   = "100ms"
+keepAlive = "60s"
+timer = 128
+[httpAd.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[httpActivity]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "50ms"
+timeout   = "150ms"
+keepAlive = "60s"
+timer = 128
+[httpActivity.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[httpBangumi]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "50ms"
+timeout   = "150ms"
+keepAlive = "60s"
+timer = 128
+[httpBangumi.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[httpDynamic]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "200ms"
+timeout   = "800ms"
+keepAlive = "60s"
+timer = 128
+[httpDynamic.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[httpShow]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "50ms"
+timeout   = "150ms"
+keepAlive = "60s"
+timer = 128
+[httpShow.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[httpSearch]
+key    = "e7482d29be4a95b8"
+secret = "9e803791cdef756e75faee68e12b7442"
+dial      = "50ms"
+timeout   = "150ms"
+keepAlive = "60s"
+timer = 128
+[httpSearch.breaker]
+    window  = "10s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+
+[bm]
+    [bm.outer]
+    addr = "0.0.0.0:6221"
+    timeout = "1s"
+
+[mysql]
+    [mysql.show]
+    addr   = "172.18.33.49:3306"
+    dsn    = "show:UJYgc9UkHIaGovEDUXpTU4U0rjBpZtwb@tcp(172.18.33.49:3306)/bilibili_show?timeout=1s&readTimeout=1s&writeTimeout=1s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+    active = 2
+    idle   = 1
+    queryTimeout = "1s"
+    execTimeout = "1s"
+    tranTimeout = "1s"
+    [mysql.show.Breaker]
+    window = "1s"
+    sleep = "1s"
+    bucket = 10
+    ratio = 0.5
+    request = 100
+    [mysql.resource]
+    addr = "172.18.33.49:3306"
+    dsn = "resource:nMgVkY0JPgQr60nUVif5tEUbOTXlilXN@tcp(172.18.33.49:3306)/bilibili_resource?timeout=100ms&readTimeout=200ms&writeTimeout=200ms&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+    active = 2
+    idle = 1
+    queryTimeout = "1s"
+    execTimeout = "1s"
+    tranTimeout = "1s"
+    [mysql.resource.Breaker]
+    window = "1s"
+    sleep = "1s"
+    bucket = 10
+    ratio = 0.5
+    request = 100
+    [mysql.manager]
+    addr = "172.16.33.205:3308"
+    dsn = "test:test@tcp(172.16.33.205:3308)/bilibili_manager?timeout=100ms&readTimeout=200ms&writeTimeout=200ms&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+    active = 2
+    idle = 1
+    queryTimeout = "1s"
+    execTimeout = "1s"
+    tranTimeout = "1s"
+    [mysql.manager.Breaker]
+    window = "1s"
+    sleep = "1s"
+    bucket = 10
+    ratio = 0.5
+    request = 100
+
+[redis]
+    [redis.feed]
+    name   = "app-feed/feed"
+    proto  = "unix"
+    addr   = "/tmp/uat-app-redis.sock"
+    active = 5
+    idle   = 1
+    dialTimeout  = "30ms"
+    readTimeout  = "80ms"
+    writeTimeout = "80ms"
+    idleTimeout  = "80s"
+    expireRecommend = "1h"
+    expireBlack = "16h"
+    [redis.upper]
+    name   = "app-feed/upper"
+    proto  = "unix"
+    addr   = "/tmp/uat-app-redis.sock"
+    active = 5
+    idle   = 1
+    dialTimeout  = "30ms"
+    readTimeout  = "50ms"
+    writeTimeout = "50ms"
+    idleTimeout  = "80s"
+    expireUpper  = "96h"
+
+[memcache]
+    [memcache.feed]
+    name   = "app-feed/feed"
+    proto  = "unix"
+    addr   = "/tmp/uat-app-mc.sock"
+    active = 5
+    idle   = 1
+    dialTimeout  = "30ms"
+    readTimeout  = "150ms"
+    writeTimeout = "150ms"
+    idleTimeout  = "80s"
+    expireArchive = "24h"
+    expireCache = "480h"
+    [memcache.cache]
+    name   = "app-feed/cache"
+    proto  = "unix"
+    addr   = "/tmp/uat-app-mc.sock"
+    active = 5
+    idle   = 1
+    dialTimeout  = "30ms"
+    readTimeout  = "150ms"
+    writeTimeout = "150ms"
+    idleTimeout  = "80s"
+    expireCache  = "24h"
+
+[dislikeDatabus]
+key = "0QNB0ZgFozbKUCQhbTq8"
+secret = "0QNB0ZgFozbKUCQhbTq9"
+group= "TagDislike-SkyHorse-P"
+topic= "Dislike-T"
+action="pub"
+name = "app-feed/dislike"
+proto = "tcp"
+addr = "172.18.33.50:6205"
+active = 5
+idle = 1
+dialTimeout = "30ms"
+readTimeout = "80ms"
+writeTimeout = "80ms"
+idleTimeout = "80s"
+expire = "1h"
+
+
+[bnj]
+tabImg = "http://i1.hdslb.com/bfs/archive/e51ec36d654559de9d2d197f4d77ee60302fa754.png"
+tabID = 10
+
+[hbase]
+master = ""
+meta = ""
+dialTimeout = "100ms"
+readTimeout = "100ms"
+readsTimeout = "200ms"
+writeTimeout = "200ms"
+writesTimeout = "200ms"
+    [hbase.zookeeper]
+    root = ""
+    addrs = ["172.18.33.131:2181", "172.18.33.168:2181", "172.18.33.169:2181"]
+    timeout = "30s"

app/interface/main/app-feed/cmd/main.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"flag"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/app/interface/main/app-feed/http"
+	ecode "go-common/library/ecode/tip"
+	"go-common/library/log"
+	"go-common/library/net/trace"
+)
+
+func main() {
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		log.Error("conf.Init() error(%v)", err)
+		panic(err)
+	}
+	// init log
+	log.Init(conf.Conf.XLog)
+	defer log.Close()
+	log.Info("app-feed start")
+	// init trace
+	trace.Init(conf.Conf.Tracer)
+	defer trace.Close()
+	// ecode init
+	ecode.Init(conf.Conf.Ecode)
+	// service init
+	http.Init(conf.Conf)
+	// init pprof conf.Conf.Perf
+	// init signal
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
+	for {
+		s := <-c
+		log.Info("app-feed get a signal %s", s.String())
+		switch s {
+		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGSTOP, syscall.SIGINT:
+			log.Info("app-feed exit")
+			return
+		case syscall.SIGHUP:
+		// TODO reload
+		default:
+			return
+		}
+	}
+}

app/interface/main/app-feed/conf/BUILD

@@ -0,0 +1,44 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["conf.go"],
+    importpath = "go-common/app/interface/main/app-feed/conf",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/model/feed:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/conf:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode/tip:go_default_library",
+        "//library/log:go_default_library",
+        "//library/log/infoc:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "//library/net/trace:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/BurntSushi/toml: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-feed/conf/conf.go

@@ -0,0 +1,225 @@
+package conf
+
+import (
+	"errors"
+	"flag"
+
+	"go-common/app/interface/main/app-feed/model/feed"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	"go-common/library/conf"
+	"go-common/library/database/sql"
+	ecode "go-common/library/ecode/tip"
+	"go-common/library/log"
+	"go-common/library/log/infoc"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/rpc"
+	"go-common/library/net/rpc/warden"
+	"go-common/library/net/trace"
+	"go-common/library/queue/databus"
+	xtime "go-common/library/time"
+
+	"github.com/BurntSushi/toml"
+)
+
+var (
+	confPath string
+	Conf     = &Config{}
+	client   *conf.Client
+)
+
+type Config struct {
+	// env
+	Env string
+	// infoc log2
+	ShowInfoc2     *infoc.Config
+	TagInfoc2      *infoc.Config
+	RedirectInfoc2 *infoc.Config
+	// show  XLog
+	XLog *log.Config
+	// tick time
+	Tick xtime.Duration
+	// tracer
+	Tracer *trace.Config
+	// httpClinet
+	HTTPClient *bm.ClientConfig
+	// httpAsyn
+	HTTPClientAsyn *bm.ClientConfig
+	// httpData
+	HTTPData *bm.ClientConfig
+	// httpTag
+	HTTPTag *bm.ClientConfig
+	// httpAd
+	HTTPAd *bm.ClientConfig
+	// httpActivity
+	HTTPActivity *bm.ClientConfig
+	// httpBangumi
+	HTTPBangumi *bm.ClientConfig
+	// httpShow
+	HTTPShow *bm.ClientConfig
+	// httpDynamic
+	HTTPDynamic *bm.ClientConfig
+	// httpClinet
+	HTTPSearch *bm.ClientConfig
+	// rpc Location
+	LocationRPC *rpc.ClientConfig
+	// http
+	BM *HTTPServers
+	// host
+	Host *Host
+	// db
+	MySQL *MySQL
+	// redis
+	Redis *Redis
+	// mc
+	Memcache *Memcache
+	// rpc client
+	AccountRPC  *rpc.ClientConfig
+	RelationRPC *rpc.ClientConfig
+	ArchiveRPC  *rpc.ClientConfig
+	FeedRPC     *rpc.ClientConfig
+	TagRPC      *rpc.ClientConfig
+	ArticleRPC  *rpc.ClientConfig
+	ResourceRPC *rpc.ClientConfig
+	// databus
+	DislikeDatabus *databus.Config
+	// ecode
+	Ecode *ecode.Config
+	// feed
+	Feed *Feed
+	// bnj2018
+	Bnj *BnjConfig
+	// BroadcastRPC grpc
+	PGCRPC *warden.ClientConfig
+	// autoplay mids
+	AutoPlayMids []int64
+}
+
+// HTTPServers Http Servers
+type HTTPServers struct {
+	Outer *bm.ServerConfig
+}
+
+// BnjConfig 2018拜年祭配置
+type BnjConfig struct {
+	TabImg    string
+	TabID     int64
+	BeginTime string
+}
+
+type Host struct {
+	LiveAPI   string
+	Bangumi   string
+	Data      string
+	Hetongzi  string
+	APICo     string
+	Ad        string
+	Activity  string
+	Rank      string
+	Show      string
+	Dynamic   string
+	DynamicCo string
+	BigData   string
+	Search    string
+}
+
+type MySQL struct {
+	Show    *sql.Config
+	Manager *sql.Config
+}
+
+type Redis struct {
+	Feed *struct {
+		*redis.Config
+		ExpireRecommend xtime.Duration
+		ExpireBlack     xtime.Duration
+	}
+	Upper *struct {
+		*redis.Config
+		ExpireUpper xtime.Duration
+	}
+}
+
+type Memcache struct {
+	Feed *struct {
+		*memcache.Config
+		ExpireArchive xtime.Duration
+	}
+	Cache *struct {
+		*memcache.Config
+		ExpireCache xtime.Duration
+	}
+}
+
+type Feed struct {
+	// feed
+	FeedCacheCount int
+	LiveFeedCount  int
+	// index
+	Index *Index
+	// ad
+	CMResource map[string]int64
+}
+
+type Index struct {
+	Count          int
+	IPadCount      int
+	MoePosition    int
+	FollowPosition int
+	// only archive for data disaster recovery
+	Abnormal   bool
+	Interest   []string
+	FollowMode *feed.FollowMode
+}
+
+func init() {
+	flag.StringVar(&confPath, "conf", "", "default config path")
+}
+
+// Init init conf
+func Init() error {
+	if confPath != "" {
+		return local()
+	}
+	return remote()
+}
+
+func local() (err error) {
+	_, err = toml.DecodeFile(confPath, &Conf)
+	return
+}
+
+func remote() (err error) {
+	if client, err = conf.New(); err != nil {
+		return
+	}
+	if err = load(); err != nil {
+		return
+	}
+	client.Watch("app-feed.toml")
+	go func() {
+		for range client.Event() {
+			log.Info("config reload")
+			if load() != nil {
+				log.Error("config reload error (%v)", err)
+			}
+		}
+	}()
+	return
+}
+
+func load() (err error) {
+	var (
+		s       string
+		ok      bool
+		tmpConf *Config
+	)
+	if s, ok = client.Toml2(); !ok {
+		return errors.New("load config center error")
+	}
+	if _, err = toml.Decode(s, &tmpConf); err != nil {
+		return errors.New("could not decode config")
+	}
+	*Conf = *tmpConf
+	return
+}

app/interface/main/app-feed/dao/BUILD

@@ -0,0 +1,41 @@
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/interface/main/app-feed/dao/account:all-srcs",
+        "//app/interface/main/app-feed/dao/activity:all-srcs",
+        "//app/interface/main/app-feed/dao/ad:all-srcs",
+        "//app/interface/main/app-feed/dao/archive:all-srcs",
+        "//app/interface/main/app-feed/dao/article:all-srcs",
+        "//app/interface/main/app-feed/dao/audio:all-srcs",
+        "//app/interface/main/app-feed/dao/audit:all-srcs",
+        "//app/interface/main/app-feed/dao/bangumi:all-srcs",
+        "//app/interface/main/app-feed/dao/black:all-srcs",
+        "//app/interface/main/app-feed/dao/bplus:all-srcs",
+        "//app/interface/main/app-feed/dao/card:all-srcs",
+        "//app/interface/main/app-feed/dao/converge:all-srcs",
+        "//app/interface/main/app-feed/dao/dynamic:all-srcs",
+        "//app/interface/main/app-feed/dao/game:all-srcs",
+        "//app/interface/main/app-feed/dao/live:all-srcs",
+        "//app/interface/main/app-feed/dao/location:all-srcs",
+        "//app/interface/main/app-feed/dao/rank:all-srcs",
+        "//app/interface/main/app-feed/dao/recommend:all-srcs",
+        "//app/interface/main/app-feed/dao/relation:all-srcs",
+        "//app/interface/main/app-feed/dao/resource:all-srcs",
+        "//app/interface/main/app-feed/dao/search:all-srcs",
+        "//app/interface/main/app-feed/dao/show:all-srcs",
+        "//app/interface/main/app-feed/dao/special:all-srcs",
+        "//app/interface/main/app-feed/dao/tab:all-srcs",
+        "//app/interface/main/app-feed/dao/tag:all-srcs",
+        "//app/interface/main/app-feed/dao/upper:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

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

@@ -0,0 +1,83 @@
+package account
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-feed/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 archive dao.
+type Dao struct {
+	// rpc
+	accRPC *accrpc.Service3
+}
+
+// New new a archive dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// rpc
+		accRPC: accrpc.New3(c.AccountRPC),
+	}
+	return
+}
+
+// Relations3 relations.
+func (d *Dao) Relations3(c context.Context, owners []int64, mid int64) (follows map[int64]bool) {
+	if len(owners) == 0 {
+		return nil
+	}
+	follows = make(map[int64]bool, len(owners))
+	for _, owner := range owners {
+		follows[owner] = false
+	}
+	var (
+		am  map[int64]*account.Relation
+		err error
+	)
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &account.ArgRelations{Owners: owners, Mid: mid, RealIP: ip}
+	if am, err = d.accRPC.Relations3(c, arg); err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	for i, a := range am {
+		if _, ok := follows[i]; ok {
+			follows[i] = a.Following
+		}
+	}
+	return
+}
+
+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
+}
+
+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
+}

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

@@ -0,0 +1,52 @@
+package account
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, func(t *testing.T) {
+			gotD := New(tt.args.c)
+			So(gotD, ShouldNotBeNil)
+		})
+	}
+}
+
+func TestDao_Relations2(t *testing.T) {
+	type args struct {
+		c      context.Context
+		owners []int64
+		mid    int64
+	}
+	tests := []struct {
+		name        string
+		d           *Dao
+		args        args
+		wantFollows map[int64]bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotFollows := tt.d.Relations3(tt.args.c, tt.args.owners, tt.args.mid); !reflect.DeepEqual(gotFollows, tt.wantFollows) {
+				t.Errorf("Dao.Relations2() = %v, want %v", gotFollows, tt.wantFollows)
+			}
+		})
+	}
+}

app/interface/main/app-feed/dao/activity/BUILD

@@ -0,0 +1,21 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_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-feed/dao/ad/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-feed/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-feed/dao/ad",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-card/model/card/cm:go_default_library",
+        "//app/interface/main/app-feed/conf: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-feed/dao/ad/dao.go

@@ -0,0 +1,80 @@
+package ad
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-card/model/card/cm"
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_bce = "/bce/api/bce/wise"
+)
+
+// Dao is ad dao.
+type Dao struct {
+	// http client
+	client *httpx.Client
+	// ad
+	bce string
+}
+
+// New new a ad dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		client: httpx.NewClient(c.HTTPAd),
+		bce:    c.Host.Ad + _bce,
+	}
+	return
+}
+
+func (d *Dao) Ad(c context.Context, mid int64, build int, buvid string, resource []int64, country, province, city, network, mobiApp, device, openEvent, adExtra string, style int, now time.Time) (advert *cm.Ad, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("buvid", buvid)
+	params.Set("resource", xstr.JoinInts(resource))
+	params.Set("ip", ip)
+	params.Set("country", country)
+	params.Set("province", province)
+	params.Set("city", city)
+	params.Set("network", network)
+	params.Set("build", strconv.Itoa(build))
+	params.Set("mobi_app", mobiApp)
+	params.Set("device", device)
+	params.Set("open_event", openEvent)
+	params.Set("ad_extra", adExtra)
+	// 老接口做兼容
+	if style != 0 {
+		if style != 2 {
+			style = 1
+		}
+		params.Set("style", strconv.Itoa(style))
+	}
+	var res struct {
+		Code int    `json:"code"`
+		Data *cm.Ad `json:"data"`
+	}
+	if err = d.client.Get(c, d.bce, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.bce+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		res.Data.ClientIP = ip
+	}
+	advert = res.Data
+	return
+}

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

@@ -0,0 +1,47 @@
+package ad
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-feed/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-feed")
+		flag.Set("conf_token", "OC30xxkAOyaH9fI6FRuXA0Ob5HL0f3kc")
+		flag.Set("tree_id", "2686")
+		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 TestAd(t *testing.T) {
+	Convey("TestAd", t, func(ctx C) {
+		gotAdvert, err := d.Ad(context.Background(), 121212, 0, "", []int64{1221}, "", "", "", "", "", "", "", "", 1, time.Now())
+		So(gotAdvert, ShouldNotBeNil)
+		So(err, ShouldBeNil)
+	})
+}

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

@@ -0,0 +1,57 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "dao_test.go",
+        "memcache_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "memcache.go",
+    ],
+    importpath = "go-common/app/interface/main/app-feed/dao/archive",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/archive/api/gorpc:go_default_library",
+        "//app/service/main/archive/model/archive:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

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

@@ -0,0 +1,119 @@
+package archive
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/app/service/main/archive/api"
+	arcrpc "go-common/app/service/main/archive/api/gorpc"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/sync/errgroup"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is archive dao.
+type Dao struct {
+	// rpc
+	arcRPC *arcrpc.Service2
+	// mc
+	mc       *memcache.Pool
+	expireMc int32
+}
+
+// New new a archive dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// rpc
+		arcRPC: arcrpc.New2(c.ArchiveRPC),
+		// mc
+		mc:       memcache.NewPool(c.Memcache.Feed.Config),
+		expireMc: int32(time.Duration(c.Memcache.Feed.ExpireArchive) / time.Second),
+	}
+	return
+}
+
+func (d *Dao) PingMC(c context.Context) (err error) {
+	conn := d.mc.Get(c)
+	item := &memcache.Item{Key: "ping", Value: []byte{1}, Flags: memcache.FlagRAW, Expiration: d.expireMc}
+	err = conn.Set(item)
+	conn.Close()
+	return
+}
+
+// Archives multi get archives.
+func (d *Dao) Archives(c context.Context, aids []int64) (am map[int64]*api.Arc, err error) {
+	if len(aids) == 0 {
+		return
+	}
+	g, ctx := errgroup.WithContext(c)
+	g.Go(func() (err error) {
+		var missed []int64
+		if am, missed, err = d.arcsCache(ctx, aids); err != nil {
+			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(c, arg); err != nil {
+			err = errors.Wrapf(err, "%v", arg)
+			return
+		}
+		for aid, a := range tmp {
+			am[aid] = a
+		}
+		return
+	})
+	var stm map[int64]*api.Stat
+	g.Go(func() (err error) {
+		var missed []int64
+		if stm, missed, err = d.statsCache(ctx, aids); err != nil {
+			missed = aids
+			log.Error("%+v", err)
+			err = nil
+		}
+		if len(missed) == 0 {
+			return
+		}
+		tmp, err := d.arcRPC.Stats3(ctx, &archive.ArgAids2{Aids: missed})
+		if err != nil {
+			log.Error("%+v", err)
+			err = nil
+			return
+		}
+		for _, st := range tmp {
+			stm[st.Aid] = st
+		}
+		return
+	})
+	if err = g.Wait(); err != nil {
+		return
+	}
+	for aid, arc := range am {
+		if st, ok := stm[aid]; ok {
+			arc.Stat = *st
+		}
+	}
+	return
+}
+
+// ArchivesWithPlayer archives witch player
+func (d *Dao) ArchivesWithPlayer(c context.Context, aids []int64, qn int, platform string, fnver, fnval, forceHost, build int) (res map[int64]*archive.ArchiveWithPlayer, err error) {
+	if len(aids) == 0 {
+		return
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &archive.ArgPlayer{Aids: aids, Qn: qn, Platform: platform, Fnval: fnval, Fnver: fnver, RealIP: ip, ForceHost: forceHost, Build: build}
+	if res, err = d.arcRPC.ArchivesWithPlayer(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

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

@@ -0,0 +1,77 @@
+package archive
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/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-feed")
+		flag.Set("conf_token", "OC30xxkAOyaH9fI6FRuXA0Ob5HL0f3kc")
+		flag.Set("tree_id", "2686")
+		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 TestPing(t *testing.T) {
+	var (
+		c = context.TODO()
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		d.PingMC(c)
+	})
+}
+
+func TestArchives(t *testing.T) {
+	var (
+		c    = context.TODO()
+		aids = []int64{1}
+	)
+	convey.Convey("Ping", 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 TestArchivesWithPlayer(t *testing.T) {
+	var (
+		c         = context.TODO()
+		aids      = []int64{1}
+		qn        = 32
+		platform  = "android"
+		fnver     = 0
+		fnval     = 0
+		forceHost = 0
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, err := d.ArchivesWithPlayer(c, aids, qn, platform, fnver, fnval, forceHost, 0)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

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

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

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

@@ -0,0 +1,20 @@
+package archive
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_statsCache(t *testing.T) {
+	Convey("should get statsCache", t, func() {
+		d.statsCache(context.Background(), []int64{1, 2, 3, 4})
+	})
+}
+
+func Test_arcsCache(t *testing.T) {
+	Convey("should get arcsCache", t, func() {
+		d.arcsCache(context.Background(), []int64{1, 2, 3, 4})
+	})
+}

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

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

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

@@ -0,0 +1,36 @@
+package article
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-feed/conf"
+	article "go-common/app/interface/openplatform/article/model"
+	artrpc "go-common/app/interface/openplatform/article/rpc/client"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is archive dao.
+type Dao struct {
+	// rpc
+	artRPC *artrpc.Service
+}
+
+// New new a archive dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// rpc
+		artRPC: artrpc.New(c.ArticleRPC),
+	}
+	return
+}
+
+func (d *Dao) Articles(c context.Context, aids []int64) (ms map[int64]*article.Meta, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &article.ArgAids{Aids: aids, RealIP: ip}
+	if ms, err = d.artRPC.ArticleMetas(c, arg); err != nil {
+		err = errors.Wrapf(err, "%v", aids)
+	}
+	return
+}

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

@@ -0,0 +1,62 @@
+package article
+
+import (
+	"context"
+	"go-common/app/interface/main/app-feed/conf"
+	article "go-common/app/interface/openplatform/article/model"
+	"reflect"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		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)
+			}
+		})
+	}
+	Convey("new", t, func() {
+		So(t, ShouldNotBeNil)
+	})
+}
+
+func TestDao_Articles(t *testing.T) {
+	type args struct {
+		c    context.Context
+		aids []int64
+	}
+	tests := []struct {
+		name    string
+		d       *Dao
+		args    args
+		wantMs  map[int64]*article.Meta
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotMs, err := tt.d.Articles(tt.args.c, tt.args.aids)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.Articles() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotMs, tt.wantMs) {
+				t.Errorf("Dao.Articles() = %v, want %v", gotMs, tt.wantMs)
+			}
+		})
+	}
+}

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

@@ -0,0 +1,51 @@
+package audio
+
+import (
+	"context"
+	"net/url"
+
+	"go-common/app/interface/main/app-card/model/card/audio"
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_audios = "/x/internal/v1/audio/menus/batch"
+)
+
+type Dao struct {
+	client    *httpx.Client
+	getAudios string
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:    httpx.NewClient(c.HTTPClient),
+		getAudios: c.Host.APICo + _audios,
+	}
+	return
+}
+
+func (d *Dao) Audios(c context.Context, ids []int64) (aum map[int64]*audio.Audio, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("ids", xstr.JoinInts(ids))
+	var res struct {
+		Code int                    `json:"code"`
+		Data map[int64]*audio.Audio `json:"data"`
+	}
+	if err = d.client.Get(c, d.getAudios, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.getAudios+"?"+params.Encode())
+		return
+	}
+	aum = res.Data
+	return
+}

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

@@ -0,0 +1,67 @@
+package audio
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-card/model/card/audio"
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+}
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotD := New(tt.args.c); !reflect.DeepEqual(gotD, tt.wantD) {
+				t.Errorf("New() = %v, want %v", gotD, tt.wantD)
+			}
+		})
+	}
+}
+
+func TestDao_Audios(t *testing.T) {
+	type args struct {
+		c   context.Context
+		ids []int64
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantAum map[int64]*audio.Audio
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotAum, err := d.Audios(tt.args.c, tt.args.ids)
+			So(gotAum, ShouldEqual, tt.wantAum)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}

app/interface/main/app-feed/dao/audit/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 = ["audit_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["audit.go"],
+    importpath = "go-common/app/interface/main/app-feed/dao/audit",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//library/database/sql: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-feed/dao/audit/audit.go

@@ -0,0 +1,69 @@
+package audit
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-feed/conf"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getSQL = "SELECT mobi_app,build FROM audit"
+)
+
+// Dao is audit dao.
+type Dao struct {
+	db     *xsql.DB
+	audGet *xsql.Stmt
+}
+
+// New new a audit dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: xsql.NewMySQL(c.MySQL.Show),
+	}
+	d.audGet = d.db.Prepared(_getSQL)
+	return
+}
+
+// Audits get all audit build.
+func (d *Dao) Audits(c context.Context) (res map[string]map[int]struct{}, err error) {
+	rows, err := d.audGet.Query(c)
+	if err != nil {
+		log.Error("query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	var (
+		mobiApp string
+		build   int
+	)
+	res = map[string]map[int]struct{}{}
+	for rows.Next() {
+		if err = rows.Scan(&mobiApp, &build); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			res = nil
+			return
+		}
+		if plat, ok := res[mobiApp]; ok {
+			plat[build] = struct{}{}
+		} else {
+			res[mobiApp] = map[int]struct{}{
+				build: struct{}{},
+			}
+		}
+	}
+	return
+}
+
+func (dao *Dao) PingDB(c context.Context) (err error) {
+	return dao.db.Ping(c)
+}
+
+// Close close db resource.
+func (dao *Dao) Close() {
+	if dao.db != nil {
+		dao.db.Close()
+	}
+}

app/interface/main/app-feed/dao/audit/audit_test.go

@@ -0,0 +1,98 @@
+package audit
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	dao *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	dao = 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_Audits(t *testing.T) {
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantRes map[string]map[int]struct{}
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotRes, err := dao.Audits(tt.args.c)
+			So(gotRes, ShouldEqual, tt.wantRes)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_PingDB(t *testing.T) {
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := dao.PingDB(tt.args.c); (err != nil) != tt.wantErr {
+				t.Errorf("Dao.PingDB() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestDao_Close(t *testing.T) {
+	tests := []struct {
+		name string
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dao.Close()
+		})
+	}
+}

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

@@ -0,0 +1,54 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/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-feed/dao/bangumi",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-card/model/card/bangumi:go_default_library",
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//app/service/main/feed/model:go_default_library",
+        "//app/service/openplatform/pgc-season/api/grpc/episode/v1: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-feed/dao/bangumi/dao.go

@@ -0,0 +1,141 @@
+package bangumi
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-card/model/card/bangumi"
+	"go-common/app/interface/main/app-feed/conf"
+	feed "go-common/app/service/main/feed/model"
+	episodegrpc "go-common/app/service/openplatform/pgc-season/api/grpc/episode/v1"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_seasons     = "/api/inner/aid_episodes_v2"
+	_updates     = "/internal_api/follow_update"
+	_pullSeasons = "/internal_api/follow_seasons"
+	_followPull  = "/pgc/internal/moe/2018/follow/pull"
+)
+
+// Dao is show dao.
+type Dao struct {
+	// http client
+	client *httpx.Client
+	// bangumi
+	seasons     string
+	updates     string
+	pullSeasons string
+	followPull  string
+	// grpc
+	rpcClient episodegrpc.EpisodeClient
+}
+
+// New new a bangumi dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http clients
+		client:      httpx.NewClient(c.HTTPBangumi),
+		seasons:     c.Host.Bangumi + _seasons,
+		updates:     c.Host.Bangumi + _updates,
+		pullSeasons: c.Host.Bangumi + _pullSeasons,
+		followPull:  c.Host.APICo + _followPull,
+	}
+	var err error
+	if d.rpcClient, err = episodegrpc.NewClient(c.PGCRPC); err != nil {
+		panic(fmt.Sprintf("episodegrpc NewClientt error (%+v)", err))
+	}
+	return d
+}
+
+func (d *Dao) Seasons(c context.Context, aids []int64, now time.Time) (sm map[int64]*bangumi.Season, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("aids", xstr.JoinInts(aids))
+	params.Set("type", "av")
+	params.Set("build", "app-feed")
+	params.Set("platform", "Golang")
+	var res struct {
+		Code   int                       `json:"code"`
+		Result map[int64]*bangumi.Season `json:"result"`
+	}
+	if err = d.client.Get(c, d.seasons, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.seasons+"?"+params.Encode())
+		return
+	}
+	sm = res.Result
+	return
+}
+
+func (d *Dao) Updates(c context.Context, mid int64, now time.Time) (u *bangumi.Update, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code   int             `json:"code"`
+		Result *bangumi.Update `json:"result"`
+	}
+	if err = d.client.Get(c, d.updates, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.updates+"?"+params.Encode())
+		return
+	}
+	u = res.Result
+	return
+}
+
+func (d *Dao) PullSeasons(c context.Context, seasonIDs []int64, now time.Time) (psm map[int64]*feed.Bangumi, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("season_ids", xstr.JoinInts(seasonIDs))
+	var res struct {
+		Code   int             `json:"code"`
+		Result []*feed.Bangumi `json:"result"`
+	}
+	if err = d.client.Get(c, d.pullSeasons, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.pullSeasons+"?"+params.Encode())
+		return
+	}
+	psm = make(map[int64]*feed.Bangumi, len(res.Result))
+	for _, p := range res.Result {
+		psm[p.SeasonID] = p
+	}
+	return
+}
+
+func (d *Dao) FollowPull(c context.Context, mid int64, mobiApp, device string, now time.Time) (moe *bangumi.Moe, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("mobi_app", mobiApp)
+	params.Set("device", device)
+	var res struct {
+		Code   int          `json:"code"`
+		Result *bangumi.Moe `json:"result"`
+	}
+	if err = d.client.Get(c, d.followPull, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.followPull+"?"+params.Encode())
+		return
+	}
+	moe = res.Result
+	return
+}

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

@@ -0,0 +1,81 @@
+package bangumi
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-feed")
+		flag.Set("conf_token", "OC30xxkAOyaH9fI6FRuXA0Ob5HL0f3kc")
+		flag.Set("tree_id", "2686")
+		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 TestSeasons(t *testing.T) {
+	Convey("get Seasons all", t, func() {
+		_, err := d.Seasons(ctx(), []int64{1}, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestUpdates(t *testing.T) {
+	Convey("get Updates all", t, func() {
+		_, err := d.Updates(ctx(), 1, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestPullSeasons(t *testing.T) {
+	Convey("get PullSeasons all", t, func() {
+		_, err := d.PullSeasons(ctx(), []int64{1}, time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestTestFollowPull(t *testing.T) {
+	Convey("get PullSeasons all", t, func() {
+		_, err := d.FollowPull(ctx(), 1, "iphone", "phone", time.Now())
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestCardsInfoReply(t *testing.T) {
+	Convey("get PullSeasons all", t, func() {
+		_, err := d.CardsInfoReply(ctx(), []int32{1})
+		err = nil
+		So(err, ShouldBeNil)
+	})
+}

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

@@ -0,0 +1,20 @@
+package bangumi
+
+import (
+	"context"
+
+	episodegrpc "go-common/app/service/openplatform/pgc-season/api/grpc/episode/v1"
+
+	"github.com/pkg/errors"
+)
+
+func (d *Dao) CardsInfoReply(c context.Context, episodeIds []int32) (res map[int32]*episodegrpc.EpisodeCardsProto, err error) {
+	arg := &episodegrpc.EpReq{Epids: episodeIds}
+	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-feed/dao/black/BUILD

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

@@ -0,0 +1,25 @@
+package black
+
+import (
+	"context"
+)
+
+const (
+	_blackURL = "http://172.18.7.208/privatedata/reco-deny-arcs.json"
+)
+
+// Black returns blacklist of aids
+func (d *Dao) Black(c context.Context) (black map[int64]struct{}, err error) {
+	var res []int64
+	if err = d.clientAsyn.Get(c, _blackURL, "", nil, &res); err != nil {
+		return
+	}
+	if len(res) == 0 {
+		return
+	}
+	black = make(map[int64]struct{}, len(res))
+	for _, aid := range res {
+		black[aid] = struct{}{}
+	}
+	return
+}

app/interface/main/app-feed/dao/black/dao.go

@@ -0,0 +1,87 @@
+package black
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/cache/redis"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+// Dao is black dao.
+type Dao struct {
+	// http clientAsyn
+	clientAsyn *httpx.Client
+	// redis
+	redis     *redis.Pool
+	expireRds int32
+	aCh       chan func()
+}
+
+// New new a black dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		clientAsyn: httpx.NewClient(c.HTTPClientAsyn),
+		// redis init
+		redis:     redis.NewPool(c.Redis.Feed.Config),
+		expireRds: int32(time.Duration(c.Redis.Feed.ExpireBlack) / time.Second),
+		aCh:       make(chan func(), 1024),
+	}
+	go d.cacheproc()
+	return
+}
+
+// Ping  Ping check redis connection
+func (d *Dao) Ping(c context.Context) (err error) {
+	connRedis := d.redis.Get(c)
+	_, err = connRedis.Do("SET", "PING", "PONG")
+	connRedis.Close()
+	return
+}
+
+func (d *Dao) AddBlacklist(mid, aid int64) {
+	d.addCache(func() {
+		d.addBlackCache(context.Background(), mid, aid)
+	})
+}
+
+func (d *Dao) DelBlacklist(mid, aid int64) {
+	d.addCache(func() {
+		d.delBlackCache(context.Background(), mid, aid)
+	})
+}
+
+func (d *Dao) BlackList(c context.Context, mid int64) (aidm map[int64]struct{}, err error) {
+	var ok bool
+	if ok, err = d.expireBlackCache(c, mid); err != nil {
+		return
+	}
+	if ok {
+		aidm, err = d.blackCache(c, mid)
+	}
+	return
+}
+
+// addCache add cache to mc by goroutine
+func (d *Dao) addCache(i func()) {
+	select {
+	case d.aCh <- i:
+	default:
+		log.Warn("cacheproc chan full")
+	}
+}
+
+// cacheproc cache proc
+func (d *Dao) cacheproc() {
+	for {
+		f, ok := <-d.aCh
+		if !ok {
+			log.Warn("cache proc exit")
+			return
+		}
+		f()
+	}
+}

app/interface/main/app-feed/dao/black/dao_test.go

@@ -0,0 +1,228 @@
+package black
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/cache/redis"
+	httpx "go-common/library/net/http/blademaster"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		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)
+			}
+		})
+		Convey(tt.name, func(t *testing.T) {
+			gotD := New(tt.args.c)
+			So(gotD, ShouldEqual, tt.wantD)
+		})
+	}
+}
+
+func TestDao_Ping(t *testing.T) {
+	type fields struct {
+		clientAsyn *httpx.Client
+		redis      *redis.Pool
+		expireRds  int32
+		aCh        chan func()
+	}
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				clientAsyn: tt.fields.clientAsyn,
+				redis:      tt.fields.redis,
+				expireRds:  tt.fields.expireRds,
+				aCh:        tt.fields.aCh,
+			}
+			if err := d.Ping(tt.args.c); (err != nil) != tt.wantErr {
+				t.Errorf("Dao.Ping() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestDao_AddBlacklist(t *testing.T) {
+	type fields struct {
+		clientAsyn *httpx.Client
+		redis      *redis.Pool
+		expireRds  int32
+		aCh        chan func()
+	}
+	type args struct {
+		mid int64
+		aid int64
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				clientAsyn: tt.fields.clientAsyn,
+				redis:      tt.fields.redis,
+				expireRds:  tt.fields.expireRds,
+				aCh:        tt.fields.aCh,
+			}
+			d.AddBlacklist(tt.args.mid, tt.args.aid)
+		})
+	}
+}
+
+func TestDao_DelBlacklist(t *testing.T) {
+	type fields struct {
+		clientAsyn *httpx.Client
+		redis      *redis.Pool
+		expireRds  int32
+		aCh        chan func()
+	}
+	type args struct {
+		mid int64
+		aid int64
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				clientAsyn: tt.fields.clientAsyn,
+				redis:      tt.fields.redis,
+				expireRds:  tt.fields.expireRds,
+				aCh:        tt.fields.aCh,
+			}
+			d.DelBlacklist(tt.args.mid, tt.args.aid)
+		})
+	}
+}
+
+func TestDao_BlackList(t *testing.T) {
+	type fields struct {
+		clientAsyn *httpx.Client
+		redis      *redis.Pool
+		expireRds  int32
+		aCh        chan func()
+	}
+	type args struct {
+		c   context.Context
+		mid int64
+	}
+	tests := []struct {
+		name     string
+		fields   fields
+		args     args
+		wantAidm map[int64]struct{}
+		wantErr  bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				clientAsyn: tt.fields.clientAsyn,
+				redis:      tt.fields.redis,
+				expireRds:  tt.fields.expireRds,
+				aCh:        tt.fields.aCh,
+			}
+			gotAidm, err := d.BlackList(tt.args.c, tt.args.mid)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.BlackList() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotAidm, tt.wantAidm) {
+				t.Errorf("Dao.BlackList() = %v, want %v", gotAidm, tt.wantAidm)
+			}
+		})
+	}
+}
+
+func TestDao_addCache(t *testing.T) {
+	type fields struct {
+		clientAsyn *httpx.Client
+		redis      *redis.Pool
+		expireRds  int32
+		aCh        chan func()
+	}
+	type args struct {
+		i func()
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				clientAsyn: tt.fields.clientAsyn,
+				redis:      tt.fields.redis,
+				expireRds:  tt.fields.expireRds,
+				aCh:        tt.fields.aCh,
+			}
+			d.addCache(tt.args.i)
+		})
+	}
+}
+
+func TestDao_cacheproc(t *testing.T) {
+	type fields struct {
+		clientAsyn *httpx.Client
+		redis      *redis.Pool
+		expireRds  int32
+		aCh        chan func()
+	}
+	tests := []struct {
+		name   string
+		fields fields
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				clientAsyn: tt.fields.clientAsyn,
+				redis:      tt.fields.redis,
+				expireRds:  tt.fields.expireRds,
+				aCh:        tt.fields.aCh,
+			}
+			d.cacheproc()
+		})
+	}
+}

app/interface/main/app-feed/dao/black/redis.go

@@ -0,0 +1,82 @@
+package black
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/library/cache/redis"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_prefixBlack = "b_"
+)
+
+func keyBlack(mid int64) string {
+	return _prefixBlack + strconv.FormatInt(mid, 10)
+}
+
+func (d *Dao) blackCache(c context.Context, mid int64) (aidm map[int64]struct{}, err error) {
+	var aids []int64
+	conn := d.redis.Get(c)
+	key := keyBlack(mid)
+	defer conn.Close()
+	if aids, err = redis.Int64s(conn.Do("ZREVRANGE", key, 0, -1)); err != nil {
+		err = errors.Wrapf(err, "conn.Do(ZREVRANGE,%s,0,-1)", key)
+		return
+	}
+	aidm = make(map[int64]struct{}, len(aids))
+	for _, aid := range aids {
+		aidm[aid] = struct{}{}
+	}
+	return
+}
+
+func (d *Dao) addBlackCache(c context.Context, mid int64, aids ...int64) (err error) {
+	if len(aids) == 0 {
+		return
+	}
+	key := keyBlack(mid)
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	for _, aid := range aids {
+		if err = conn.Send("ZADD", key, aid, aid); err != nil {
+			err = errors.Wrapf(err, "conn.Send(ZADD,%s,%d,%d)", key, aid, aid)
+			return
+		}
+	}
+	if err = conn.Send("EXPIRE", key, d.expireRds); err != nil {
+		err = errors.Wrapf(err, "conn.Send(EXPIRE,%s,%d)", key, d.expireRds)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		return
+	}
+	for i := 0; i < len(aids)+1; i++ {
+		if _, err = conn.Receive(); err != nil {
+			return
+		}
+	}
+	return
+}
+
+func (d *Dao) delBlackCache(c context.Context, mid, aid int64) (err error) {
+	key := keyBlack(mid)
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if _, err = conn.Do("ZREM", key, aid); err != nil {
+		err = errors.Wrapf(err, "conn.Do(ZREM,%s,%d)", key, aid)
+	}
+	return
+}
+
+func (d *Dao) expireBlackCache(c context.Context, mid int64) (ok bool, err error) {
+	key := keyBlack(mid)
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if ok, err = redis.Bool(conn.Do("EXPIRE", key, d.expireRds)); err != nil {
+		err = errors.Wrapf(err, "conn.Do(EXPIRE,%s,%d)", key, d.expireRds)
+	}
+	return
+}

app/interface/main/app-feed/dao/bplus/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"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/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-feed/dao/bplus",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-card/model/bplus:go_default_library",
+        "//app/interface/main/app-feed/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-feed/dao/bplus/dao.go

@@ -0,0 +1,65 @@
+package bplus
+
+import (
+	"context"
+	"go-common/app/interface/main/app-card/model/bplus"
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"net/url"
+	"strconv"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_dynamicDetail = "/dynamic_detail/v0/dynamic/details"
+)
+
+// Dao is a dao.
+type Dao struct {
+	// http client
+	client *httpx.Client
+	// ad
+	dynamicDetail string
+}
+
+// New new a dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		client:        httpx.NewClient(c.HTTPClient),
+		dynamicDetail: c.Host.DynamicCo + _dynamicDetail,
+	}
+	return
+}
+
+// DynamicDetail is.
+func (d *Dao) DynamicDetail(c context.Context, ids ...int64) (picm map[int64]*bplus.Picture, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	for _, id := range ids {
+		params.Add("dynamic_ids[]", strconv.FormatInt(id, 10))
+	}
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			List []*bplus.Picture `json:"list"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.dynamicDetail, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.dynamicDetail+"?"+params.Encode())
+		return
+	}
+	if res.Data != nil {
+		picm = make(map[int64]*bplus.Picture, len(res.Data.List))
+		for _, pic := range res.Data.List {
+			picm[pic.DynamicID] = pic
+		}
+	}
+	return
+}

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

@@ -0,0 +1,45 @@
+package bplus
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/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-feed")
+		flag.Set("conf_token", "OC30xxkAOyaH9fI6FRuXA0Ob5HL0f3kc")
+		flag.Set("tree_id", "2686")
+		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 TestDynamicDetail(t *testing.T) {
+	Convey(t.Name(), t, func(ctx C) {
+		gotPicm, _ := d.DynamicDetail(context.Background(), 123)
+		So(gotPicm, ShouldBeNil)
+	})
+}

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

@@ -0,0 +1,45 @@
+package tab
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/database/sql"
+)
+
+const (
+	_followSQL = "SELECT `id`,`type`,`long_title`,`content` FROM `card_follow` WHERE `deleted`=0"
+)
+
+type Dao struct {
+	db        *sql.DB
+	followGet *sql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	// prepare
+	d.followGet = d.db.Prepared(_followSQL)
+	return
+}
+
+func (d *Dao) Follow(c context.Context) (cm map[int64]*operate.Follow, err error) {
+	var rows *sql.Rows
+	if rows, err = d.followGet.Query(c); err != nil {
+		return
+	}
+	defer rows.Close()
+	cm = make(map[int64]*operate.Follow)
+	for rows.Next() {
+		c := &operate.Follow{}
+		if err = rows.Scan(&c.ID, &c.Type, &c.Title, &c.Content); err != nil {
+			return
+		}
+		c.Change()
+		cm[c.ID] = c
+	}
+	return
+}

app/interface/main/app-feed/dao/card/dao_test.go

@@ -0,0 +1,28 @@
+package tab
+
+import (
+	. "github.com/smartystreets/goconvey/convey"
+
+	"go-common/app/interface/main/app-feed/conf"
+
+	"testing"
+)
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotD := New(tt.args.c)
+			So(gotD, ShouldEqual, tt.wantD)
+		})
+	}
+}

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

@@ -0,0 +1,52 @@
+package converge
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/database/sql"
+)
+
+const (
+	_getSQL = "SELECT id,re_type,re_value,title,cover,content FROM content_card"
+)
+
+type Dao struct {
+	db      *sql.DB
+	cardGet *sql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Manager),
+	}
+	// prepare
+	d.cardGet = d.db.Prepared(_getSQL)
+	return
+}
+
+func (d *Dao) Cards(c context.Context) (cm map[int64]*operate.Converge, err error) {
+	rows, err := d.cardGet.Query(c)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	cm = map[int64]*operate.Converge{}
+	for rows.Next() {
+		c := &operate.Converge{}
+		if err = rows.Scan(&c.ID, &c.ReType, &c.ReValue, &c.Title, &c.Cover, &c.Content); err != nil {
+			return
+		}
+		c.Change()
+		cm[c.ID] = c
+	}
+	return
+}
+
+// Close close memcache resource.
+func (dao *Dao) Close() {
+	if dao.db != nil {
+		dao.db.Close()
+	}
+}

app/interface/main/app-feed/dao/converge/dao_test.go

@@ -0,0 +1,80 @@
+package converge
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-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_Cards(t *testing.T) {
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantCm  map[int64]*operate.Converge
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotCm, err := d.Cards(tt.args.c)
+			So(gotCm, ShouldEqual, tt.wantCm)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_Close(t *testing.T) {
+	tests := []struct {
+		name string
+		dao  *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.dao.Close()
+		})
+	}
+}

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

@@ -0,0 +1,59 @@
+package dynamic
+
+import (
+	"context"
+	"encoding/json"
+
+	"go-common/app/interface/main/app-feed/conf"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+var (
+	_dynamicGet     = "/dynamic_svr/v1/dynamic_svr/dynamic_new"
+	_dynamicHistory = "/dynamic_svr/v1/dynamic_svr/dynamic_history"
+)
+
+// Dao .
+type Dao struct {
+	client *httpx.Client
+	host   string
+}
+
+// New .
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPDynamic),
+		host:   c.Host.Dynamic,
+	}
+	return
+}
+
+func (d *Dao) dynamicSrv(c context.Context, reqPath string, params string) (res json.RawMessage, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	uri := d.host + reqPath + "?" + params
+	if err = d.client.Get(c, uri, ip, nil, &res); err != nil {
+		err = errors.Wrap(err, uri)
+	}
+	return
+}
+
+// DynamicHistory .
+func (d *Dao) DynamicHistory(c context.Context, params string) (res json.RawMessage, err error) {
+	res, err = d.dynamicSrv(c, _dynamicHistory, params)
+	return
+}
+
+// DynamicCount .
+func (d *Dao) DynamicCount(c context.Context, params string) (res json.RawMessage, err error) {
+	res, err = d.dynamicSrv(c, _dynamicGet, params)
+	return
+}
+
+// DynamicNew .
+func (d *Dao) DynamicNew(c context.Context, params string) (res json.RawMessage, err error) {
+	res, err = d.dynamicSrv(c, _dynamicGet, params)
+	return
+}

app/interface/main/app-feed/dao/dynamic/dao_test.go

@@ -0,0 +1,152 @@
+package dynamic
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-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_dynamicSrv(t *testing.T) {
+	type args struct {
+		c       context.Context
+		reqPath string
+		params  string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantRes json.RawMessage
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotRes, err := d.dynamicSrv(tt.args.c, tt.args.reqPath, tt.args.params)
+			So(gotRes, ShouldEqual, tt.wantRes)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_DynamicHistory(t *testing.T) {
+	type args struct {
+		c      context.Context
+		params string
+	}
+	tests := []struct {
+		name    string
+		d       *Dao
+		args    args
+		wantRes json.RawMessage
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotRes, err := tt.d.DynamicHistory(tt.args.c, tt.args.params)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.DynamicHistory() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Dao.DynamicHistory() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestDao_DynamicCount(t *testing.T) {
+	type args struct {
+		c      context.Context
+		params string
+	}
+	tests := []struct {
+		name    string
+		d       *Dao
+		args    args
+		wantRes json.RawMessage
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotRes, err := tt.d.DynamicCount(tt.args.c, tt.args.params)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.DynamicCount() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Dao.DynamicCount() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestDao_DynamicNew(t *testing.T) {
+	type args struct {
+		c      context.Context
+		params string
+	}
+	tests := []struct {
+		name    string
+		d       *Dao
+		args    args
+		wantRes json.RawMessage
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotRes, err := tt.d.DynamicNew(tt.args.c, tt.args.params)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.DynamicNew() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Dao.DynamicNew() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}

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

@@ -0,0 +1,52 @@
+package game
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/database/sql"
+)
+
+const (
+	_getSQL = "SELECT `id`,`title`,`desc`,`icon`,`cover`,`url_type`,`url_value`,`btn_txt`,`re_type`,`re_value`,`number`,`double_cover` FROM download_card"
+)
+
+type Dao struct {
+	db          *sql.DB
+	downloadGet *sql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Manager),
+	}
+	// prepare
+	d.downloadGet = d.db.Prepared(_getSQL)
+	return
+}
+
+func (d *Dao) DownLoad(c context.Context) (dm map[int64]*operate.Download, err error) {
+	rows, err := d.downloadGet.Query(c)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	dm = map[int64]*operate.Download{}
+	for rows.Next() {
+		d := &operate.Download{}
+		if err = rows.Scan(&d.ID, &d.Title, &d.Desc, &d.Icon, &d.Cover, &d.URLType, &d.URLValue, &d.BtnTxt, &d.ReType, &d.ReValue, &d.Number, &d.DoubleCover); err != nil {
+			return
+		}
+		d.Change()
+		dm[d.ID] = d
+	}
+	return
+}
+
+// Close close memcache resource.
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}

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

@@ -0,0 +1,80 @@
+package game
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-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_DownLoad(t *testing.T) {
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantDm  map[int64]*operate.Download
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotDm, err := d.DownLoad(tt.args.c)
+			So(gotDm, ShouldEqual, tt.wantDm)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_Close(t *testing.T) {
+	tests := []struct {
+		name string
+		d    *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.d.Close()
+		})
+	}
+}

app/interface/main/app-feed/dao/live/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-card/model/card/live:go_default_library",
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//app/interface/main/app-feed/model/live: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-feed/dao/live",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-card/model/card/live:go_default_library",
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//app/interface/main/app-feed/model/live:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

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

@@ -0,0 +1,135 @@
+package live
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-card/model/card/live"
+	"go-common/app/interface/main/app-feed/conf"
+	model "go-common/app/interface/main/app-feed/model/live"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_appMRoom = "/room/v1/Room/rooms_for_app_index"
+	_feedList = "/feed/v1/feed/getList"
+	_card     = "/room/v1/RoomRecommend/getInfoByCardId"
+)
+
+// Dao is show dao.
+type Dao struct {
+	// http client
+	client     *httpx.Client
+	clientAsyn *httpx.Client
+	// live
+	appMRoom string
+	feedList string
+	card     string
+}
+
+// New new a bangumi dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		client:     httpx.NewClient(c.HTTPClient),
+		clientAsyn: httpx.NewClient(c.HTTPClientAsyn),
+		appMRoom:   c.Host.LiveAPI + _appMRoom,
+		feedList:   c.Host.LiveAPI + _feedList,
+		card:       c.Host.LiveAPI + _card,
+	}
+	return
+}
+
+func (d *Dao) AppMRoom(c context.Context, roomids []int64) (rs map[int64]*live.Room, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("room_ids", xstr.JoinInts(roomids))
+	var res struct {
+		Code int          `json:"code"`
+		Data []*live.Room `json:"data"`
+	}
+	if err = d.client.Get(c, d.appMRoom, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.appMRoom+"?"+params.Encode())
+		return
+	}
+	rs = make(map[int64]*live.Room, len(res.Data))
+	for _, r := range res.Data {
+		rs[r.RoomID] = r
+	}
+	return
+}
+
+func (d *Dao) FeedList(c context.Context, mid int64, pn, ps int) (fs []*model.Feed, count int, err error) {
+	var req *http.Request
+	params := url.Values{}
+	params.Set("page", strconv.Itoa(pn))
+	params.Set("pagesize", strconv.Itoa(ps))
+	if req, err = d.client.NewRequest("GET", d.feedList, "", params); err != nil {
+		return
+	}
+	req.Header.Set("X-BiliLive-UID", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Rooms []*model.Feed `json:"rooms"`
+			Count int           `json:"count"`
+		} `json:"data"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.feedList+"?"+params.Encode())
+		return
+	}
+	fs = res.Data.Rooms
+	count = res.Data.Count
+	return
+}
+
+func (d *Dao) Card(c context.Context) (csm map[int64][]*live.Card, err error) {
+	var res struct {
+		Code int                    `json:"code"`
+		Data map[int64][]*live.Card `json:"data"`
+	}
+	if err = d.clientAsyn.Get(c, d.card, "", nil, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.card)
+		return
+	}
+	csm = res.Data
+	return
+}
+
+func (d *Dao) Rooms(c context.Context, roomids []int64, ip string) (rs map[int64]*live.Room, err error) {
+	params := url.Values{}
+	params.Set("room_ids", xstr.JoinInts(roomids))
+	var res struct {
+		Code int          `json:"code"`
+		Data []*live.Room `json:"data"`
+	}
+	if err = d.clientAsyn.Get(c, d.appMRoom, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.appMRoom+"?"+params.Encode())
+		return
+	}
+	rs = make(map[int64]*live.Room, len(res.Data))
+	for _, r := range res.Data {
+		rs[r.RoomID] = r
+	}
+	return
+}

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

@@ -0,0 +1,94 @@
+package live
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-card/model/card/live"
+	"go-common/app/interface/main/app-feed/conf"
+	model "go-common/app/interface/main/app-feed/model/live"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-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_AppMRoom(t *testing.T) {
+	type args struct {
+		c       context.Context
+		roomids []int64
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantRs  map[int64]*live.Room
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotRs, err := d.AppMRoom(tt.args.c, tt.args.roomids)
+			So(gotRs, ShouldEqual, tt.wantRs)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_FeedList(t *testing.T) {
+	type args struct {
+		c   context.Context
+		mid int64
+		pn  int
+		ps  int
+	}
+	tests := []struct {
+		name      string
+		args      args
+		wantFs    []*model.Feed
+		wantCount int
+		wantErr   bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotFs, gotCount, err := d.FeedList(tt.args.c, tt.args.mid, tt.args.pn, tt.args.ps)
+			So(gotFs, ShouldEqual, tt.wantFs)
+			So(gotCount, ShouldEqual, tt.wantCount)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}

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

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

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

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

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

@@ -0,0 +1,50 @@
+package rank
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-card/model/card/rank"
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_allRank = "/data/rank/recent_all-app.json"
+)
+
+// Dao is rank dao.
+type Dao struct {
+	// http client
+	clientAsyn *httpx.Client
+	// all rank
+	allRank string
+}
+
+// New new a rank dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		clientAsyn: httpx.NewClient(c.HTTPClientAsyn),
+		allRank:    c.Host.Rank + _allRank,
+	}
+	return d
+}
+
+func (d *Dao) AllRank(c context.Context) (ranks []*rank.Rank, err error) {
+	var res struct {
+		Code int          `json:"code"`
+		List []*rank.Rank `json:"list"`
+	}
+	if err = d.clientAsyn.Get(c, d.allRank, "", nil, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.allRank)
+		return
+	}
+	ranks = res.List
+	return
+}

app/interface/main/app-feed/dao/rank/dao_test.go

@@ -0,0 +1,66 @@
+package rank
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-card/model/card/rank"
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-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_AllRank(t *testing.T) {
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name      string
+		args      args
+		wantRanks []rank.Rank
+		wantErr   error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotRanks, err := d.AllRank(tt.args.c)
+			So(gotRanks, ShouldEqual, tt.wantRanks)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}

app/interface/main/app-feed/dao/recommend/BUILD

@@ -0,0 +1,67 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "api_test.go",
+        "dao_test.go",
+        "databus_test.go",
+        "memcache_test.go",
+        "redis_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-card/model:go_default_library",
+        "//app/interface/main/app-card/model/card/ai:go_default_library",
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "dao.go",
+        "databus.go",
+        "memcache.go",
+        "redis.go",
+    ],
+    importpath = "go-common/app/interface/main/app-feed/dao/recommend",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-card/model:go_default_library",
+        "//app/interface/main/app-card/model/card/ai:go_default_library",
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//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-feed/dao/recommend/api.go

@@ -0,0 +1,150 @@
+package recommend
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-card/model"
+	"go-common/app/interface/main/app-card/model/card/ai"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_rcmd           = "/pegasus/feed/%d"
+	_hot            = "/data/rank/reco-tmzb.json"
+	_group          = "/group_changes/pegasus.json"
+	_top            = "/feed/tag/top"
+	_followModeList = "/data/rank/others/followmode_whitelist.json"
+)
+
+// Recommend is.
+func (d *Dao) Recommend(c context.Context, plat int8, buvid string, mid int64, build, loginEvent, parentMode, recsysMode int, zoneID int64, group int, interest, network string, style int, column model.ColumnStatus, flush int, autoplay string, now time.Time) (rs []*ai.Item, userFeature json.RawMessage, respCode int, newUser bool, err error) {
+	if mid == 0 && buvid == "" {
+		return
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	uri := fmt.Sprintf(d.rcmd, group)
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("buvid", buvid)
+	params.Set("plat", strconv.Itoa(int(plat)))
+	params.Set("build", strconv.Itoa(build))
+	params.Set("login_event", strconv.Itoa(loginEvent))
+	params.Set("zone_id", strconv.FormatInt(zoneID, 10))
+	params.Set("interest", interest)
+	params.Set("network", network)
+	if column > -1 {
+		params.Set("column", strconv.Itoa(int(column)))
+	}
+	params.Set("style", strconv.Itoa(style))
+	params.Set("flush", strconv.Itoa(flush))
+	params.Set("autoplay_card", autoplay)
+	params.Set("parent_mode", strconv.Itoa(parentMode))
+	params.Set("recsys_mode", strconv.Itoa(recsysMode))
+	var res struct {
+		Code        int             `json:"code"`
+		NewUser     bool            `json:"new_user"`
+		UserFeature json.RawMessage `json:"user_feature"`
+		Data        []*ai.Item      `json:"data"`
+	}
+	if err = d.client.Get(c, uri, ip, params, &res); err != nil {
+		respCode = ecode.ServerErr.Code()
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		respCode = res.Code
+		err = errors.Wrap(code, uri+"?"+params.Encode())
+		return
+	}
+	rs = res.Data
+	userFeature = res.UserFeature
+	newUser = res.NewUser
+	return
+}
+
+// Hots is.
+func (d *Dao) Hots(c context.Context) (aids []int64, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	var res struct {
+		Code int `json:"code"`
+		List []struct {
+			Aid int64 `json:"aid"`
+		} `json:"list"`
+	}
+	if err = d.clientAsyn.Get(c, d.hot, ip, nil, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrap(code, d.hot)
+		return
+	}
+	for _, list := range res.List {
+		if list.Aid != 0 {
+			aids = append(aids, list.Aid)
+		}
+	}
+	return
+}
+
+// TagTop is.
+func (d *Dao) TagTop(c context.Context, mid, tid int64, rn int) (aids []int64, err error) {
+	params := url.Values{}
+	params.Set("src", "2")
+	params.Set("pn", "1")
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("tag", strconv.FormatInt(tid, 10))
+	params.Set("rn", strconv.Itoa(rn))
+	var res struct {
+		Code int     `json:"code"`
+		Data []int64 `json:"data"`
+	}
+	if err = d.client.Get(c, d.top, "", params, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrap(code, d.top+"?"+params.Encode())
+		return
+	}
+	aids = res.Data
+	return
+}
+
+// Group is.
+func (d *Dao) Group(c context.Context) (gm map[int64]int, err error) {
+	err = d.clientAsyn.Get(c, d.group, "", nil, &gm)
+	return
+}
+
+// FollowModeList is.
+func (d *Dao) FollowModeList(c context.Context) (list map[int64]struct{}, err error) {
+	var res struct {
+		Code int     `json:"code"`
+		Data []int64 `json:"data"`
+	}
+	if err = d.clientAsyn.Get(c, d.followModeList, "", nil, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrap(code, d.followModeList)
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Warn("FollowModeList param(%s) res(%s)", b, d.followModeList)
+	list = make(map[int64]struct{}, len(res.Data))
+	for _, mid := range res.Data {
+		list[mid] = struct{}{}
+	}
+	return
+}

app/interface/main/app-feed/dao/recommend/api_test.go

@@ -0,0 +1,75 @@
+package recommend
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	cdm "go-common/app/interface/main/app-card/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestRecommend(t *testing.T) {
+	var (
+		c          = context.TODO()
+		plat       = int8(1)
+		buvid      = ""
+		mid        = int64(1)
+		build      = int(1111)
+		loginEvent = int(0)
+		parentMode = int(0)
+		recsysMode = int(1)
+		zoneID     = int64(0)
+		group      = int(0)
+		interest   = ""
+		network    = ""
+		style      = int(0)
+		column     cdm.ColumnStatus
+		flush      = int(0)
+		autoPlay   = ""
+		now        time.Time
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, _, _, _, err := d.Recommend(c, plat, buvid, mid, build, loginEvent, parentMode, recsysMode, zoneID, group, interest, network, style, column, flush, autoPlay, now)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestHots(t *testing.T) {
+	var (
+		c = context.TODO()
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, err := d.Hots(c)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestTagTop(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		tid = int64(1)
+		rn  = int(0)
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, err := d.TagTop(c, mid, tid, rn)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestGroup(t *testing.T) {
+	var (
+		c = context.TODO()
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		d.Group(c)
+	})
+}

app/interface/main/app-feed/dao/recommend/dao.go

@@ -0,0 +1,68 @@
+package recommend
+
+import (
+	"time"
+
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/queue/databus"
+)
+
+// Dao is show dao.
+type Dao struct {
+	// http client
+	client     *httpx.Client
+	clientAsyn *httpx.Client
+	// hetongzi
+	hot string
+	// bigdata
+	rcmd           string
+	group          string
+	top            string
+	followModeList string
+	// redis
+	redis     *redis.Pool
+	expireRds int
+	// databus
+	databus *databus.Databus
+	// mc
+	mc       *memcache.Pool
+	expireMc int32
+}
+
+// New new a show dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		client:     httpx.NewClient(c.HTTPData),
+		clientAsyn: httpx.NewClient(c.HTTPClientAsyn),
+		// hetongzi
+		hot: c.Host.Hetongzi + _hot,
+		// bigdata
+		rcmd:           c.Host.Data + _rcmd,
+		group:          c.Host.BigData + _group,
+		top:            c.Host.Data + _top,
+		followModeList: c.Host.Data + _followModeList,
+		// redis
+		redis:     redis.NewPool(c.Redis.Feed.Config),
+		expireRds: int(time.Duration(c.Redis.Feed.ExpireRecommend) / time.Second),
+		// databus
+		databus: databus.New(c.DislikeDatabus),
+		// mc
+		mc:       memcache.NewPool(c.Memcache.Cache.Config),
+		expireMc: int32(time.Duration(c.Memcache.Cache.ExpireCache) / time.Second),
+	}
+	return
+}
+
+// Close close resource.
+func (d *Dao) Close() {
+	if d.redis != nil {
+		d.redis.Close()
+	}
+	if d.mc != nil {
+		d.mc.Close()
+	}
+}

app/interface/main/app-feed/dao/recommend/dao_test.go

@@ -0,0 +1,34 @@
+package recommend
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/conf"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.app-svr.app-feed")
+		flag.Set("conf_token", "OC30xxkAOyaH9fI6FRuXA0Ob5HL0f3kc")
+		flag.Set("tree_id", "2686")
+		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)
+}

app/interface/main/app-feed/dao/recommend/databus.go

@@ -0,0 +1,46 @@
+package recommend
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"go-common/library/log"
+
+	"github.com/pkg/errors"
+)
+
+// PubDislike is.
+func (d *Dao) PubDislike(c context.Context, buvid, gt string, id, mid, reasonID, cmreasonID, feedbackID, upperID, rid, tagID int64, adcb string, now time.Time) (err error) {
+	return d.pub(c, buvid, gt, id, mid, reasonID, cmreasonID, feedbackID, upperID, rid, tagID, adcb, 1, now)
+}
+
+// PubDislikeCancel is.
+func (d *Dao) PubDislikeCancel(c context.Context, buvid, gt string, id, mid, reasonID, cmreasonID, feedbackID, upperID, rid, tagID int64, adcb string, now time.Time) (err error) {
+	return d.pub(c, buvid, gt, id, mid, reasonID, cmreasonID, feedbackID, upperID, rid, tagID, adcb, 2, now)
+}
+
+func (d *Dao) pub(c context.Context, buvid, gt string, id, mid, reasonID, cmreasonID, feedbackID, upperID, rid, tagID int64, adcb string, state int8, now time.Time) (err error) {
+	key := strconv.FormatInt(mid, 10)
+	msg := struct {
+		Buvid      string `json:"buvid"`
+		Goto       string `json:"goto"`
+		ID         int64  `json:"id"`
+		Mid        int64  `json:"mid"`
+		ReasonID   int64  `json:"reason_id"`
+		CMReasonID int64  `json:"cm_reason_id"`
+		FeedbackID int64  `json:"feedback_id"`
+		UpperID    int64  `json:"upper_id"`
+		Rid        int64  `json:"rid"`
+		TagID      int64  `json:"tag_id"`
+		ADCB       string `json:"ad_cb"`
+		State      int8   `json:"state"`
+		Time       int64  `json:"time"`
+	}{Buvid: buvid, Goto: gt, ID: id, Mid: mid, ReasonID: reasonID, CMReasonID: cmreasonID, FeedbackID: feedbackID, UpperID: upperID, Rid: rid, TagID: tagID, ADCB: adcb, State: state, Time: now.Unix()}
+	if err = d.databus.Send(c, key, msg); err != nil {
+		err = errors.Wrapf(err, "%s %v", key, msg)
+		return
+	}
+	log.Info("d.dataBus.Pub(%s,%v)", key, msg)
+	return
+}

app/interface/main/app-feed/dao/recommend/databus_test.go

@@ -0,0 +1,51 @@
+package recommend
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestPubDislike(t *testing.T) {
+	var (
+		c          = context.TODO()
+		buvid      string
+		gt         string
+		id         int64
+		mid        int64
+		reasonID   int64
+		cmReasonID int64
+		feedbackID int64
+		upperID    int64
+		rid        int64
+		tagID      int64
+		adcb       string
+		now        time.Time
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		d.PubDislike(c, buvid, gt, id, mid, reasonID, cmReasonID, feedbackID, upperID, rid, tagID, adcb, now)
+	})
+}
+
+func TestPubDislikeCancel(t *testing.T) {
+	var (
+		c          = context.TODO()
+		buvid      = ""
+		gt         = ""
+		id         = int64(1)
+		mid        = int64(1)
+		reasonID   = int64(1)
+		cmReasonID = int64(1)
+		feedbackID = int64(1)
+		upperID    = int64(1)
+		rid        = int64(1)
+		tagID      = int64(1)
+		adcb       = ""
+		now        time.Time
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		d.PubDislikeCancel(c, buvid, gt, id, mid, reasonID, cmReasonID, feedbackID, upperID, rid, tagID, adcb, now)
+	})
+}

app/interface/main/app-feed/dao/recommend/memcache.go

@@ -0,0 +1,124 @@
+package recommend
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-card/model/card/ai"
+	"go-common/library/cache/memcache"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_prefixRcmdAids       = "rc"
+	_prefixRcmd           = "rc2"
+	_prefixFollowModeList = "fml"
+)
+
+func keyRcmdAids() string {
+	return _prefixRcmdAids
+}
+
+func keyRcmd() string {
+	return _prefixRcmd
+}
+
+func keyFollowModeList() string {
+	return _prefixFollowModeList
+}
+
+// AddRcmdCache add ai into cahce.
+func (d *Dao) AddRcmdAidsCache(c context.Context, aids []int64) (err error) {
+	conn := d.mc.Get(c)
+	key := keyRcmdAids()
+	item := &memcache.Item{Key: key, Object: aids, Flags: memcache.FlagJSON, Expiration: d.expireMc}
+	if err = conn.Set(item); err != nil {
+		err = errors.Wrapf(err, "%v", aids)
+	}
+	conn.Close()
+	return
+}
+
+// RcmdCache get ai cache data from cache
+func (d *Dao) RcmdAidsCache(c context.Context) (aids []int64, err error) {
+	var r *memcache.Item
+	conn := d.mc.Get(c)
+	key := keyRcmdAids()
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrap(err, key)
+		return
+	}
+	if err = conn.Scan(r, &aids); err != nil {
+		err = errors.Wrapf(err, "%s", r.Value)
+	}
+	return
+}
+
+// AddRcmdCache add ai into cahce.
+func (d *Dao) AddRcmdCache(c context.Context, is []*ai.Item) (err error) {
+	conn := d.mc.Get(c)
+	key := keyRcmd()
+	item := &memcache.Item{Key: key, Object: is, Flags: memcache.FlagJSON, Expiration: d.expireMc}
+	if err = conn.Set(item); err != nil {
+		err = errors.Wrap(err, key)
+	}
+	conn.Close()
+	return
+}
+
+// RcmdCache get ai cache data from cache
+func (d *Dao) RcmdCache(c context.Context) (is []*ai.Item, err error) {
+	var r *memcache.Item
+	conn := d.mc.Get(c)
+	key := keyRcmd()
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrap(err, key)
+		return
+	}
+	if err = conn.Scan(r, &is); err != nil {
+		err = errors.Wrapf(err, "%s", r.Value)
+	}
+	return
+}
+
+// AddFollowModeListCache is.
+func (d *Dao) AddFollowModeListCache(c context.Context, list map[int64]struct{}) (err error) {
+	conn := d.mc.Get(c)
+	key := keyFollowModeList()
+	item := &memcache.Item{Key: key, Object: list, Flags: memcache.FlagJSON, Expiration: d.expireMc}
+	if err = conn.Set(item); err != nil {
+		err = errors.Wrap(err, key)
+	}
+	conn.Close()
+	return
+}
+
+// FollowModeListCache is.
+func (d *Dao) FollowModeListCache(c context.Context) (list map[int64]struct{}, err error) {
+	var r *memcache.Item
+	conn := d.mc.Get(c)
+	key := keyFollowModeList()
+	defer conn.Close()
+	if r, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		err = errors.Wrap(err, key)
+		return
+	}
+	if err = conn.Scan(r, &list); err != nil {
+		err = errors.Wrapf(err, "%s", r.Value)
+	}
+	return
+}

app/interface/main/app-feed/dao/recommend/memcache_test.go

@@ -0,0 +1,60 @@
+package recommend
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/app-card/model/card/ai"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAddRcmdAidsCache(t *testing.T) {
+	var (
+		c    = context.TODO()
+		aids = []int64{1}
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		err := d.AddRcmdAidsCache(c, aids)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestRcmdAidsCache(t *testing.T) {
+	var (
+		c = context.TODO()
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, err := d.RcmdAidsCache(c)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestAddRcmdCache(t *testing.T) {
+	var (
+		c  = context.TODO()
+		is = []*ai.Item{}
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		err := d.AddRcmdCache(c, is)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestRcmdCache(t *testing.T) {
+	var (
+		c = context.TODO()
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, err := d.RcmdCache(c)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}

app/interface/main/app-feed/dao/recommend/redis.go

@@ -0,0 +1,46 @@
+package recommend
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/library/cache/redis"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_prefixPos = "p_"
+)
+
+func keyPos(mid int64) string {
+	return _prefixPos + strconv.FormatInt(mid%100000, 10)
+}
+
+func (d *Dao) PositionCache(c context.Context, mid int64) (pos int, err error) {
+	var (
+		key  = keyPos(mid)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if pos, err = redis.Int(conn.Do("HGET", key, mid)); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "conn.Do(HGET,%s,%d)", key, mid)
+	}
+	return
+}
+
+func (d *Dao) AddPositionCache(c context.Context, mid int64, pos int) (err error) {
+	var (
+		key  = keyPos(mid)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if _, err = conn.Do("HSET", key, mid, pos); err != nil {
+		err = errors.Wrapf(err, "conn.Do(HSET,%s,%d,%d)", key, mid, pos)
+	}
+	return
+}

app/interface/main/app-feed/dao/recommend/redis_test.go

@@ -0,0 +1,35 @@
+package recommend
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestPositionCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		_, err := d.PositionCache(c, mid)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestAddPositionCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		pos = int(1)
+	)
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		err := d.AddPositionCache(c, mid, pos)
+		ctx.Convey("Then err should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}

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

@@ -0,0 +1,48 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//app/service/main/relation/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-feed/dao/relation",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-feed/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-feed/dao/relation/dao.go

@@ -0,0 +1,35 @@
+package relation
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-feed/conf"
+	relation "go-common/app/service/main/relation/model"
+	relrpc "go-common/app/service/main/relation/rpc/client"
+
+	"github.com/pkg/errors"
+)
+
+// Dao is rpc dao.
+type Dao struct {
+	// relation rpc
+	relRPC *relrpc.Service
+}
+
+// New new a relation dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// relation rpc
+		relRPC: relrpc.New(c.RelationRPC),
+	}
+	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.relRPC.Stats(ctx, arg); err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

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

@@ -0,0 +1,59 @@
+package relation
+
+import (
+	. "github.com/smartystreets/goconvey/convey"
+
+	"context"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/conf"
+	relation "go-common/app/service/main/relation/model"
+)
+
+func TestNew(t *testing.T) {
+	type args struct {
+		c *conf.Config
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantD *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotD := New(tt.args.c)
+			So(gotD, ShouldEqual, tt.wantD)
+		})
+	}
+}
+
+func TestDao_Stats(t *testing.T) {
+	type args struct {
+		ctx  context.Context
+		mids []int64
+	}
+	tests := []struct {
+		name    string
+		d       *Dao
+		args    args
+		wantRes map[int64]*relation.Stat
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotRes, err := tt.d.Stats(tt.args.ctx, tt.args.mids)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.Stats() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("Dao.Stats() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}

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

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

@@ -0,0 +1,55 @@
+package resource
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/app/service/main/resource/model"
+	rscrpc "go-common/app/service/main/resource/rpc/client"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+type Dao struct {
+	c *conf.Config
+	// rpc
+	rscRPC *rscrpc.Service
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c: c,
+		// rpc
+		rscRPC: rscrpc.New(c.ResourceRPC),
+	}
+	return
+}
+
+func (d *Dao) Banner(c context.Context, plat int8, build int, mid int64, resIDs, channel, buvid, network, mobiApp, device string, isAd bool, openEvent, adExtra, hash string) (res map[int][]*model.Banner, version string, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &model.ArgBanner{Plat: plat, ResIDs: resIDs, Build: build, MID: mid, Channel: channel, IP: ip, Buvid: buvid, Network: network, MobiApp: mobiApp, Device: device, IsAd: isAd, OpenEvent: openEvent, AdExtra: adExtra, Version: hash}
+	bs, err := d.rscRPC.Banners(c, arg)
+	if err != nil {
+		err = errors.Wrapf(err, "%v", arg)
+		return
+	}
+	if bs != nil {
+		res = bs.Banner
+		version = bs.Version
+	}
+	return
+}
+
+// AbTest resource abtest
+func (d *Dao) AbTest(ctx context.Context, groups string) (res map[string]*model.AbTest, err error) {
+	arg := &model.ArgAbTest{
+		Groups: groups,
+	}
+	if res, err = d.rscRPC.AbTest(ctx, arg); err != nil {
+		log.Error("resource d.resRpc.AbTest error(%v)", err)
+		return
+	}
+	return
+}

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

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

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

@@ -0,0 +1,68 @@
+package search
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/app/interface/main/app-feed/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 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("rec_type", "up_rec")
+	params.Set("pagesize", "3")
+	params.Set("service_area", "pegasus")
+	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-feed/dao/search/search_test.go

@@ -0,0 +1,34 @@
+package search
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestGetAudios(t *testing.T) {
+	Convey("get GetAudios all", t, func() {
+		res, trackID, err := d.Follow(context.Background(), "ios", "iphone", "phone", "xxx", 1, 1)
+		So(res, ShouldNotBeEmpty)
+		So(trackID, ShouldNotBeEmpty)
+		So(err, ShouldBeNil)
+	})
+}

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

@@ -0,0 +1,61 @@
+package show
+
+import (
+	"context"
+	"net/url"
+
+	"go-common/app/interface/main/app-card/model/card/show"
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_getCard = "/api/ticket/project/getcard"
+)
+
+// Dao is show dao.
+type Dao struct {
+	// http client
+	client *httpx.Client
+	// live
+	getCard string
+}
+
+// New new a bangumi dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// http client
+		client:  httpx.NewClient(c.HTTPShow),
+		getCard: c.Host.Show + _getCard,
+	}
+	return d
+}
+
+func (d *Dao) Card(c context.Context, ids []int64) (rs map[int64]*show.Shopping, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("id", xstr.JoinInts(ids))
+	params.Set("for", "1")
+	params.Set("price", "1")
+	var res struct {
+		Code int              `json:"errno"`
+		Data []*show.Shopping `json:"data"`
+	}
+	if err = d.client.Get(c, d.getCard, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(err, d.getCard+"?"+params.Encode())
+		return
+	}
+	rs = make(map[int64]*show.Shopping, len(res.Data))
+	for _, r := range res.Data {
+		rs[r.ID] = r
+	}
+	return
+}

app/interface/main/app-feed/dao/show/dao_test.go

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

app/interface/main/app-feed/dao/special/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 = ["special_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-card/model/card/operate:go_default_library",
+        "//app/interface/main/app-feed/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-feed/dao/special",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-card/model/card/operate:go_default_library",
+        "//app/interface/main/app-feed/conf: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-feed/dao/special/special.go

@@ -0,0 +1,53 @@
+package special
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-feed/conf"
+	"go-common/library/database/sql"
+)
+
+const (
+	_getSQL = "SELECT `id`,`title`,`desc`,`cover`,`scover`,`re_type`,`re_value`,`corner`,`size` 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, now time.Time) (scm map[int64]*operate.Special, err error) {
+	rows, err := d.specialGet.Query(c)
+	if err != nil {
+		return
+	}
+	defer rows.Close()
+	scm = map[int64]*operate.Special{}
+	for rows.Next() {
+		sc := &operate.Special{}
+		if err = rows.Scan(&sc.ID, &sc.Title, &sc.Desc, &sc.Cover, &sc.SingleCover, &sc.ReType, &sc.ReValue, &sc.Badge, &sc.Size); err != nil {
+			return
+		}
+		sc.Change()
+		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-feed/dao/special/special_test.go

@@ -0,0 +1,82 @@
+package special
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-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_Card(t *testing.T) {
+	type args struct {
+		c   context.Context
+		now time.Time
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantScm map[int64]*operate.Special
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotScm, err := d.Card(tt.args.c, tt.args.now)
+			So(gotScm, ShouldEqual, tt.wantScm)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_Close(t *testing.T) {
+	tests := []struct {
+		name string
+		d    *Dao
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.d.Close()
+		})
+	}
+}

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

@@ -0,0 +1,67 @@
+package tab
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-feed/conf"
+
+	"go-common/library/database/sql"
+)
+
+const (
+	_getAllMenuSQL   = "SELECT id,plat,name,ctype,cvalue,plat_ver,stime,etime,status,color,badge FROM app_menus ORDER BY `order`"
+	_getAllActiveSQL = "SELECT id,parent_id,name,background,type,content FROM app_active"
+)
+
+type Dao struct {
+	db        *sql.DB
+	menuGet   *sql.Stmt
+	activeGet *sql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	// prepare
+	d.menuGet = d.db.Prepared(_getAllMenuSQL)
+	d.activeGet = d.db.Prepared(_getAllActiveSQL)
+	return
+}
+
+func (d *Dao) Menus(c context.Context) (menus []*operate.Menu, err error) {
+	var rows *sql.Rows
+	if rows, err = d.menuGet.Query(c); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		m := &operate.Menu{}
+		if err = rows.Scan(&m.TabID, &m.Plat, &m.Name, &m.CType, &m.CValue, &m.PlatVersion, &m.STime, &m.ETime, &m.Status, &m.Color, &m.Badge); err != nil {
+			return
+		}
+		if m.CValue != "" {
+			m.Change()
+			menus = append(menus, m)
+		}
+	}
+	return
+}
+
+func (d *Dao) Actives(c context.Context) (acs []*operate.Active, err error) {
+	var rows *sql.Rows
+	if rows, err = d.activeGet.Query(c); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		ac := &operate.Active{}
+		if err = rows.Scan(&ac.ID, &ac.ParentID, &ac.Name, &ac.Background, &ac.Type, &ac.Content); err != nil {
+			return
+		}
+		ac.Change()
+		acs = append(acs, ac)
+	}
+	return
+}

app/interface/main/app-feed/dao/tab/dao_test.go

@@ -0,0 +1,90 @@
+package tab
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-feed/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-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_Menus(t *testing.T) {
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name      string
+		args      args
+		wantMenus []*operate.Menu
+		wantErr   bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotMenus, err := d.Menus(tt.args.c)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.Menus() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotMenus, tt.wantMenus) {
+				t.Errorf("Dao.Menus() = %v, want %v", gotMenus, tt.wantMenus)
+			}
+		})
+	}
+}
+
+func TestDao_Actives(t *testing.T) {
+	type args struct {
+		c context.Context
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantAcs []*operate.Active
+		wantErr error
+	}{}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotAcs, err := d.Actives(tt.args.c)
+			So(err, ShouldEqual, tt.wantErr)
+			So(gotAcs, ShouldResemble, tt.wantAcs)
+		})
+	}
+}

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

@@ -0,0 +1,59 @@
+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-feed/conf:go_default_library",
+        "//app/interface/main/app-feed/model/tag:go_default_library",
+        "//app/interface/main/tag/model: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-feed/dao/tag",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//app/interface/main/app-feed/model/tag:go_default_library",
+        "//app/interface/main/tag/model:go_default_library",
+        "//app/interface/main/tag/rpc/client:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/app-feed/dao/tag/api.go

@@ -0,0 +1,138 @@
+package tag
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-feed/model/tag"
+	"go-common/library/ecode"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_hot    = "/x/internal/tag/hots"
+	_add    = "/x/internal/tag/subscribe/add"
+	_cancel = "/x/internal/tag/subscribe/cancel"
+	_tags   = "/x/internal/tag/archive/multi/tags"
+	_detail = "/x/internal/tag/detail"
+)
+
+// Hots.
+func (d *Dao) Hots(c context.Context, mid int64, rid int16, now time.Time) (hs []*tag.Hot, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("rid", strconv.FormatInt(int64(rid), 10))
+	var res struct {
+		Code int        `json:"code"`
+		Data []*tag.Hot `json:"data"`
+	}
+	if err = d.client.Get(c, d.hot, "", params, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrap(code, d.hot+"?"+params.Encode())
+		return
+	}
+	hs = res.Data
+	return
+}
+
+func (d *Dao) Add(c context.Context, mid, tid int64, now time.Time) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("tag_id", strconv.FormatInt(tid, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.add, "", params, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		if code.Equal(ecode.TagTagIsSubed) {
+			return
+		}
+		if code.Equal(ecode.TagMaxSub) {
+			err = code
+			return
+		}
+		err = errors.Wrap(code, d.add+"?"+params.Encode())
+		return
+	}
+	return
+}
+
+func (d *Dao) Cancel(c context.Context, mid, tid int64, now time.Time) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("tag_id", strconv.FormatInt(tid, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.cancel, "", params, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		if code.Equal(ecode.TagNotSub) {
+			return
+		}
+		err = errors.Wrap(code, d.cancel+"?"+params.Encode())
+		return
+	}
+	return
+}
+
+func (d *Dao) Tags(c context.Context, mid int64, aids []int64, now time.Time) (tagm map[string][]*tag.Tag, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("aids", xstr.JoinInts(aids))
+	var res struct {
+		Code int                   `json:"code"`
+		Data map[string][]*tag.Tag `json:"data"`
+	}
+	if err = d.client.Get(c, d.tags, "", params, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrap(code, d.tags+"?"+params.Encode())
+		return
+	}
+	tagm = res.Data
+	return
+}
+
+func (d *Dao) Detail(c context.Context, tagID int, pn, ps int, now time.Time) (arcids []int64, err error) {
+	params := url.Values{}
+	params.Set("tag_id", strconv.Itoa(tagID))
+	params.Set("pn", strconv.Itoa(pn))
+	params.Set("ps", strconv.Itoa(ps))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			News struct {
+				Archives []struct {
+					Aid int64 `json:"aid"`
+				} `json:"archives"`
+			} `json:"news"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.detail, "", params, &res); err != nil {
+		return
+	}
+	code := ecode.Int(res.Code)
+	if !code.Equal(ecode.OK) {
+		err = errors.Wrap(code, d.detail+"?"+params.Encode())
+		return
+	}
+	for _, arcs := range res.Data.News.Archives {
+		arcids = append(arcids, arcs.Aid)
+	}
+	return
+}

app/interface/main/app-feed/dao/tag/api_test.go

@@ -0,0 +1,145 @@
+package tag
+
+import (
+	"context"
+	"reflect"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-feed/model/tag"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_Hots(t *testing.T) {
+	type args struct {
+		c   context.Context
+		mid int64
+		rid int16
+		now time.Time
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantHs  []*tag.Hot
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotHs, err := d.Hots(tt.args.c, tt.args.mid, tt.args.rid, tt.args.now)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.Hots() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotHs, tt.wantHs) {
+				t.Errorf("Dao.Hots() = %v, want %v", gotHs, tt.wantHs)
+			}
+		})
+	}
+}
+
+func TestDao_Add(t *testing.T) {
+	type args struct {
+		c   context.Context
+		mid int64
+		tid int64
+		now time.Time
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			err := d.Add(tt.args.c, tt.args.mid, tt.args.tid, tt.args.now)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_Cancel(t *testing.T) {
+	type args struct {
+		c   context.Context
+		mid int64
+		tid int64
+		now time.Time
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := d.Cancel(tt.args.c, tt.args.mid, tt.args.tid, tt.args.now); (err != nil) != tt.wantErr {
+				t.Errorf("Dao.Cancel() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestDao_Tags(t *testing.T) {
+	type args struct {
+		c    context.Context
+		mid  int64
+		aids []int64
+		now  time.Time
+	}
+	tests := []struct {
+		name     string
+		args     args
+		wantTagm map[string][]*tag.Tag
+		wantErr  bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotTagm, err := d.Tags(tt.args.c, tt.args.mid, tt.args.aids, tt.args.now)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.Tags() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotTagm, tt.wantTagm) {
+				t.Errorf("Dao.Tags() = %v, want %v", gotTagm, tt.wantTagm)
+			}
+		})
+	}
+}
+
+func TestDao_Detail(t *testing.T) {
+	type args struct {
+		c     context.Context
+		tagID int
+		pn    int
+		ps    int
+		now   time.Time
+	}
+	tests := []struct {
+		name       string
+		args       args
+		wantArcids []int64
+		wantErr    bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotArcids, err := d.Detail(tt.args.c, tt.args.tagID, tt.args.pn, tt.args.ps, tt.args.now)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.Detail() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotArcids, tt.wantArcids) {
+				t.Errorf("Dao.Detail() = %v, want %v", gotArcids, tt.wantArcids)
+			}
+		})
+	}
+}

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

@@ -0,0 +1,71 @@
+package tag
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-feed/conf"
+	tag "go-common/app/interface/main/tag/model"
+	tagrpc "go-common/app/interface/main/tag/rpc/client"
+	"go-common/library/ecode"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+type Dao struct {
+	// conf
+	// http client
+	hot    string
+	add    string
+	cancel string
+	tags   string
+	detail string
+	client *httpx.Client
+	tagRPC *tagrpc.Service
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPTag),
+		hot:    c.Host.APICo + _hot,
+		add:    c.Host.APICo + _add,
+		cancel: c.Host.APICo + _cancel,
+		tags:   c.Host.APICo + _tags,
+		detail: c.Host.APICo + _detail,
+		tagRPC: tagrpc.New2(c.TagRPC),
+	}
+	return
+}
+
+func (d *Dao) InfoByIDs(c context.Context, mid int64, tids []int64) (tm map[int64]*tag.Tag, err error) {
+	var ts []*tag.Tag
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &tag.ArgIDs{IDs: tids, Mid: mid, RealIP: ip}
+	if ts, err = d.tagRPC.InfoByIDs(c, arg); err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "%v", arg)
+		return
+	}
+	tm = make(map[int64]*tag.Tag, len(ts))
+	for _, t := range ts {
+		tm[t.ID] = t
+	}
+	return
+}
+
+func (d *Dao) SubTags(c context.Context, mid, vmid int64, pn, ps int) (sub *tag.Sub, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	arg := &tag.ArgSub{Mid: mid, Vmid: vmid, Pn: pn, Ps: ps, RealIP: ip}
+	if sub, err = d.tagRPC.SubTags(c, arg); err != nil {
+		if err == ecode.NothingFound {
+			err = nil
+			return
+		}
+		err = errors.Wrapf(err, "%v", arg)
+	}
+	return
+}

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

@@ -0,0 +1,98 @@
+package tag
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"go-common/app/interface/main/app-feed/conf"
+	tag "go-common/app/interface/main/tag/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-feed-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_InfoByIDs(t *testing.T) {
+	type args struct {
+		c    context.Context
+		mid  int64
+		tids []int64
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantTm  map[int64]*tag.Tag
+		wantErr error
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		Convey(tt.name, t, func() {
+			gotTm, err := d.InfoByIDs(tt.args.c, tt.args.mid, tt.args.tids)
+			So(gotTm, ShouldEqual, tt.wantTm)
+			So(err, ShouldEqual, tt.wantErr)
+		})
+	}
+}
+
+func TestDao_SubTags(t *testing.T) {
+	type args struct {
+		c    context.Context
+		mid  int64
+		vmid int64
+		pn   int
+		ps   int
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantSub *tag.Sub
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotSub, err := d.SubTags(tt.args.c, tt.args.mid, tt.args.vmid, tt.args.pn, tt.args.ps)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Dao.SubTags() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotSub, tt.wantSub) {
+				t.Errorf("Dao.SubTags() = %v, want %v", gotSub, tt.wantSub)
+			}
+		})
+	}
+}

app/interface/main/app-feed/dao/upper/BUILD

@@ -0,0 +1,59 @@
+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",
+        "redis_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "redis.go",
+    ],
+    importpath = "go-common/app/interface/main/app-feed/dao/upper",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-feed/conf:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/feed/model:go_default_library",
+        "//app/service/main/feed/rpc/client:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log: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"],
+)