Create & Init Project...

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

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

@@ -0,0 +1,110 @@
+package abtest
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/experiment"
+	"go-common/library/database/sql"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_selExpLimit = `SELECT experiment_id,build,conditions FROM experiment_limit`
+	_selExpByIDs = `SELECT id,name,plat,strategy,description,traffic_group FROM experiment WHERE state=1 AND id IN (%s) ORDER BY uptime DESC`
+)
+
+// Dao is notice dao.
+type Dao struct {
+	db       *sql.DB
+	limit    *sql.Stmt
+	dataPath string
+	client   *bm.Client
+}
+
+// New new a notice dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db:       sql.NewMySQL(c.MySQL.Show),
+		client:   bm.NewClient(conf.Conf.HTTPClient),
+		dataPath: c.Host.Data + "/abserver/v1/app/match-exp",
+	}
+	d.limit = d.db.Prepared(_selExpLimit)
+	return
+}
+
+func (d *Dao) ExperimentLimit(c context.Context) (lm map[int64][]*experiment.Limit, err error) {
+	rows, err := d.limit.Query(c)
+	if err != nil {
+		log.Error("d.limit.Query error (%v)", err)
+		return
+	}
+	defer rows.Close()
+	lm = map[int64][]*experiment.Limit{}
+	for rows.Next() {
+		limit := &experiment.Limit{}
+		if err = rows.Scan(&limit.ExperimentID, &limit.Build, &limit.Condition); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			continue
+		}
+		lm[limit.ExperimentID] = append(lm[limit.ExperimentID], limit)
+	}
+	return
+}
+
+func (d *Dao) ExperimentByIDs(c context.Context, ids []int64) (eps []*experiment.Experiment, err error) {
+	rows, err := d.db.Query(c, fmt.Sprintf(_selExpByIDs, xstr.JoinInts(ids)))
+	if err != nil {
+		log.Error("d.expByIDs.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		ep := &experiment.Experiment{}
+		if err = rows.Scan(&ep.ID, &ep.Name, &ep.Plat, &ep.Strategy, &ep.Desc, &ep.TrafficGroup); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			continue
+		}
+		eps = append(eps, ep)
+	}
+	return
+}
+
+// AbServer  http://info.bilibili.co/pages/viewpage.action?pageId=8741843 大数据abtest
+func (d *Dao) AbServer(c context.Context, buvid, device, mobiAPP, filteredStr string, build int, mid int64) (res json.RawMessage, err error) {
+	params := url.Values{}
+	params.Set("buvid", buvid)
+	params.Set("device", device)
+	params.Set("mobi_app", mobiAPP)
+	params.Set("build", strconv.Itoa(build))
+	if mid > 0 {
+		params.Set("mid", strconv.FormatInt(mid, 10))
+	}
+	if filteredStr != "" {
+		params.Set("filtered", filteredStr)
+	}
+	var data struct {
+		Code int `json:"errorCode"`
+	}
+	if err = d.client.Get(c, d.dataPath, "", params, &res); err != nil {
+		return
+	}
+	if err = json.Unmarshal(res, &data); err != nil {
+		err = errors.Wrap(err, "json.Unmarshal")
+		return
+	}
+	if data.Code != ecode.OK.Code() {
+		log.Warn("code(%d) path:(%s)", data.Code, d.dataPath+params.Encode())
+		return
+	}
+	return
+}

app/interface/main/app-resource/dao/abtest/abtest_test.go

@@ -0,0 +1,59 @@
+package abtest
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-resource-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func TestExperimentLimit(t *testing.T) {
+	Convey("get ExperimentLimit all", t, func() {
+		res, err := d.ExperimentLimit(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestExperimentByIDs(t *testing.T) {
+	Convey("get ExperimentByIDs all", t, func() {
+		res, err := d.ExperimentByIDs(ctx(), []int64{1})
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestAbServer(t *testing.T) {
+	Convey("TestAbServer", t, func() {
+		res, err := d.AbServer(context.TODO(),
+			"9902822F-DDD1-47BC-A08F-19F746C9CB8459220infoc",
+			"phone",
+			"iphone",
+			"",
+			6720,
+			1,
+		)
+		Println(string(res), err)
+	})
+}

app/interface/main/app-resource/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 = ["ad_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["ad.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/ad",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/splash: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",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

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

@@ -0,0 +1,121 @@
+package ad
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/splash"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+const (
+	_splashListURL = "/bce/api/splash/list"
+	_splashShowURL = "/bce/api/splash/show"
+)
+
+// Dao is advertising dao.
+type Dao struct {
+	client        *httpx.Client
+	splashListURL string
+	splashShowURL string
+}
+
+// New advertising dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client:        httpx.NewClient(conf.Conf.HTTPClient),
+		splashListURL: c.Host.Ad + _splashListURL,
+		splashShowURL: c.Host.Ad + _splashShowURL,
+	}
+	return
+}
+
+// SplashList ad splash list
+func (d *Dao) SplashList(c context.Context, mobiApp, device, buvid, birth, adExtra string, height, width, build int, mid int64) (res []*splash.List, config *splash.CmConfig, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("build", strconv.Itoa(build))
+	params.Set("buvid", buvid)
+	params.Set("mobi_app", mobiApp)
+	params.Set("device", device)
+	params.Set("ip", ip)
+	params.Set("height", strconv.Itoa(height))
+	params.Set("width", strconv.Itoa(width))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	if birth != "" {
+		params.Set("birth", birth)
+	}
+	if adExtra != "" {
+		params.Set("ad_extra", adExtra)
+	}
+	var data struct {
+		Code int `json:"code"`
+		*splash.CmConfig
+		RequestID string         `json:"request_id"`
+		Data      []*splash.List `json:"data"`
+	}
+	if err = d.client.Get(c, d.splashListURL, ip, params, &data); err != nil {
+		log.Error("cpm splash url(%s) error(%v)", d.splashListURL+"?"+params.Encode(), err)
+		return
+	}
+	b, _ := json.Marshal(&data)
+	log.Info("cpm splash list url(%s) response(%s)", d.splashListURL+"?"+params.Encode(), b)
+	if data.Code != 0 {
+		err = ecode.Int(data.Code)
+		log.Error("cpm splash url(%s) code(%d)", d.splashListURL+"?"+params.Encode(), data.Code)
+		return
+	}
+	for _, t := range data.Data {
+		s := &splash.List{}
+		*s = *t
+		s.RequestID = data.RequestID
+		s.ClientIP = ip
+		s.IsAdLoc = true
+		res = append(res, s)
+	}
+	config = data.CmConfig
+	return
+}
+
+// SplashShow ad splash show
+func (d *Dao) SplashShow(c context.Context, mobiApp, device, buvid, birth, adExtra string, height, width, build int, mid int64) (res []*splash.Show, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("build", strconv.Itoa(build))
+	params.Set("buvid", buvid)
+	params.Set("mobi_app", mobiApp)
+	params.Set("device", device)
+	params.Set("ip", ip)
+	params.Set("height", strconv.Itoa(height))
+	params.Set("width", strconv.Itoa(width))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	if birth != "" {
+		params.Set("birth", birth)
+	}
+	if adExtra != "" {
+		params.Set("ad_extra", adExtra)
+	}
+	var data struct {
+		Code int            `json:"code"`
+		Data []*splash.Show `json:"data"`
+	}
+	if err = d.client.Get(c, d.splashShowURL, ip, params, &data); err != nil {
+		log.Error("cpm splash url(%s) error(%v)", d.splashShowURL+"?"+params.Encode(), err)
+		return
+	}
+	b, _ := json.Marshal(&data)
+	log.Info("cpm splash show url(%s) response(%s)", d.splashShowURL+"?"+params.Encode(), b)
+	if data.Code != 0 {
+		err = ecode.Int(data.Code)
+		log.Error("cpm splash url(%s) code(%d)", d.splashShowURL+"?"+params.Encode(), data.Code)
+		return
+	}
+	res = data.Data
+	return
+}

app/interface/main/app-resource/dao/ad/ad_test.go

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

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

@@ -0,0 +1,65 @@
+package audit
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_auditSQL = "SELECT mobi_app,build FROM audit"
+)
+
+// Dao is notice dao.
+type Dao struct {
+	db    *sql.DB
+	audit *sql.Stmt
+}
+
+// New new a notice dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	d.audit = d.db.Prepared(_auditSQL)
+	return
+}
+
+// Audits get all audit build.
+func (d *Dao) Audits(ctx context.Context) (res map[string]map[int]struct{}, err error) {
+	rows, err := d.audit.Query(ctx)
+	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
+}
+
+// Close close memcache resource.
+func (dao *Dao) Close() {
+	if dao.db != nil {
+		dao.db.Close()
+	}
+}

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

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

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

@@ -0,0 +1,61 @@
+package bplus
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_checkUser = "/promo_svr/v0/promo_svr/inner_user_check"
+)
+
+// Dao bplus
+type Dao struct {
+	client *httpx.Client
+	// url
+	checkUserURL string
+}
+
+// New bplus
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPClient),
+		// url
+		checkUserURL: c.Host.VC + _checkUser,
+	}
+	return
+}
+
+// UserCheck 动态互推入口白名单
+func (d *Dao) UserCheck(c context.Context, mid int64) (ok bool, err error) {
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Status int `json:"status"`
+		}
+	}
+	if err = d.client.Get(c, d.checkUserURL, "", params, &res); err != nil {
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("UserCheck url(%s) response(%s)", d.checkUserURL+"?"+params.Encode(), b)
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.checkUserURL+"?"+params.Encode())
+		return
+	}
+	if res.Data.Status == 1 {
+		ok = true
+	}
+	return
+}

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

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

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

@@ -0,0 +1,41 @@
+package broadcast
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/app-resource/conf"
+	pb "go-common/app/service/main/broadcast/api/grpc/v1"
+	warden "go-common/app/service/main/broadcast/api/grpc/v1"
+	wardenclient "go-common/app/service/main/broadcast/api/grpc/v1"
+	"go-common/library/log"
+)
+
+type Dao struct {
+	c *conf.Config
+	// grpc
+	rpcClient pb.ZergClient
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c: c,
+	}
+	var err error
+	if d.rpcClient, err = wardenclient.NewClient(c.BroadcastRPC); err != nil {
+		panic(fmt.Sprintf("BroadcastRPC warden.NewClient error (%+v)", err))
+	}
+	return
+}
+
+// ServerList warden server list
+func (d *Dao) ServerList(ctx context.Context, platform string) (res *warden.ServerListReply, err error) {
+	arg := &warden.ServerListReq{
+		Platform: platform,
+	}
+	if res, err = d.rpcClient.ServerList(ctx, arg); err != nil {
+		log.Error("d.rpcClient.ServerList error(%v)", err)
+		return
+	}
+	return
+}

app/interface/main/app-resource/dao/broadcast/broadcast_test.go

@@ -0,0 +1,48 @@
+package broadcast
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-resource/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-resource")
+		flag.Set("conf_token", "z8JNX5MFIyDxyBsqwQyF6pnjWQ5YOA14")
+		flag.Set("tree_id", "2722")
+		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 TestServerList(t *testing.T) {
+	Convey("get ServerList all", t, func() {
+		_, err := d.ServerList(ctx(), "ios")
+		So(err, ShouldBeNil)
+	})
+}

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

@@ -0,0 +1,34 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["egg.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/egg",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/static: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-resource/dao/egg/egg.go

@@ -0,0 +1,52 @@
+package egg
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/static"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_eggSQL = `SELECT e.id,ep.plat,ep.conditions,ep.build,ep.url,ep.md5,ep.size FROM egg AS e,egg_plat AS ep 
+	WHERE e.id=ep.egg_id AND e.stime<? AND e.etime>? AND e.publish=1 AND e.delete=0 AND ep.deleted=0`
+)
+
+type Dao struct {
+	db *xsql.DB
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: xsql.NewMySQL(c.MySQL.Show),
+	}
+	return
+}
+
+// Egg select all egg
+func (d *Dao) Egg(ctx context.Context, now time.Time) (res map[int8][]*static.Static, err error) {
+	res = map[int8][]*static.Static{}
+	rows, err := d.db.Query(ctx, _eggSQL, now, now)
+	if err != nil {
+		log.Error("mysqlDB.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		s := &static.Static{}
+		if err = rows.Scan(&s.Sid, &s.Plat, &s.Condition, &s.Build, &s.URL, &s.Hash, &s.Size); err != nil {
+			log.Error("egg rows.Scan error(%v)", err)
+			return
+		}
+		if s.URL == "" {
+			continue
+		}
+		s.StaticChange()
+		res[s.Plat] = append(res[s.Plat], s)
+	}
+	err = rows.Err()
+	return
+}

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

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

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

@@ -0,0 +1,44 @@
+package location
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-resource-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)
+	})
+}
+
+func TestAuthPIDs(t *testing.T) {
+	Convey("get AuthPIDs", t, func() {
+		_, err := d.AuthPIDs(ctx(), "417,1521", "127.0.0.0")
+		So(err, ShouldBeNil)
+	})
+}

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

@@ -0,0 +1,135 @@
+package module
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/app/interface/main/app-resource/model/module"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_moduleDevSQL = `SELECT p.id,d.name FROM resource_department AS d,resource_pool AS p WHERE d.id=p.department_id AND d.is_deleted=0 AND p.action=1 AND p.deleted=0`
+	_moduleAllSQL = `SELECT rp.id,r.id,r.version,rp.name,rp.compresstype,rf.type,rf.url,rf.md5,rf.size,rf.file_type,rf.from_ver FROM resource_pool AS rp,resource AS r,resource_file AS rf 
+	WHERE rp.id=r.pool_id AND r.id=rf.resource_id ORDER BY rp.id ASC,r.version DESC,rf.from_ver DESC`
+	_resourceConfigSQL = `SELECT id,resource_id,stime,etime,valid,valid_test,default_package,is_wifi FROM resource_config WHERE is_deleted=0`
+	_resourceLimitSQL  = `SELECT l.config_id,l.column,l.condition,l.value FROM resource_limit AS l WHERE l.is_deleted=0`
+)
+
+// Dao is a module dao.
+type Dao struct {
+	db *sql.DB
+}
+
+// New new a module dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	return
+}
+
+// ModuleDev get modelu dev
+func (d *Dao) ModuleDev(ctx context.Context) (res map[string]*module.ResourcePool, err error) {
+	rows, err := d.db.Query(ctx, _moduleDevSQL)
+	if err != nil {
+		log.Error("d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = make(map[string]*module.ResourcePool)
+	for rows.Next() {
+		// NOTE: don't ask way the map key is "pink", stupid demand! fuck!!!
+		// rp := &module.ResourcePool{ID: 1, Name: "pink"}
+		r := &module.Resource{}
+		if err = rows.Scan(&r.ID, &r.Name); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		var (
+			resTmp *module.ResourcePool
+			ok     bool
+		)
+		if resTmp, ok = res[r.Name]; !ok {
+			resTmp = &module.ResourcePool{ID: r.ID, Name: r.Name}
+			res[r.Name] = resTmp
+		}
+		resTmp.Resources = append(resTmp.Resources, r)
+	}
+	return
+}
+
+// ModuleAll get module
+func (d *Dao) ModuleAll(ctx context.Context) (res map[int][]*module.Resource, err error) {
+	rows, err := d.db.Query(ctx, _moduleAllSQL)
+	if err != nil {
+		log.Error("d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = make(map[int][]*module.Resource)
+	for rows.Next() {
+		r := &module.Resource{}
+		if err = rows.Scan(&r.ID, &r.ResID, &r.Version, &r.Name, &r.Compresstype, &r.Type, &r.URL, &r.MD5, &r.Size, &r.Increment, &r.FromVer); err != nil {
+			log.Error("d.db.rows.Scan error(%v)", err)
+			return
+		}
+		r.URL = model.URLHTTPS(r.URL)
+		res[r.ID] = append(res[r.ID], r)
+	}
+	return
+}
+
+// ResourceCondition
+func (d *Dao) ResourceConfig(ctx context.Context) (conditions map[int]*module.Condition, err error) {
+	rows, err := d.db.Query(ctx, _resourceConfigSQL)
+	if err != nil {
+		log.Error("d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	conditions = make(map[int]*module.Condition)
+	for rows.Next() {
+		var (
+			condition = &module.Condition{}
+		)
+		if err = rows.Scan(&condition.ID, &condition.ResID, &condition.STime, &condition.ETime, &condition.Valid, &condition.ValidTest, &condition.Default, &condition.IsWifi); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		conditions[condition.ResID] = condition
+	}
+	return
+}
+
+// ResourceLimit
+func (d *Dao) ResourceLimit(ctx context.Context) (columns map[int]map[string][]*module.Column, err error) {
+	rows, err := d.db.Query(ctx, _resourceLimitSQL)
+	if err != nil {
+		log.Error("d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	columns = make(map[int]map[string][]*module.Column)
+	for rows.Next() {
+		var (
+			cid         int
+			column      = &module.Column{}
+			columnValue string
+			cm          map[string][]*module.Column
+			ok          bool
+		)
+		if err = rows.Scan(&cid, &columnValue, &column.Condition, &column.Value); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		if cm, ok = columns[cid]; !ok {
+			cm = make(map[string][]*module.Column)
+			columns[cid] = cm
+		}
+		cm[columnValue] = append(cm[columnValue], column)
+	}
+	return
+}

app/interface/main/app-resource/dao/module/module_test.go

@@ -0,0 +1,55 @@
+package module
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/app-resource/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-resource")
+		flag.Set("conf_token", "z8JNX5MFIyDxyBsqwQyF6pnjWQ5YOA14")
+		flag.Set("tree_id", "2722")
+		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 TestModuleAll(t *testing.T) {
+	Convey("get module all", t, func() {
+		_, err := d.ModuleAll(ctx())
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestModuleDev(t *testing.T) {
+	Convey("get resourcePool all", t, func() {
+		_, err := d.ModuleDev(ctx())
+		So(err, ShouldBeNil)
+	})
+}

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

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

@@ -0,0 +1,58 @@
+package notice
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/notice"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getSQL = `SELECT id,plat,title,content,build,conditions,area,url,type,ef_time,ex_time FROM notice WHERE state=1 AND ef_time<? AND ex_time>? ORDER BY mtime DESC`
+)
+
+// Dao is notice dao.
+type Dao struct {
+	db  *sql.DB
+	get *sql.Stmt
+}
+
+// New new a notice dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	d.get = d.db.Prepared(_getSQL)
+	return
+}
+
+// GetAll get all notice data.
+func (d *Dao) All(ctx context.Context, now time.Time) (res []*notice.Notice, err error) {
+	rows, err := d.get.Query(ctx, now, now)
+	if err != nil {
+		log.Error("query error (%v)", err)
+		return
+	}
+	defer rows.Close()
+	res = []*notice.Notice{}
+	for rows.Next() {
+		b := &notice.Notice{}
+		if err = rows.Scan(&b.ID, &b.Plat, &b.Title, &b.Content, &b.Build, &b.Condition, &b.Area, &b.URI, &b.Type, &b.Start, &b.End); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			return nil, err
+
+		}
+		res = append(res, b)
+	}
+	return
+}
+
+// Close close memcache resource.
+func (dao *Dao) Close() {
+	if dao.db != nil {
+		dao.db.Close()
+	}
+}

app/interface/main/app-resource/dao/notice/notice_test.go

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

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

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

@@ -0,0 +1,62 @@
+package param
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/param"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	// get param key and value
+	_getAllSQL = "SELECT name,value,plat,build,conditions FROM param WHERE state=0 AND plat!=9"
+)
+
+// Dao is a param dao.
+type Dao struct {
+	db  *sql.DB
+	get *sql.Stmt
+}
+
+// New new a param dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	// prepare
+	d.get = d.db.Prepared(_getAllSQL)
+	return
+}
+
+// All get all param
+func (d *Dao) All(ctx context.Context) (m map[string][]*param.Param, err error) {
+	rows, err := d.get.Query(ctx)
+	if err != nil {
+		log.Error("d.get error(%v)", err)
+		return nil, err
+	}
+	defer rows.Close()
+	m = map[string][]*param.Param{}
+	var _key = "param_%d"
+	for rows.Next() {
+		p := &param.Param{}
+		if err = rows.Scan(&p.Name, &p.Value, &p.Plat, &p.Build, &p.Condition); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return nil, err
+		}
+		p.Change()
+		key := fmt.Sprintf(_key, p.Plat)
+		m[key] = append(m[key], p)
+	}
+	return
+}
+
+// Close close memcache resource.
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}

app/interface/main/app-resource/dao/param/param_test.go

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

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

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

@@ -0,0 +1,61 @@
+package plugin
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/plugin"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getSQL = "SELECT `name`,`package`,`policy`,`ver_code`,`ver_name`,`size`,`md5`,`url`,`enable`,`force`,`clear`,`min_build`,`max_build`,`base_code`,`base_name`,`desc`,`coverage` FROM plugin WHERE `enable`=1 AND `state`=0"
+)
+
+type Dao struct {
+	db        *sql.DB
+	pluginGet *sql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	// prepare
+	d.pluginGet = d.db.Prepared(_getSQL)
+	return
+}
+
+func (d *Dao) All(c context.Context) (psm map[string][]*plugin.Plugin, err error) {
+	rows, err := d.pluginGet.Query(c)
+	if err != nil {
+		log.Error("query error(%v)", err)
+		return nil, err
+	}
+	defer rows.Close()
+	psm = map[string][]*plugin.Plugin{}
+	for rows.Next() {
+		p := &plugin.Plugin{}
+		if err = rows.Scan(&p.Name, &p.Package, &p.Policy, &p.VerCode, &p.VerName, &p.Size, &p.MD5, &p.URL, &p.Enable, &p.Force, &p.Clear, &p.MinBuild, &p.MaxBuild, &p.BaseCode, &p.BaseName, &p.Desc, &p.Coverage); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return nil, err
+		}
+		if p.MaxBuild != 0 && p.MaxBuild < p.MinBuild {
+			continue
+		}
+		psm[p.Name] = append(psm[p.Name], p)
+	}
+	return psm, err
+}
+
+// Close close memcache resource.
+func (dao *Dao) Close() {
+	if dao.db != nil {
+		dao.db.Close()
+	}
+}
+
+func (dao *Dao) PingDB(c context.Context) (err error) {
+	return dao.db.Ping(c)
+}

app/interface/main/app-resource/dao/plugin/plugin_test.go

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

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

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

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

@@ -0,0 +1,46 @@
+package resource
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	resource "go-common/app/service/main/resource/model"
+	resrpc "go-common/app/service/main/resource/rpc/client"
+	"go-common/library/log"
+)
+
+type Dao struct {
+	c *conf.Config
+	// rpc
+	resRpc *resrpc.Service
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c: c,
+		// rpc
+		resRpc: resrpc.New(c.ResourceRPC),
+	}
+	return
+}
+
+// ResSideBar resource ressidebar
+func (d *Dao) ResSideBar(ctx context.Context) (res *resource.SideBars, err error) {
+	if res, err = d.resRpc.SideBars(ctx); err != nil {
+		log.Error("resource d.resRpc.SideBars error(%v)", err)
+		return
+	}
+	return
+}
+
+// AbTest resource abtest
+func (d *Dao) AbTest(ctx context.Context, groups string) (res map[string]*resource.AbTest, err error) {
+	arg := &resource.ArgAbTest{
+		Groups: groups,
+	}
+	if res, err = d.resRpc.AbTest(ctx, arg); err != nil {
+		log.Error("resource d.resRpc.AbTest error(%v)", err)
+		return
+	}
+	return
+}

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

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

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

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

@@ -0,0 +1,67 @@
+package sidebar
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/sidebar"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_initSidebarKey = "sidebar_%d_%d"
+	_selSideSQL     = `SELECT s.id,s.plat,s.module,s.name,s.logo,s.logo_white,s.param,s.rank,l.build,l.conditions,s.tip FROM 
+		sidebar AS s,sidebar_limit AS l WHERE s.state=1 AND s.id=l.s_id AND s.online_time<? ORDER BY s.rank DESC,l.id ASC`
+)
+
+type Dao struct {
+	db  *xsql.DB
+	get *xsql.Stmt
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: xsql.NewMySQL(c.MySQL.Show),
+	}
+	d.get = d.db.Prepared(_selSideSQL)
+	return
+}
+
+// SideBar
+func (d *Dao) SideBar(ctx context.Context, now time.Time) (ss map[string][]*sidebar.SideBar, limits map[int64][]*sidebar.Limit, err error) {
+	ss = map[string][]*sidebar.SideBar{}
+	limits = map[int64][]*sidebar.Limit{}
+	rows, err := d.get.Query(ctx, now)
+	if err != nil {
+		log.Error("mysqlDB.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		s := &sidebar.SideBar{}
+		if err = rows.Scan(&s.ID, &s.Plat, &s.Module, &s.Name, &s.Logo, &s.LogoWhite, &s.Param, &s.Rank, &s.Build, &s.Conditions, &s.Tip); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		key := fmt.Sprintf(_initSidebarKey, s.Plat, s.Module)
+		if _, ok := limits[s.ID]; !ok {
+			ss[key] = append(ss[key], s)
+		}
+		limit := &sidebar.Limit{
+			ID:        s.ID,
+			Build:     s.Build,
+			Condition: s.Conditions,
+		}
+		limits[s.ID] = append(limits[s.ID], limit)
+	}
+	return
+}
+
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}

app/interface/main/app-resource/dao/sidebar/sidebar_test.go

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

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

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

@@ -0,0 +1,118 @@
+package splash
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/splash"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_actAllSQL = `SELECT i.splash_id,s.animate,s.duration,s.type,s.times,s.goto,s.param,s.skip,s.starttime,s.endtime,s.platform,i.url,i.hash,i.width,i.height,s.area,s.conditions,s.build,s.operate,s.no_preview FROM 
+					splash AS s, splash_image AS i WHERE s.id=i.splash_id AND s.publish=1 AND i.type=3 AND s.platform!=0 AND s.type!=2 AND s.type!=4 AND s.state=0 ORDER BY s.starttime DESC`
+	_actBirthSQL = `SELECT i.splash_id,s.animate,s.duration,s.type,s.times,s.goto,s.param,s.skip,s.starttime,s.endtime,s.platform,i.url,i.hash,i.width,i.height,s.area,s.conditions,s.build,s.operate FROM 
+					splash AS s, splash_image AS i WHERE s.id=i.splash_id AND s.publish=1 AND i.type=3 AND s.platform!=0 AND s.type=2 AND s.state=0 ORDER BY s.starttime DESC`
+	_actVipSQL = `SELECT i.splash_id,s.animate,s.duration,s.type,s.times,s.goto,s.param,s.skip,s.starttime,s.endtime,s.platform,i.url,i.hash,i.width,i.height,s.area,s.conditions,s.build,s.operate FROM 
+					splash AS s, splash_image AS i WHERE s.id=i.splash_id AND s.publish=1 AND i.type=3 AND s.platform!=0 AND s.type=4 AND s.state=0 ORDER BY s.starttime DESC`
+)
+
+// Dao is splash dao.
+type Dao struct {
+	resdb *sql.DB
+	// splash_active
+	actAll   *sql.Stmt
+	actBirth *sql.Stmt
+	actVip   *sql.Stmt
+}
+
+// New new splash dao and return.
+func New(c *conf.Config) *Dao {
+	d := &Dao{
+		resdb: sql.NewMySQL(c.MySQL.Resource),
+	}
+	// splah_active
+	d.actAll = d.resdb.Prepared(_actAllSQL)
+	d.actBirth = d.resdb.Prepared(_actBirthSQL)
+	d.actVip = d.resdb.Prepared(_actVipSQL)
+	return d
+}
+
+// GetActiveAll get all splash from table splash_active.
+func (d *Dao) ActiveAll(ctx context.Context) (res []*splash.Splash, err error) {
+	rows, err := d.actAll.Query(ctx)
+	if err != nil {
+		log.Error("dao.Exec(), err (%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		sp := &splash.Splash{}
+		if err = rows.Scan(&sp.ID, &sp.Animate, &sp.Duration, &sp.Type, &sp.Times, &sp.Goto, &sp.Param, &sp.Skip, &sp.Start,
+			&sp.End, &sp.Plat, &sp.Image, &sp.Hash, &sp.Width, &sp.Height, &sp.Area, &sp.Condition, &sp.Build, &sp.Operate, &sp.NoPreview); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			res = nil
+			return
+		}
+		sp.PlatChange()
+		if sp.Operate == 1 {
+			res = append([]*splash.Splash{sp}, res...)
+		} else {
+			res = append(res, sp)
+		}
+	}
+	return
+}
+
+// ActiveBirth from table splash and splash_image.
+func (d *Dao) ActiveBirth(ctx context.Context) (res []*splash.Splash, err error) {
+	rows, err := d.actBirth.Query(ctx)
+	if err != nil {
+		log.Error("dao.Exec(), err (%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		sp := &splash.Splash{}
+		if err = rows.Scan(&sp.ID, &sp.Animate, &sp.Duration, &sp.Type, &sp.Times, &sp.Goto, &sp.Param, &sp.Skip, &sp.Start,
+			&sp.End, &sp.Plat, &sp.Image, &sp.Hash, &sp.Width, &sp.Height, &sp.Area, &sp.Condition, &sp.Build, &sp.Operate); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			res = nil
+			return
+		}
+		sp.PlatChange()
+		sp.BirthDate()
+		res = append(res, sp)
+	}
+	return
+}
+
+// ActiveVip form table vip splash
+func (d *Dao) ActiveVip(ctx context.Context) (res []*splash.Splash, err error) {
+	rows, err := d.actVip.Query(ctx)
+	if err != nil {
+		log.Error("dao.Exec(), err (%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		sp := &splash.Splash{}
+		if err = rows.Scan(&sp.ID, &sp.Animate, &sp.Duration, &sp.Type, &sp.Times, &sp.Goto, &sp.Param, &sp.Skip, &sp.Start,
+			&sp.End, &sp.Plat, &sp.Image, &sp.Hash, &sp.Width, &sp.Height, &sp.Area, &sp.Condition, &sp.Build, &sp.Operate); err != nil {
+			log.Error("rows.Scan err (%v)", err)
+			res = nil
+			return
+		}
+		sp.PlatChange()
+		res = append(res, sp)
+	}
+	return
+}
+
+// Close close memcache resource.
+func (dao *Dao) Close() {
+	if dao.resdb != nil {
+		dao.resdb.Close()
+	}
+}

app/interface/main/app-resource/dao/splash/splash_test.go

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

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

@@ -0,0 +1,33 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["tab.go"],
+    importpath = "go-common/app/interface/main/app-resource/dao/tab",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model/tab: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-resource/dao/tab/tab.go

@@ -0,0 +1,46 @@
+package tab
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model/tab"
+	"go-common/library/database/sql"
+)
+
+const (
+	_getAllMenuSQL = "SELECT id,plat,name,ctype,cvalue,plat_ver,status,color,badge FROM app_menus WHERE stime<? AND etime>? AND status=1 ORDER BY `order` ASC"
+)
+
+type Dao struct {
+	db *sql.DB
+}
+
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	return
+}
+
+// Menus menus tab
+func (d *Dao) Menus(c context.Context, now time.Time) (menus []*tab.Menu, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(c, _getAllMenuSQL, now, now); err != nil {
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		m := &tab.Menu{}
+		if err = rows.Scan(&m.TabID, &m.Plat, &m.Name, &m.CType, &m.CValue, &m.PlatVersion, &m.Status, &m.Color, &m.Badge); err != nil {
+			return
+		}
+		if m.CValue != "" {
+			m.Change()
+			menus = append(menus, m)
+		}
+	}
+	err = rows.Err()
+	return
+}

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

@@ -0,0 +1,213 @@
+package version
+
+import (
+	"context"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/app/interface/main/app-resource/model/version"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	// version
+	_allSQL = "SELECT id,plat,description,version,build,ptime FROM version WHERE state=0 ORDER BY ptime DESC"
+	// version_update AND version
+	_allUpsSQL = `SELECT up.id,up.channel,up.url,up.size,up.md5,v.build,v.version,v.description,up.sdkint_list,up.model,up.policy,up.is_force,
+				up.is_push,up.policy_name,v.state,up.mtime,v.plat,up.policy_url,up.buvid_start,up.buvid_end
+					FROM version v RIGHT JOIN version_update up ON v.id=up.vid AND v.plat in(0,7,8,9,11,12) WHERE up.state=1 AND v.state!=1 AND up.url!='' ORDER BY v.build DESC`
+	_allUpsLimitSQL = `SELECT up_id,value,condi FROM version_update_limit ORDER BY value ASC`
+	_allSosSQL      = `SELECT id,package,name,description,clear,ver_code,ver_name,url,size,enable_state,force_state,md5,min_build,coverage,sdkint,model 
+					FROM version_so WHERE enable_state!=2 ORDER BY id DESC`
+	_allIncreSQL = `SELECT i.id,i.target_version,i.target_build,i.target_id,i.source_version,i.source_build,i.source_id,i.task_id,i.file_path,i.url,i.md5,i.size,v.build,v.plat
+						FROM version v RIGHT JOIN version_incremental i ON v.id=i.vid AND v.plat in(0,7,8,9,11,12) WHERE i.state=1 AND v.state!=1 AND i.url!='' ORDER BY v.build DESC`
+	_allRnSQL = `SELECT id,deployment_key,bundle_id,url,md5,size,version FROM version_rn WHERE state=1 ORDER BY ctime DESC`
+)
+
+// Dao is a version dao
+type Dao struct {
+	db     *sql.DB
+	get    *sql.Stmt
+	update *sql.Stmt
+	so     *sql.Stmt
+	incre  *sql.Stmt
+	rn     *sql.Stmt
+	limit  *sql.Stmt
+}
+
+// New new a version dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		db: sql.NewMySQL(c.MySQL.Show),
+	}
+	// prepare
+	d.get = d.db.Prepared(_allSQL)
+	d.update = d.db.Prepared(_allUpsSQL)
+	d.so = d.db.Prepared(_allSosSQL)
+	d.incre = d.db.Prepared(_allIncreSQL)
+	d.rn = d.db.Prepared(_allRnSQL)
+	d.limit = d.db.Prepared(_allUpsLimitSQL)
+	return
+}
+
+// GetVersion get version.
+func (d *Dao) All(ctx context.Context) (ver map[int8][]*version.Version, err error) {
+	rows, err := d.get.Query(ctx)
+	if err != nil {
+		log.Error("d.get error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	ver = map[int8][]*version.Version{}
+	for rows.Next() {
+		a := &version.Version{}
+		if err = rows.Scan(&a.Id, &a.Plat, &a.Desc, &a.Version, &a.Build, &a.PTime); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		ver[a.Plat] = append(ver[a.Plat], a)
+	}
+	return
+}
+
+// GetUpdate get active version AND version_update
+func (d *Dao) Updates(ctx context.Context) (ver map[int8]map[string][]*version.VersionUpdate, err error) {
+	var (
+		masterChannel  = "master"
+		defaultChannel = "bili"
+	)
+	rows, err := d.update.Query(ctx)
+	if err != nil {
+		log.Error("d.update error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	ver = map[int8]map[string][]*version.VersionUpdate{}
+	for rows.Next() {
+		a := &version.VersionUpdate{}
+		if err = rows.Scan(&a.Id, &a.Channel, &a.Url, &a.Size, &a.MD5, &a.Build, &a.Version, &a.Desc, &a.SdkInts, &a.Model, &a.Policy, &a.IsForce,
+			&a.IsPush, &a.PolicyName, &a.State, &a.Mtime, &a.Plat, &a.PolicyURL, &a.BuvidStart, &a.BuvidEnd); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		a.VersionUpdateChange()
+		if a.State == 2 {
+			a.IsGray = 1
+		} else {
+			a.IsGray = 0
+		}
+		if a.Channel == masterChannel && a.Plat != model.PlatAndroidTVYST {
+			a.Channel = defaultChannel
+		}
+		if v, ok := ver[a.Plat]; !ok {
+			ver[a.Plat] = map[string][]*version.VersionUpdate{
+				a.Channel: []*version.VersionUpdate{a},
+			}
+		} else {
+			v[a.Channel] = append(v[a.Channel], a)
+		}
+	}
+	return
+}
+
+// Limits version update limits
+func (d *Dao) Limits(ctx context.Context) (res map[int][]*version.UpdateLimit, err error) {
+	res = map[int][]*version.UpdateLimit{}
+	rows, err := d.limit.Query(ctx)
+	if err != nil {
+		log.Error("d.update error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		l := &version.UpdateLimit{}
+		if err = rows.Scan(&l.ID, &l.BuildLimit, &l.Conditions); err != nil {
+			log.Error("version update limit sql error(%v)", err)
+			return
+		}
+		res[l.ID] = append(res[l.ID], l)
+	}
+	return
+}
+
+// GetSos get version_so
+func (d *Dao) Sos(ctx context.Context) (ver map[string][]*version.VersionSo, err error) {
+	rows, err := d.so.Query(ctx)
+	if err != nil {
+		log.Error("d.so error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	ver = map[string][]*version.VersionSo{}
+	for rows.Next() {
+		s := &version.VersionSo{}
+		if err = rows.Scan(&s.Id, &s.Package, &s.Name, &s.Description, &s.Clear, &s.Ver_code, &s.Ver_name, &s.Url, &s.Size, &s.Enable_state,
+			&s.Force_state, &s.Md5, &s.Min_build, &s.Coverage, &s.Sdkint, &s.Model); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		ver[s.Name] = append(ver[s.Name], s)
+	}
+	return
+}
+
+// Incrementals version incrementals
+func (d *Dao) Incrementals(ctx context.Context) (ver map[int8]map[string][]*version.Incremental, err error) {
+	rows, err := d.incre.Query(ctx)
+	if err != nil {
+		log.Error("d.incre error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	ver = map[int8]map[string][]*version.Incremental{}
+	for rows.Next() {
+		v := &version.Incremental{}
+		if err = rows.Scan(&v.ID, &v.TargetVersion, &v.TargetBuild, &v.TargetID, &v.SourceVersion, &v.SourceBuild, &v.SourceID, &v.TaskID, &v.FilePath, &v.URL, &v.Md5,
+			&v.Size, &v.Build, &v.Plat); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		if vi, ok := ver[v.Plat]; !ok {
+			ver[v.Plat] = map[string][]*version.Incremental{
+				v.SourceID: []*version.Incremental{v},
+			}
+		} else {
+			vi[v.SourceID] = append(vi[v.SourceID], v)
+		}
+	}
+	return
+}
+
+// Rn version rn
+func (d *Dao) Rn(ctx context.Context) (ver map[string]map[string]*version.Rn, err error) {
+	rows, err := d.rn.Query(ctx)
+	if err != nil {
+		log.Error("d.rn error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	ver = map[string]map[string]*version.Rn{}
+	for rows.Next() {
+		v := &version.Rn{}
+		if err = rows.Scan(&v.ID, &v.DeploymentKey, &v.BundleID, &v.URL, &v.Md5, &v.Size, &v.Version); err != nil {
+			log.Error("row.Scan error(%v)", err)
+			return
+		}
+		if vi, ok := ver[v.DeploymentKey]; !ok {
+			ver[v.DeploymentKey] = map[string]*version.Rn{
+				v.Version: v,
+			}
+		} else if _, ok := vi[v.Version]; !ok {
+			vi[v.Version] = v
+		}
+	}
+	return
+}
+
+// Close close db resource.
+func (dao *Dao) Close() {
+	if dao.db != nil {
+		dao.db.Close()
+	}
+}

app/interface/main/app-resource/dao/version/version_test.go

@@ -0,0 +1,68 @@
+package version
+
+import (
+	"context"
+	"flag"
+	"go-common/app/interface/main/app-resource/conf"
+	"path/filepath"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestAll(t *testing.T) {
+	Convey("get all", t, func() {
+		res, err := d.All(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestUpdates(t *testing.T) {
+	Convey("get Updates all", t, func() {
+		res, err := d.Updates(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestIncrementals(t *testing.T) {
+	Convey("get Incrementals all", t, func() {
+		res, err := d.Incrementals(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestSos(t *testing.T) {
+	Convey("get Sos all", t, func() {
+		res, err := d.Sos(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func TestRn(t *testing.T) {
+	Convey("get Rn all", t, func() {
+		res, err := d.Rn(ctx())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/app-resource-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+	time.Sleep(time.Second)
+}

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

@@ -0,0 +1,53 @@
+package white
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/conf"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+
+	"github.com/pkg/errors"
+)
+
+// Dao bplus
+type Dao struct {
+	client *httpx.Client
+}
+
+// New bplus
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		client: httpx.NewClient(c.HTTPClient),
+	}
+	return
+}
+
+// WhiteVerify white verify
+func (d *Dao) WhiteVerify(c context.Context, mid int64, urlStr string) (ok bool, err error) {
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Status int `json:"status"`
+		}
+	}
+	if err = d.client.Get(c, urlStr, "", params, &res); err != nil {
+		return
+	}
+	b, _ := json.Marshal(&res)
+	log.Info("WhiteVerify url(%s) response(%s)", urlStr+"?"+params.Encode(), b)
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), urlStr+"?"+params.Encode())
+		return
+	}
+	if res.Data.Status == 1 {
+		ok = true
+	}
+	return
+}

app/interface/main/app-resource/dao/white/white_test.go

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