Create & Init Project...

app/interface/main/player/dao/BUILD.bazel

@@ -0,0 +1,69 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "account_test.go",
+        "archive_test.go",
+        "creative_test.go",
+        "dao_test.go",
+        "mysql_test.go",
+        "online_test.go",
+        "playurl_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/player/conf:go_default_library",
+        "//app/interface/main/player/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+        "//vendor/gopkg.in/h2non/gock.v1:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "account.go",
+        "archive.go",
+        "creative.go",
+        "dao.go",
+        "mysql.go",
+        "online.go",
+        "playurl.go",
+    ],
+    importpath = "go-common/app/interface/main/player/dao",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/player/conf:go_default_library",
+        "//app/interface/main/player/model: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/net/metadata:go_default_library",
+        "//library/stat/prom: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/player/dao/account.go

@@ -0,0 +1,38 @@
+package dao
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/player/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+)
+
+const _blockTimeURI = "/api/member/getBlockAndMoralStatus"
+
+// BlockTime get user block time from account by mid
+func (d *Dao) BlockTime(c context.Context, mid int64) (res *model.BlockTime, err error) {
+	var (
+		params = url.Values{}
+		ip     = metadata.String(c, metadata.RemoteIP)
+	)
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var rs struct {
+		Code int              `json:"code"`
+		Data *model.BlockTime `json:"data"`
+	}
+	if err = d.client.Get(c, d.blockTimeURL, ip, params, &rs); err != nil {
+		log.Error("d.client.Get(%s,%d) error(%v)", d.blockTimeURL, mid, err)
+		return
+	}
+	if rs.Code != ecode.OK.Code() {
+		log.Error("d.client.Get(%s,%d) error code(%d)", d.blockTimeURL, mid, rs.Code)
+		err = ecode.Int(rs.Code)
+		return
+	}
+	res = rs.Data
+	return
+}

app/interface/main/player/dao/account_test.go

@@ -0,0 +1,18 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/player/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_BlockTime(t *testing.T) {
+	convey.Convey("error should be nill", t, func(ctx convey.C) {
+		res, err := d.BlockTime(context.Background(), 88889069)
+		ctx.So(err, convey.ShouldBeNil)
+		ctx.So(res, convey.ShouldHaveSameTypeAs, &model.BlockTime{})
+	})
+}

app/interface/main/player/dao/archive.go

@@ -0,0 +1,38 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+// PvData get binary data from pvdata url
+func (d *Dao) PvData(c context.Context, pvURL string) (res []byte, err error) {
+	var (
+		req    *http.Request
+		resp   *http.Response
+		cancel func()
+	)
+	if req, err = http.NewRequest("GET", pvURL, nil); err != nil {
+		err = errors.Wrapf(err, "PvData http.NewRequest(%s)", pvURL)
+		return
+	}
+	c, cancel = context.WithTimeout(c, time.Duration(d.c.Rule.VsTimeout))
+	defer cancel()
+	req = req.WithContext(c)
+	if resp, err = d.vsClient.Do(req); err != nil {
+		err = errors.Wrapf(err, "httpClient.Do(%s)", pvURL)
+		return
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= http.StatusBadRequest {
+		err = fmt.Errorf("PvData url(%s) resp.StatusCode(%v)", pvURL, resp.StatusCode)
+		return
+	}
+	res, err = ioutil.ReadAll(resp.Body)
+	return
+}

app/interface/main/player/dao/archive_test.go

@@ -0,0 +1,36 @@
+package dao
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"io"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_PvData(t *testing.T) {
+	convey.Convey("test pvdata", t, func(ctx convey.C) {
+		url := "http://i3.hdslb.com/bfs/videoshot/10135146.bin?vsign=5d5c80b9c583b1ce49f0fb8ab8dd178568efa66c&ver=108653418"
+		res, err := d.PvData(context.Background(), url)
+		ctx.So(err, convey.ShouldBeNil)
+		var (
+			v   uint16
+			pvs []uint16
+			buf = bytes.NewReader(res)
+		)
+		for {
+			if err = binary.Read(buf, binary.BigEndian, &v); err != nil {
+				if err != io.EOF {
+					ctx.Printf("binary.Read err(%v)", err)
+				}
+				err = nil
+				break
+			}
+			pvs = append(pvs, v)
+		}
+		ctx.So(err, convey.ShouldBeNil)
+		ctx.Printf("%+v", pvs)
+	})
+}

app/interface/main/player/dao/creative.go

@@ -0,0 +1,38 @@
+package dao
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/player/model"
+	"go-common/library/ecode"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const _viewPointsURI = "/x/internal/creative/video/viewpoints"
+
+// ViewPoints get view points data from creative.
+func (d *Dao) ViewPoints(c context.Context, aid, cid int64) (points []*model.Points, err error) {
+	params := url.Values{}
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	params.Set("cid", strconv.FormatInt(cid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Points []*model.Points `json:"points"`
+		} `json:"data"`
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	if err = d.client.Get(c, d.viewPointsURL, ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.viewPointsURL+"?"+params.Encode())
+		return
+	}
+	points = res.Data.Points
+	return
+}

app/interface/main/player/dao/creative_test.go

@@ -0,0 +1,26 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoViewPoints(t *testing.T) {
+	convey.Convey("ViewPoints", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			aid = int64(10110670)
+			cid = int64(10134319)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			points, err := d.ViewPoints(c, aid, cid)
+			ctx.Convey("Then err should be nil.points should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(points, convey.ShouldNotBeNil)
+				ctx.Printf("%+v", points)
+			})
+		})
+	})
+}

app/interface/main/player/dao/dao.go

@@ -0,0 +1,58 @@
+package dao
+
+import (
+	"context"
+	"net/http"
+
+	"go-common/app/interface/main/player/conf"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	xhttp "go-common/library/net/http/blademaster"
+	"go-common/library/stat/prom"
+)
+
+// Dao dao.
+type Dao struct {
+	// config
+	c *conf.Config
+	// mysql
+	showDB *sql.DB
+	// stmt
+	paramStmt *sql.Stmt
+	// client
+	client   *xhttp.Client
+	vsClient *http.Client
+	// API URL
+	blockTimeURL   string
+	onlineCountURL string
+	viewPointsURL  string
+}
+
+// New return new dao.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:        c,
+		showDB:   sql.NewMySQL(c.MySQL.Show),
+		client:   xhttp.NewClient(c.HTTPClient),
+		vsClient: http.DefaultClient,
+	}
+	d.paramStmt = d.showDB.Prepared(_param)
+	d.blockTimeURL = c.Host.AccCo + _blockTimeURI
+	d.onlineCountURL = c.Host.APICo + _onlineCountURI
+	d.viewPointsURL = c.Host.APICo + _viewPointsURI
+	return
+}
+
+// Ping check service health
+func (d *Dao) Ping(c context.Context) (err error) {
+	if err = d.showDB.Ping(c); err != nil {
+		log.Error("d.show.Ping() err(%v)", err)
+	}
+	return
+}
+
+// PromError stat and log.
+func PromError(name string, format string, args ...interface{}) {
+	prom.BusinessErrCount.Incr(name)
+	log.Error(format, args...)
+}

app/interface/main/player/dao/dao_test.go

@@ -0,0 +1,45 @@
+package dao
+
+import (
+	"flag"
+	"os"
+	"strings"
+	"testing"
+
+	"gopkg.in/h2non/gock.v1"
+
+	"go-common/app/interface/main/player/conf"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "local" {
+		flag.Set("app_id", "main.web-svr.player-interface")
+		flag.Set("conf_token", "419a7d1d51888c17a9dbdc0abb61cee8")
+		flag.Set("tree_id", "2285")
+		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/player-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	d.client.SetTransport(gock.DefaultTransport)
+	os.Exit(m.Run())
+}
+
+func httpMock(method, url string) *gock.Request {
+	r := gock.New(url)
+	r.Method = strings.ToUpper(method)
+	return r
+}

app/interface/main/player/dao/mysql.go

@@ -0,0 +1,35 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/interface/main/player/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_param = "SELECT `name`,`value` FROM `param` WHERE `plat` = 9 AND `state` = 0"
+)
+
+// Param return player setting params.
+func (d *Dao) Param(c context.Context) (param []*model.Param, err error) {
+	var (
+		rows *sql.Rows
+		pa   *model.Param
+	)
+	if rows, err = d.paramStmt.Query(c); err != nil {
+		log.Error("d.paramStmt.Query() error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		pa = &model.Param{}
+		if err = rows.Scan(&pa.Name, &pa.Value); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		param = append(param, pa)
+	}
+	return
+}

app/interface/main/player/dao/mysql_test.go

@@ -0,0 +1,25 @@
+package dao
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoParam(t *testing.T) {
+	convey.Convey("Param", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		time.Sleep(time.Second)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			param, err := d.Param(c)
+			ctx.Convey("Then err should be nil.param should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(param, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/interface/main/player/dao/online.go

@@ -0,0 +1,42 @@
+package dao
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/library/ecode"
+	"go-common/library/net/metadata"
+)
+
+const _onlineCountURI = "/x/internal/chat/num/ol"
+
+// OnlineCount get online count by aid and cid
+func (d *Dao) OnlineCount(c context.Context, aid, cid int64) (count int64, err error) {
+	var (
+		params = url.Values{}
+		ip     = metadata.String(c, metadata.RemoteIP)
+	)
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	params.Set("cids", strconv.FormatInt(cid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data []struct {
+			Cid   int64 `json:"cid"`
+			Count int64 `json:"count"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.onlineCountURL, ip, params, &res); err != nil {
+		PromError("OnlineNum接口错误", "d.client.Get(%s) error(%v)", d.onlineCountURL, err)
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		PromError("OnlineNum接口Code错误", "d.client.Get(%s) code(%d) error", d.onlineCountURL, res.Code)
+		return
+	}
+	if len(res.Data) == 0 || res.Data[0].Cid != cid {
+		PromError("OnlineNum接口数据错误", "d.client.Get(%s) data(%v) error", d.onlineCountURL, res.Data)
+	}
+	count = res.Data[0].Count
+	return
+}

app/interface/main/player/dao/online_test.go

@@ -0,0 +1,18 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_OnlineCount(t *testing.T) {
+	convey.Convey("test online num", t, func(ctx convey.C) {
+		aid := int64(17592153)
+		cid := int64(28727160)
+		data, err := d.OnlineCount(context.Background(), aid, cid)
+		ctx.So(err, convey.ShouldBeNil)
+		ctx.Println(data)
+	})
+}

app/interface/main/player/dao/playurl.go

@@ -0,0 +1,80 @@
+package dao
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/player/model"
+	"go-common/library/ecode"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Playurl get playurl data.
+func (d *Dao) Playurl(c context.Context, mid int64, arg *model.PlayurlArg, playurl, token string) (data *model.PlayurlRes, err error) {
+	params := url.Values{}
+	params.Set("cid", strconv.FormatInt(arg.Cid, 10))
+	params.Set("avid", strconv.FormatInt(arg.Aid, 10))
+	params.Set("qn", strconv.Itoa(arg.Qn))
+	if arg.Type != "" {
+		params.Set("type", arg.Type)
+	}
+	if arg.MaxBackup > 0 {
+		params.Set("max_backup", strconv.Itoa(arg.MaxBackup))
+	}
+	if arg.Npcybs > 0 {
+		params.Set("npcybs", strconv.Itoa(arg.Npcybs))
+	}
+	if mid > 0 {
+		params.Set("mid", strconv.FormatInt(mid, 10))
+	}
+	if arg.Platform != "" {
+		params.Set("platform", arg.Platform)
+	}
+	if arg.Buvid != "" {
+		params.Set("buvid", arg.Buvid)
+	}
+	if arg.Resolution != "" {
+		params.Set("resolution", arg.Resolution)
+	}
+	if arg.Model != "" {
+		params.Set("model", arg.Model)
+	}
+	if arg.Build > 0 {
+		params.Set("build", strconv.Itoa(arg.Build))
+	}
+	params.Set("fnver", strconv.Itoa(arg.Fnver))
+	if arg.Fnval > 0 {
+		params.Set("fnval", strconv.Itoa(arg.Fnval))
+	}
+	if arg.Session != "" {
+		params.Set("session", arg.Session)
+	}
+	if arg.HTML5 > 0 && arg.H5GoodQuality > 0 {
+		params.Set("h5_good_quality", strconv.Itoa(arg.H5GoodQuality))
+	}
+	params.Set("otype", "json")
+	var req *http.Request
+	if req, err = d.client.NewRequest(http.MethodGet, playurl, metadata.String(c, metadata.RemoteIP), params); err != nil {
+		return
+	}
+	if token != "" {
+		req.Header.Set("X-BVC-FINGERPRINT", token)
+	}
+	var res struct {
+		Code int `json:"code"`
+		*model.PlayurlRes
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		err = errors.Wrapf(err, "d.client.Do(%s) (%+v)", playurl+"?"+params.Encode(), arg)
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), playurl+"?"+params.Encode())
+	}
+	data = res.PlayurlRes
+	return
+}

app/interface/main/player/dao/playurl_test.go

@@ -0,0 +1,38 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+
+	"gopkg.in/h2non/gock.v1"
+
+	"go-common/app/interface/main/player/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_Playurl(t *testing.T) {
+	convey.Convey("test playurl", t, func(ctx convey.C) {
+		// aid 10108138
+		mid := int64(908085)
+		//cid=47083420&qn=80&type=&otype=json&fnver=0&fnval=8
+		arg := &model.PlayurlArg{
+			Aid:   10111420,
+			Cid:   10151472,
+			Qn:    0,
+			OType: "xml",
+			//Player: 1,
+			Fnver: 0,
+			Fnval: 8,
+		}
+		token := ""
+		playurl := "http://uat-videodispatch-ugc.bilibili.co/v3/playurl"
+		defer gock.OffAll()
+		httpMock("GET", playurl).Reply(200).JSON(`{"code":0}`)
+		data, err := d.Playurl(context.Background(), mid, arg, playurl, token)
+		convey.So(err, convey.ShouldBeNil)
+		str, _ := json.Marshal(data)
+		convey.Println(string(str))
+	})
+}