Create & Init Project...

app/interface/main/creative/dao/danmu/BUILD

@@ -0,0 +1,67 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "adv_danmu.go",
+        "assist.go",
+        "dao.go",
+        "dm.go",
+        "protect.go",
+        "report.go",
+    ],
+    importpath = "go-common/app/interface/main/creative/dao/danmu",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/creative/conf:go_default_library",
+        "//app/interface/main/creative/dao/tool:go_default_library",
+        "//app/interface/main/creative/model/danmu:go_default_library",
+        "//app/interface/main/dm/model: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",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "adv_danmu_test.go",
+        "assist_test.go",
+        "dao_test.go",
+        "dm_test.go",
+        "protect_test.go",
+        "report_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/creative/conf:go_default_library",
+        "//app/interface/main/creative/model/danmu:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+        "//vendor/gopkg.in/h2non/gock.v1:go_default_library",
+    ],
+)

app/interface/main/creative/dao/danmu/adv_danmu.go

@@ -0,0 +1,104 @@
+package danmu
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/creative/model/danmu"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	// api
+	_getDmPurchaseListURI   = "/x/internal/dm/adv/list"
+	_setDmPurchasePassURI   = "/x/internal/dm/adv/pass"
+	_setDmPurchaseDenyURI   = "/x/internal/dm/adv/deny"
+	_setDmPurchaseCancelURI = "/x/internal/dm/adv/cancel"
+)
+
+// GetAdvDmPurchases fn
+func (d *Dao) GetAdvDmPurchases(c context.Context, mid int64, ip string) (danmus []*danmu.AdvanceDanmu, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int                   `json:"code"`
+		Data []*danmu.AdvanceDanmu `json:"data"`
+	}
+	if err = d.client.Get(c, d.advDmPurchaseListURL, ip, params, &res); err != nil {
+		log.Error("d.ListAdvanceDm.Get(%s,%s,%s) err(%v)", d.advDmPurchaseListURL, ip, params.Encode(), err)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.ListAdvanceDm.Get(%s,%s,%s) err(%v)|code（%d）", d.advDmPurchaseListURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	danmus = res.Data
+	return
+}
+
+// PassAdvDmPurchase fn
+func (d *Dao) PassAdvDmPurchase(c context.Context, mid, id int64, ip string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("id", strconv.FormatInt(id, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.advDmPurchasePassURL, ip, params, &res); err != nil {
+		log.Error("d.advDmPurchasePass.Post(%s,%s,%s) err(%v)", d.advDmPurchasePassURL, ip, params.Encode(), err)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.advDmPurchasePass.Post(%s,%s,%s) err(%v)|code(%d)", d.advDmPurchasePassURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	return
+}
+
+// DenyAdvDmPurchase fn
+func (d *Dao) DenyAdvDmPurchase(c context.Context, mid, id int64, ip string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("id", strconv.FormatInt(id, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.advDmPurchaseDenyURL, ip, params, &res); err != nil {
+		log.Error("d.advDmPurchaseDeny.Post(%s,%s,%s) err(%v)", d.advDmPurchaseDenyURL, ip, params.Encode(), err)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.advDmPurchaseDeny.Post(%s,%s,%s) err(%v)|code(%d)", d.advDmPurchaseDenyURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	return
+}
+
+// CancelAdvDmPurchase fn
+func (d *Dao) CancelAdvDmPurchase(c context.Context, mid, id int64, ip string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("id", strconv.FormatInt(id, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.advDmPurchaseCancelURL, ip, params, &res); err != nil {
+		log.Error("d.advDmPurchaseCancel.Post(%s,%s,%s) err(%v)", d.advDmPurchaseCancelURL, ip, params.Encode(), err)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.advDmPurchaseCancel.Post(%s,%s,%s) err(%v)|code(%d)", d.advDmPurchaseCancelURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	return
+}

app/interface/main/creative/dao/danmu/adv_danmu_test.go

@@ -0,0 +1,73 @@
+package danmu
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+	gock "gopkg.in/h2non/gock.v1"
+)
+
+func TestDanmuGetAdvDmPurchases(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		ip  = "127.0.0.1"
+	)
+	convey.Convey("GetAdvDmPurchases", t, func(ctx convey.C) {
+		danmus, err := d.GetAdvDmPurchases(c, mid, ip)
+		ctx.Convey("Then err should be nil.danmus should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(danmus, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDanmuPassAdvDmPurchase(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		id  = int64(1)
+		ip  = "127.0.0.1"
+	)
+	convey.Convey("PassAdvDmPurchase", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("POST", d.advDmPurchasePassURL).Reply(200).JSON(`{"code":20043,"data":""}`)
+		err := d.PassAdvDmPurchase(c, mid, id, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDanmuDenyAdvDmPurchase(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		id  = int64(1)
+		ip  = "127.0.0.1"
+	)
+	convey.Convey("DenyAdvDmPurchase", t, func(ctx convey.C) {
+		err := d.DenyAdvDmPurchase(c, mid, id, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDanmuCancelAdvDmPurchase(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		id  = int64(1)
+		ip  = "127.0.0.1"
+	)
+	convey.Convey("CancelAdvDmPurchase", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("POST", d.advDmPurchaseCancelURL).Reply(200).JSON(`{"code":0,"data":""}`)
+		err := d.CancelAdvDmPurchase(c, mid, id, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/danmu/assist.go

@@ -0,0 +1,37 @@
+package danmu
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	// api
+	_setDmBannedURI = "/x/internal/dm/assist/banned/upt"
+)
+
+// ResetUpBanned pool 0：cancel move，1：cancel ignore
+func (d *Dao) ResetUpBanned(c context.Context, mid int64, state int8, hash, ip string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("hash", hash)
+	params.Set("stat", strconv.FormatInt(mid, 10)) //0：撤销添加屏蔽，1：撤销删除屏蔽
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.assistDmBannedURL, ip, params, &res); err != nil {
+		err = ecode.CreativeDanmuErr
+		log.Error("d.SetDmStat.Post(%s,%s,%s) err(%v)", d.assistDmBannedURL, ip, params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.SetDmStat.Post(%s,%s,%s) err(%v)|code(%d)", d.assistDmBannedURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	return
+}

app/interface/main/creative/dao/danmu/assist_test.go

@@ -0,0 +1,27 @@
+package danmu
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+	gock "gopkg.in/h2non/gock.v1"
+)
+
+func TestDanmuResetUpBanned(t *testing.T) {
+	var (
+		c     = context.TODO()
+		mid   = int64(2089809)
+		state = int8(0)
+		hash  = "iamahashstring"
+		ip    = "127.0.0.1"
+	)
+	convey.Convey("ResetUpBanned", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("POST", d.assistDmBannedURL).Reply(200).JSON(`{"code":0,"message":"0","ttl":1,"data":""}`)
+		err := d.ResetUpBanned(c, mid, state, hash, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

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

@@ -0,0 +1,61 @@
+package danmu
+
+import (
+	"go-common/app/interface/main/creative/conf"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// Dao is creative dao.
+type Dao struct {
+	// config
+	c *conf.Config
+	// http client
+	client *bm.Client
+	// assist url
+	assistDmBannedURL string
+
+	advDmPurchaseListURL   string
+	advDmPurchasePassURL   string
+	advDmPurchaseDenyURL   string
+	advDmPurchaseCancelURL string
+
+	dmSearchURL                string
+	dmEditURL                  string
+	dmRecentURL                string
+	dmTransferURL              string
+	dmPoolURL                  string
+	dmDistriURL                string
+	dmProtectApplyListURL      string
+	dmProtectApplyStatusURL    string
+	dmProtectApplyVideoListURL string
+	dmReportUpListURL          string
+	dmReportUpArchivesURL      string
+	dmReportUpEditURL          string
+}
+
+// New init api url
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:                 c,
+		client:            bm.NewClient(c.HTTPClient.Slow),
+		assistDmBannedURL: c.Host.API + _setDmBannedURI,
+
+		advDmPurchaseListURL:       c.Host.API + _getDmPurchaseListURI,
+		advDmPurchasePassURL:       c.Host.API + _setDmPurchasePassURI,
+		advDmPurchaseDenyURL:       c.Host.API + _setDmPurchaseDenyURI,
+		advDmPurchaseCancelURL:     c.Host.API + _setDmPurchaseCancelURI,
+		dmSearchURL:                c.Host.API + _dmSearchURI,
+		dmEditURL:                  c.Host.API + _dmEditURI,
+		dmRecentURL:                c.Host.API + _dmRecentURI,
+		dmTransferURL:              c.Host.API + _dmTransferURI,
+		dmPoolURL:                  c.Host.API + _dmPoolURI,
+		dmDistriURL:                c.Host.API + _dmDistriURI,
+		dmProtectApplyStatusURL:    c.Host.API + _dmProtectApplyStatusURI,
+		dmProtectApplyListURL:      c.Host.API + _dmProtectApplyListURI,
+		dmProtectApplyVideoListURL: c.Host.API + _dmProtectApplyVideoListURI,
+		dmReportUpEditURL:          c.Host.API + _dmReportUpEditURI,
+		dmReportUpListURL:          c.Host.API + _dmReportUpListURI,
+		dmReportUpArchivesURL:      c.Host.API + _dmReportUpArchivesURI,
+	}
+	return
+}

app/interface/main/creative/dao/danmu/dao_test.go

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

app/interface/main/creative/dao/danmu/dm.go

@@ -0,0 +1,284 @@
+package danmu
+
+import (
+	"context"
+	"math"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/creative/conf"
+	"go-common/app/interface/main/creative/dao/tool"
+	"go-common/app/interface/main/creative/model/danmu"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+const (
+	_dmSearchURI   = "/x/internal/v2/dm/search"
+	_dmEditURI     = "/x/internal/v2/dm/edit/state"
+	_dmTransferURI = "/x/internal/dm/up/transfer"
+	_dmPoolURI     = "/x/internal/v2/dm/edit/pool"
+	_dmDistriURI   = "/x/internal/v2/dm/distribution"
+	_dmRecentURI   = "/x/internal/v2/dm/recent"
+)
+
+// List fn
+func (d *Dao) List(c context.Context, cid, mid int64, page, size int, order, pool, midStr, ip string) (dmList *danmu.DmList, err error) {
+	params := url.Values{}
+	params.Set("type", "1")
+	params.Set("oid", strconv.FormatInt(cid, 10))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("pn", strconv.FormatInt(int64(page), 10))
+	params.Set("ps", strconv.FormatInt(int64(size), 10))
+	params.Set("order", order)
+	params.Set("pool", pool)
+	if len(midStr) > 0 {
+		midss, _ := xstr.SplitInts(midStr)
+		midsa := make([]int64, 0)
+		for _, v := range midss {
+			if v > 0 {
+				midsa = append(midsa, v)
+			}
+		}
+		if len(midsa) > 0 {
+			params.Set("mids", xstr.JoinInts(midsa))
+		}
+	}
+
+	var res struct {
+		Code           int                   `json:"code"`
+		SearchDMResult *danmu.SearchDMResult `json:"data"`
+	}
+	dmList = &danmu.DmList{
+		List: make([]*danmu.MemberDM, 0),
+	}
+	if err = d.client.Get(c, d.dmSearchURL, ip, params, &res); err != nil {
+		log.Error("d.DmSearch Get(%s,%s,%s) err(%v)", d.dmSearchURL, ip, params.Encode(), err)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.DmSearch Get(%s,%s,%s) err(%v)|code(%d)", d.dmSearchURL, ip, params.Encode(), err, res.Code)
+		if err == ecode.NothingFound {
+			log.Error("d.DmSearch Get NothingFound (%s,%s,%s) err(%v)|code(%d)", d.dmSearchURL, ip, params.Encode(), err, res.Code)
+			err = nil
+		}
+		return
+	}
+	if res.SearchDMResult != nil {
+		dmList.Page = res.SearchDMResult.Page.Num
+		dmList.Size = res.SearchDMResult.Page.Size
+		dmList.TotalItems = res.SearchDMResult.Page.Total
+		dmList.TotalPages = int(math.Ceil(float64(res.SearchDMResult.Page.Total) / float64(res.SearchDMResult.Page.Size)))
+		for _, v := range res.SearchDMResult.Result {
+			list := &danmu.MemberDM{
+				ID:       v.ID,
+				FontSize: v.FontSize,
+				Color:    v.Color,
+				Mode:     v.Mode,
+				Msg:      v.Msg,
+				Oid:      v.Oid,
+				Mid:      v.Mid,
+				Playtime: float64(v.Progress) / 1000,
+				Pool:     v.Pool,
+				Ctime:    v.Ctime,
+				Attrs:    v.Attrs,
+			}
+			if d.isProtect(v.Attrs, 1) {
+				list.State = 2
+			}
+			dmList.List = append(dmList.List, list)
+		}
+	}
+	return
+}
+
+// Edit fn
+func (d *Dao) Edit(c context.Context, mid, cid int64, state int8, dmids []int64, ip string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("oid", strconv.FormatInt(cid, 10))
+	params.Set("type", "1")
+	params.Set("state", strconv.FormatInt(int64(state), 10))
+	params.Set("dmids", xstr.JoinInts(dmids))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.dmEditURL, ip, params, &res); err != nil {
+		log.Error("d.DmEdit.Post(%s,%s,%s) err(%v)", d.dmEditURL, ip, params.Encode(), err)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	log.Info("d.DmEdit.Post res.Code (%s,%s,%s) err(%v)|code(%d)", d.dmEditURL, ip, params.Encode(), err, res.Code)
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.DmEdit.Post res.Code (%s,%s,%s) err(%v)|code(%d)", d.dmEditURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	return
+}
+
+// Transfer fn
+func (d *Dao) Transfer(c context.Context, mid, fromCID, toCID int64, offset float64, ak, ck, ip string) (err error) {
+	params := url.Values{}
+	params.Set("from", strconv.FormatInt(fromCID, 10))
+	params.Set("to", strconv.FormatInt(toCID, 10))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("offset", strconv.FormatFloat(offset, 'f', 3, 64))
+	params.Set("appkey", conf.Conf.App.Key)
+	params.Set("appsecret", conf.Conf.App.Secret)
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	var (
+		query, _ = tool.Sign(params)
+		url      string
+	)
+	url = d.dmTransferURL + "?" + query
+	var res struct {
+		Code int `json:"code"`
+	}
+	req, err := http.NewRequest("POST", url, nil)
+	if err != nil {
+		log.Error("http.NewRequest(%s) error(%v)|mid(%d),fromCID(%d),toCID(%d),ak(%s),ck(%s),ip(%s)", url, err, mid, fromCID, toCID, ak, ck, ip)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	req.Header.Set("X-BACKEND-BILI-REAL-IP", ip)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("Cookie", ck)
+	if err = d.client.Do(c, req, &res); err != nil {
+		log.Error("d.client.Do(%s) error(%v)|mid(%d),fromCID(%d),toCID(%d),ak(%s),ck(%s),ip(%s)", url, err, mid, fromCID, toCID, ak, ck, ip)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	log.Info("dao Transfer(%s)mid(%d),fromCID(%d),toCID(%d),ak(%s),ck(%s),ip(%s)", url, mid, fromCID, toCID, ak, ck, ip)
+	if res.Code != 0 {
+		log.Error("dm Transfer(%s) res(%v); mid(%d), ip(%s), code(%d)", url, res, mid, ip, res.Code)
+		err = ecode.Int(res.Code)
+		return
+	}
+	return
+}
+
+// UpPool fn
+func (d *Dao) UpPool(c context.Context, mid, cid int64, dmids []int64, pool int8) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("oid", strconv.FormatInt(cid, 10))
+	params.Set("type", "1")
+	params.Set("pool", strconv.FormatInt(int64(pool), 10))
+	params.Set("dmids", xstr.JoinInts(dmids))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.dmPoolURL, "", params, &res); err != nil {
+		log.Error("d.Pool.Post(%s,%s,%s) err(%v)", d.dmPoolURL, "", params.Encode(), err)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	log.Info("d.Pool.Post res.Code (%s,%s,%s) err(%v)|code(%d)", d.dmPoolURL, "", params.Encode(), err, res.Code)
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.DmEdit.Post res.Code (%s,%s,%s) err(%v)|code(%d)", d.dmPoolURL, "", params.Encode(), err, res.Code)
+		return
+	}
+	return
+}
+
+// Distri fn
+func (d *Dao) Distri(c context.Context, mid, cid int64, ip string) (distri map[int64]int64, err error) {
+	params := url.Values{}
+	params.Set("oid", strconv.FormatInt(cid, 10))
+	params.Set("type", "1")
+	params.Set("interval", "1")
+	var res struct {
+		Code   int             `json:"code"`
+		Distri map[int64]int64 `json:"data"`
+	}
+	res.Distri = make(map[int64]int64)
+	if err = d.client.Get(c, d.dmDistriURL, ip, params, &res); err != nil {
+		log.Error("d.DmDistri.Get(%s,%s,%s) err(%v)", d.dmDistriURL, ip, params.Encode(), err)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.DmDistri.Get(%s,%s,%s) err(%v)|code(%d)", d.dmDistriURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	distri = res.Distri
+	return
+}
+
+// Recent fn
+func (d *Dao) Recent(c context.Context, mid, pn, ps int64, ip string) (dmRecent *danmu.DmRecent, aids []int64, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("pn", strconv.FormatInt(pn, 10))
+	params.Set("ps", strconv.FormatInt(ps, 10))
+	dmRecent = &danmu.DmRecent{
+		List: make([]*danmu.Recent, 0),
+	}
+	aids = make([]int64, 0)
+	var res struct {
+		Code         int                 `json:"code"`
+		ResNewRecent *danmu.ResNewRecent `json:"data"`
+	}
+	if err = d.client.Get(c, d.dmRecentURL, ip, params, &res); err != nil {
+		log.Error("d.DmRecent Get(%s,%s,%s) err(%v)", d.dmRecentURL, ip, params.Encode(), err)
+		err = ecode.CreativeDanmuErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.DmRecent Get(%s,%s,%s) err(%v)|code(%d)", d.dmRecentURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	if res.ResNewRecent != nil {
+		dmRecent.Page = res.ResNewRecent.Page.Pn
+		dmRecent.Size = res.ResNewRecent.Page.Ps
+		dmRecent.TotalItems = res.ResNewRecent.Page.Total
+		dmRecent.TotalPages = int(math.Ceil(float64(res.ResNewRecent.Page.Total) / float64(res.ResNewRecent.Page.Ps)))
+		for _, v := range res.ResNewRecent.Result {
+			list := &danmu.Recent{
+				ID:       v.ID,
+				Aid:      v.Aid,
+				Type:     v.Type,
+				Oid:      v.Oid,
+				Mid:      v.Mid,
+				Msg:      v.Msg,
+				Playtime: float64(v.Progress) / 1000,
+				FontSize: v.FontSize,
+				Color:    v.Color,
+				Mode:     v.Mode,
+				Pool:     v.Pool,
+				Title:    v.Title,
+				Ctime:    v.Ctime,
+				Mtime:    v.Ctime,
+				Attrs:    v.Attrs,
+			}
+			if d.isProtect(v.Attrs, 1) {
+				list.State = 2
+			}
+			dmRecent.List = append(dmRecent.List, list)
+			aids = append(aids, v.Aid)
+		}
+	}
+	return
+}
+
+func (d *Dao) isProtect(attrs string, num int64) bool {
+	if len(attrs) == 0 {
+		return false
+	}
+	attrInts, _ := xstr.SplitInts(attrs)
+	for _, v := range attrInts {
+		if v == num {
+			return true
+		}
+	}
+	return false
+}

app/interface/main/creative/dao/danmu/dm_test.go

@@ -0,0 +1,157 @@
+package danmu
+
+import (
+	"context"
+	"encoding/json"
+	"go-common/app/interface/main/creative/model/danmu"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+	gock "gopkg.in/h2non/gock.v1"
+)
+
+func TestDanmuList(t *testing.T) {
+	var (
+		c      = context.TODO()
+		cid    = int64(0)
+		mid    = int64(2089809)
+		page   = int(1)
+		size   = int(10)
+		order  = "ctime"
+		pool   = "0"
+		midStr = ""
+		ip     = "127.0.0.1"
+	)
+	convey.Convey("List", t, func(ctx convey.C) {
+		dmList, err := d.List(c, cid, mid, page, size, order, pool, midStr, ip)
+		ctx.Convey("Then err should be nil.dmList should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(dmList, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDanmuEdit(t *testing.T) {
+	var (
+		c     = context.TODO()
+		mid   = int64(2089809)
+		cid   = int64(0)
+		state = int8(0)
+		dmids = []int64{}
+		ip    = "127.0.0.1"
+	)
+	convey.Convey("Edit", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("POST", d.dmEditURL).Reply(200).JSON(`{"code":0,"data":""}`)
+		err := d.Edit(c, mid, cid, state, dmids, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDanmuTransfer(t *testing.T) {
+	var (
+		c       = context.TODO()
+		mid     = int64(2089809)
+		fromCID = int64(1)
+		toCID   = int64(2)
+		offset  = float64(10.0)
+		ak      = "ak"
+		ck      = "ck"
+		ip      = "127.0.0.1"
+	)
+	convey.Convey("Transfer", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("POST", d.dmTransferURL).Reply(200).JSON(`{"code":0,"data":""}`)
+		err := d.Transfer(c, mid, fromCID, toCID, offset, ak, ck, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDanmuUpPool(t *testing.T) {
+	var (
+		c     = context.TODO()
+		mid   = int64(2089809)
+		cid   = int64(0)
+		dmids = []int64{}
+		pool  = int8(0)
+	)
+	convey.Convey("UpPool", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("POST", d.dmPoolURL).Reply(200).JSON(`{"code":0,"data":""}`)
+		err := d.UpPool(c, mid, cid, dmids, pool)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDanmuDistri(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		cid = int64(1)
+		ip  = "127.0.0.1"
+	)
+	convey.Convey("Distri", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("Get", d.dmDistriURL).Reply(200).JSON(`{"code":0,"message":"0","ttl":1,"data":{"1":1}}`)
+		distri, err := d.Distri(c, mid, cid, ip)
+		ctx.Convey("Then err should be nil.distri should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(distri, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDanmuRecent(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		pn  = int64(1)
+		ps  = int64(10)
+		ip  = "127.0.0.1"
+	)
+	convey.Convey("Recent", t, func(ctx convey.C) {
+		var res struct {
+			Code         int                 `json:"code"`
+			ResNewRecent *danmu.ResNewRecent `json:"data"`
+		}
+		res.ResNewRecent = &danmu.ResNewRecent{
+			Page: &danmu.RecentPage{
+				Pn:    1,
+				Ps:    10,
+				Total: 20,
+			},
+		}
+		res.ResNewRecent.Result = append(res.ResNewRecent.Result, &danmu.DMMember{
+			ID:  1,
+			Aid: 99,
+		})
+		defer gock.OffAll()
+		js, _ := json.Marshal(res)
+		httpMock("Get", d.dmRecentURL).Reply(200).JSON(string(js))
+		dmRecent, aids, err := d.Recent(c, mid, pn, ps, ip)
+		ctx.Convey("Recent", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(aids, convey.ShouldNotBeNil)
+			ctx.So(dmRecent, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDanmuisProtect(t *testing.T) {
+	var (
+		attrs = ""
+		num   = int64(0)
+	)
+	convey.Convey("isProtect", t, func(ctx convey.C) {
+		p1 := d.isProtect(attrs, num)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/danmu/protect.go

@@ -0,0 +1,95 @@
+package danmu
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/creative/model/danmu"
+	dmMdl "go-common/app/interface/main/dm/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_dmProtectApplyListURI      = "/x/internal/dm/up/protect/apply/list"
+	_dmProtectApplyStatusURI    = "/x/internal/dm/up/protect/apply/status"
+	_dmProtectApplyVideoListURI = "/x/internal/dm/up/protect/apply/video/list"
+)
+
+// ProtectApplyList fn
+func (d *Dao) ProtectApplyList(c context.Context, mid, page int64, aidStr, sort, ip string) (result *danmu.ApplyList, err error) {
+	result = &danmu.ApplyList{}
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	params.Set("aid", aidStr)
+	params.Set("page", strconv.FormatInt(page, 10))
+	params.Set("sort", sort)
+	var res struct {
+		Code int                    `json:"code"`
+		Data *danmu.ApplyListFromDM `json:"data"`
+	}
+	if err = d.client.Get(c, d.dmProtectApplyListURL, ip, params, &res); err != nil {
+		err = ecode.CreativeDanmuErr
+		log.Error("d.ProtectApplyList.Get(%s,%s,%s) err(%v)", d.dmProtectApplyListURL, ip, params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.ProtectApplyList.Get(%s,%s,%s) err(%v)|code(%d)", d.dmProtectApplyListURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	for _, v := range res.Data.List {
+		v.IDStr = strconv.FormatInt(v.ID, 10)
+	}
+	result = &danmu.ApplyList{
+		Pager: res.Data.Pager,
+		List:  res.Data.List,
+	}
+	return
+}
+
+// ProtectApplyVideoList fn
+func (d *Dao) ProtectApplyVideoList(c context.Context, mid int64, ip string) (result []*dmMdl.Video, err error) {
+	result = []*dmMdl.Video{}
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int            `json:"code"`
+		Data []*dmMdl.Video `json:"data"`
+	}
+	if err = d.client.Get(c, d.dmProtectApplyVideoListURL, ip, params, &res); err != nil {
+		err = ecode.CreativeDanmuErr
+		log.Error("d.ProtectApplyVideoList.Get(%s,%s,%s) err(%v)", d.dmProtectApplyVideoListURL, ip, params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.ProtectApplyVideoList.Get(%s,%s,%s) err(%v)|code(%d)", d.dmProtectApplyVideoListURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	result = res.Data
+	return
+}
+
+// ProtectOper fn
+func (d *Dao) ProtectOper(c context.Context, mid, status int64, ids, ip string) (err error) {
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	params.Set("status", strconv.FormatInt(status, 10))
+	params.Set("ids", ids)
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.dmProtectApplyStatusURL, ip, params, &res); err != nil {
+		err = ecode.CreativeDanmuErr
+		log.Error("d.ProtectApply.Post(%s,%s,%s) err(%v)", d.dmProtectApplyStatusURL, ip, params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.ProtectApply.Post(%s,%s,%s) err(%v)|code(%d)", d.dmProtectApplyStatusURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	return
+}

app/interface/main/creative/dao/danmu/protect_test.go

@@ -0,0 +1,60 @@
+package danmu
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+	gock "gopkg.in/h2non/gock.v1"
+)
+
+func TestDanmuProtectApplyList(t *testing.T) {
+	var (
+		c      = context.TODO()
+		mid    = int64(2089809)
+		page   = int64(0)
+		aidStr = "1"
+		sort   = "ctime"
+		ip     = "127.0.0.1"
+	)
+	convey.Convey("ProtectApplyList", t, func(ctx convey.C) {
+		result, err := d.ProtectApplyList(c, mid, page, aidStr, sort, ip)
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(result, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDanmuProtectApplyVideoList(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		ip  = "127.0.0.1"
+	)
+	convey.Convey("ProtectApplyVideoList", t, func(ctx convey.C) {
+		result, err := d.ProtectApplyVideoList(c, mid, ip)
+		ctx.Convey("Then err should be nil.result should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(result, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDanmuProtectOper(t *testing.T) {
+	var (
+		c      = context.TODO()
+		mid    = int64(2089809)
+		status = int64(0)
+		ids    = "1,2"
+		ip     = "127.0.0.1"
+	)
+	convey.Convey("ProtectOper", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("POST", d.dmProtectApplyStatusURL).Reply(200).JSON(`{"code":20043,"data":""}`)
+		err := d.ProtectOper(c, mid, status, ids, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/danmu/report.go

@@ -0,0 +1,98 @@
+package danmu
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/creative/model/danmu"
+	dmMdl "go-common/app/interface/main/dm/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_dmReportUpEditURI     = "/x/internal/dm/report/up/edit"
+	_dmReportUpListURI     = "/x/internal/dm/report/up/list"
+	_dmReportUpArchivesURI = "/x/internal/dm/report/up/archives"
+)
+
+// ReportUpList fn
+func (d *Dao) ReportUpList(c context.Context, mid, pn, ps int64, aidStr, ip string) (result []*dmMdl.RptSearch, total int64, err error) {
+	result = []*dmMdl.RptSearch{}
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("aid", aidStr)
+	params.Set("page", strconv.FormatInt(pn, 10))
+	params.Set("size", strconv.FormatInt(ps, 10))
+	var res struct {
+		Code int               `json:"code"`
+		Data *dmMdl.RptSearchs `json:"data"`
+	}
+	if err = d.client.Get(c, d.dmReportUpListURL, ip, params, &res); err != nil {
+		err = ecode.CreativeDanmuErr
+		log.Error("d.ReportUpList.Get(%s,%s,%s) err(%v)", d.dmReportUpListURL, ip, params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(int(res.Code))
+		log.Error("d.ReportUpList.Get(%s,%s,%s) err(%v)|code(%d)", d.dmReportUpListURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	result = res.Data.Result
+	total = res.Data.Total
+	return
+}
+
+// ReportUpArchives fn
+func (d *Dao) ReportUpArchives(c context.Context, mid int64, ip string) (ars []*danmu.DmArc, err error) {
+	ars = []*danmu.DmArc{}
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int             `json:"code"`
+		Data *dmMdl.Archives `json:"data"`
+	}
+	if err = d.client.Get(c, d.dmReportUpArchivesURL, ip, params, &res); err != nil {
+		err = ecode.CreativeDanmuErr
+		log.Error("d.ReportUpArchives.Get(%s,%s,%s) err(%v)", d.dmReportUpArchivesURL, ip, params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(int(res.Code))
+		log.Error("d.ReportUpArchives.Get(%s,%s,%s) err(%v)|code(%d)", d.dmReportUpArchivesURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	if res.Data != nil {
+		for _, v := range res.Data.Result {
+			ars = append(ars, &danmu.DmArc{
+				Aid:   v.Aid,
+				Title: v.Title,
+			})
+		}
+	}
+	return
+}
+
+// ReportUpEdit fn
+func (d *Dao) ReportUpEdit(c context.Context, mid, dmid, cid, op int64, ip string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("dmid", strconv.FormatInt(dmid, 10))
+	params.Set("cid", strconv.FormatInt(cid, 10))
+	params.Set("op", strconv.FormatInt(op, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.dmReportUpEditURL, ip, params, &res); err != nil {
+		err = ecode.CreativeDanmuErr
+		log.Error("d.dmReportUpEditURL.Post(%s,%s,%s) err(%v)", d.dmReportUpEditURL, ip, params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.dmReportUpEditURL.Post(%s,%s,%s) err(%v)|code(%d)", d.dmReportUpEditURL, ip, params.Encode(), err, res.Code)
+		return
+	}
+	return
+}

app/interface/main/creative/dao/danmu/report_test.go

@@ -0,0 +1,66 @@
+package danmu
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+	gock "gopkg.in/h2non/gock.v1"
+)
+
+func TestDanmuReportUpList(t *testing.T) {
+	var (
+		c      = context.TODO()
+		mid    = int64(2089809)
+		pn     = int64(1)
+		ps     = int64(10)
+		aidStr = "1"
+		ip     = "127.0.0.1"
+	)
+	convey.Convey("ReportUpList", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("GET", d.dmReportUpListURL).Reply(200).JSON(`{"code":20043,"data":""}`)
+		result, total, err := d.ReportUpList(c, mid, pn, ps, aidStr, ip)
+		ctx.Convey("Then err should be nil.result,total should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+			ctx.So(total, convey.ShouldNotBeNil)
+			ctx.So(result, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDanmuReportUpArchives(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		ip  = "127.0.0.1"
+	)
+	convey.Convey("ReportUpArchives", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("GET", d.dmReportUpArchivesURL).Reply(200).JSON(`{"code":20043,"data":""}`)
+		ars, err := d.ReportUpArchives(c, mid, ip)
+		ctx.Convey("Then err should be nil.ars should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+			ctx.So(ars, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDanmuReportUpEdit(t *testing.T) {
+	var (
+		c    = context.TODO()
+		mid  = int64(2089809)
+		dmid = int64(1)
+		cid  = int64(1)
+		op   = int64(0)
+		ip   = "127.0.0.1"
+	)
+	convey.Convey("ReportUpEdit", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("POST", d.dmReportUpArchivesURL).Reply(200).JSON(`{"code":20043,"data":""}`)
+		err := d.ReportUpEdit(c, mid, dmid, cid, op, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}