Create & Init Project...

app/interface/main/creative/dao/assist/BUILD

@@ -0,0 +1,60 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "assist.go",
+        "dao.go",
+        "live.go",
+    ],
+    importpath = "go-common/app/interface/main/creative/dao/assist",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/creative/conf:go_default_library",
+        "//app/interface/main/creative/model/assist:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/time: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 = [
+        "assist_test.go",
+        "dao_test.go",
+        "live_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/creative/conf:go_default_library",
+        "//app/interface/main/creative/model/assist: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/assist/assist.go

@@ -0,0 +1,257 @@
+package assist
+
+import (
+	"context"
+	"go-common/app/interface/main/creative/model/assist"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/xstr"
+	"net/url"
+	"strconv"
+	"strings"
+)
+
+const (
+	// api
+	_addAssistURI        = "/x/internal/assist/add"
+	_delAssistURI        = "/x/internal/assist/del"
+	_getAssistInfoURI    = "/x/internal/assist/info"
+	_getAssistLogsURI    = "/x/internal/assist/logs"
+	_addAssistLogURI     = "/x/internal/assist/log/add"
+	_getAssistURI        = "/x/internal/assist/assists"
+	_getAssistLogInfoURI = "/x/internal/assist/log/info"
+	_revocAssistLogURI   = "/x/internal/assist/log/cancel"
+	_getAssistLogObjURI  = "/x/internal/assist/log/obj"
+	_getAssistStatURI    = "/x/internal/assist/stat"
+)
+
+// Assists get all Assists from assist service.
+func (d *Dao) Assists(c context.Context, mid int64, ip string) (assists []*assist.Assist, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int              `json:"code"`
+		Data []*assist.Assist `json:"data"`
+	}
+	if err = d.client.Get(c, d.assistListURL, ip, params, &res); err != nil {
+		log.Error("d.client.Get(%s,%s,%s) err(%v)", d.assistListURL, ip, params.Encode(), err)
+		err = ecode.CreativeAssistErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.client.Get(%s,%s,%s) err(%v)", d.assistListURL, ip, params.Encode(), err)
+		return
+	}
+	assists = res.Data
+	return
+}
+
+// AssistLog get assist log info from assist service
+func (d *Dao) AssistLog(c context.Context, mid, assistMid, logID int64, ip string) (assistLog *assist.AssistLog, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("assist_mid", strconv.FormatInt(assistMid, 10))
+	params.Set("log_id", strconv.FormatInt(logID, 10))
+	var res struct {
+		Code int               `json:"code"`
+		Data *assist.AssistLog `json:"data"`
+	}
+	if err = d.client.Get(c, d.assistLogInfoURL, ip, params, &res); err != nil {
+		log.Error("d.client.Get(%s,%s,%s) err(%v)", d.assistLogInfoURL, ip, params.Encode(), err)
+		err = ecode.CreativeAssistErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.client.Get(%s,%s,%s) err(%v)", d.assistLogInfoURL, ip, params.Encode(), err)
+		return
+	}
+	assistLog = res.Data
+	return
+}
+
+// AssistLogs get logs from assist service.
+func (d *Dao) AssistLogs(c context.Context, mid, assistMid, pn, ps, stime, etime int64, ip string) (logs []*assist.AssistLog, pager map[string]int64, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("assist_mid", strconv.FormatInt(assistMid, 10))
+	params.Set("pn", strconv.FormatInt(pn, 10))
+	params.Set("ps", strconv.FormatInt(ps, 10))
+	params.Set("stime", strconv.FormatInt(stime, 10))
+	params.Set("etime", strconv.FormatInt(etime, 10))
+	var res struct {
+		Code  int                 `json:"code"`
+		Data  []*assist.AssistLog `json:"data"`
+		Pager map[string]int64    `json:"pager"`
+	}
+	if err = d.client.Get(c, d.assistLogsURL, ip, params, &res); err != nil {
+		log.Error("d.client.Get(%s,%s,%s) err(%v)", d.assistLogsURL, ip, params.Encode(), err)
+		err = ecode.CreativeAssistErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.client.Get(%s,%s,%s) err(%v)", d.assistLogsURL, ip, params.Encode(), err)
+		return
+	}
+	for _, v := range res.Data {
+		if v.Type == 3 && v.Action == 8 {
+			detailT3A8 := strings.Split(v.Detail, ":")
+			if len(detailT3A8) > 1 {
+				v.Detail = " 用户UID:" + detailT3A8[len(detailT3A8)-1]
+			}
+		}
+		if v.Type == 3 && v.Action == 9 {
+			detailT3A9 := strings.Split(v.Detail, ":")
+			if len(detailT3A9) > 1 {
+				v.Detail = " 用户UID:" + detailT3A9[len(detailT3A9)-1]
+			}
+		}
+	}
+	logs = res.Data
+	pager = res.Pager
+	return
+}
+
+// AddAssist add assist
+func (d *Dao) AddAssist(c context.Context, mid, assistMid int64, ip, upUname string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("up_uname", upUname)
+	params.Set("assist_mid", strconv.FormatInt(assistMid, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	log.Info("AddOrDelAssist d.client.Post(%s,%s,%s) err(%v)", d.assistAddURL, ip, params.Encode(), err)
+	if err = d.client.Post(c, d.assistAddURL, ip, params, &res); err != nil {
+		log.Error("d.client.Post(%s,%s,%s) err(%v)", d.assistAddURL, ip, params.Encode(), err)
+		err = ecode.CreativeAssistErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.client.Post(%s,%s,%s) err(%v)", d.assistAddURL, ip, params.Encode(), err)
+		return
+	}
+	return
+}
+
+// DelAssist cancel assist
+func (d *Dao) DelAssist(c context.Context, mid, assistMid int64, ip, upUname string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("assist_mid", strconv.FormatInt(assistMid, 10))
+	params.Set("up_uname", upUname)
+	var res struct {
+		Code int `json:"code"`
+	}
+	log.Info("AddOrDelAssist d.client.Post(%s,%s,%s) err(%v)", d.assistDelURL, ip, params.Encode(), err)
+	if err = d.client.Post(c, d.assistDelURL, ip, params, &res); err != nil {
+		log.Error("d.client.Post(%s,%s,%s) err(%v)", d.assistDelURL, ip, params.Encode(), err)
+		err = ecode.CreativeAssistErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.client.Post(%s,%s,%s) err(%v)", d.assistDelURL, ip, params.Encode(), err)
+		return
+	}
+	return
+}
+
+// RevocAssistLog calcel assistlog action
+func (d *Dao) RevocAssistLog(c context.Context, mid, assistMid, logID int64, ip string) (err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("assist_mid", strconv.FormatInt(assistMid, 10))
+	params.Set("log_id", strconv.FormatInt(logID, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Post(c, d.assistLogRevocURL, ip, params, &res); err != nil {
+		log.Error("d.client.Post(%s,%s,%s) err(%v)", d.assistLogRevocURL, ip, params.Encode(), err)
+		err = ecode.CreativeAssistErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.client.Post(%s,%s,%s) err(%v)", d.assistLogRevocURL, ip, params.Encode(), err)
+		return
+	}
+	return
+}
+
+// Stat get assists stat
+func (d *Dao) Stat(c context.Context, mid int64, assistMids []int64, ip string) (stat map[int64]map[int8]map[int8]int, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("assmids", xstr.JoinInts(assistMids))
+	var res struct {
+		Code int                             `json:"code"`
+		Data map[int64]map[int8]map[int8]int `json:"data"`
+	}
+	if err = d.client.Get(c, d.assistStatURL, ip, params, &res); err != nil {
+		log.Error("d.client.Get(%s,%s,%s) err(%v)", d.assistStatURL, ip, params.Encode(), err)
+		err = ecode.CreativeAssistErr
+		return
+	}
+	if res.Code != 0 {
+		log.Error("d.client.Get(%s,%s,%s) err(%v)", d.assistStatURL, ip, params.Encode(), err)
+		err = ecode.Int(res.Code)
+		return
+	}
+	stat = res.Data
+	return
+}
+
+// Info  check if is assist
+func (d *Dao) Info(c context.Context, mid, assistMid int64, ip string) (assist int8, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("assist_mid", strconv.FormatInt(assistMid, 10))
+	params.Set("type", "1")
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Assist int8 `json:"assist"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.assistInfoURL, ip, params, &res); err != nil {
+		log.Error("d.client.Post(%s,%s,%s) err(%v)", d.assistInfoURL, ip, params.Encode(), err)
+		err = ecode.CreativeAssistErr
+		return
+	}
+	if res.Code != 0 {
+		log.Error("d.client.Post(%s,%s,%s) err(%v)", d.assistInfoURL, ip, params.Encode(), err)
+		err = ecode.Int(res.Code)
+		return
+	}
+	assist = res.Data.Assist
+	return
+}
+
+// AssistLogObj get assist log info from assist service
+func (d *Dao) AssistLogObj(c context.Context, tp, act int8, mid, objID int64) (assLog *assist.AssistLog, err error) {
+	params := url.Values{}
+	params.Set("type", strconv.FormatInt(int64(tp), 10))
+	params.Set("action", strconv.FormatInt(int64(act), 10))
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("object_id", strconv.FormatInt(objID, 10))
+	var res struct {
+		Code int               `json:"code"`
+		Data *assist.AssistLog `json:"data"`
+	}
+	if err = d.client.Get(c, d.assistLogObjURL, "", params, &res); err != nil {
+		log.Error("d.client.Get(%s,%s) err(%v)", d.assistLogObjURL, params.Encode(), err)
+		err = ecode.CreativeAssistErr
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("d.client.Get(%s,%s) err(%v)", d.assistLogObjURL, params.Encode(), err)
+		return
+	}
+	assLog = res.Data
+	return
+}

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

@@ -0,0 +1,248 @@
+package assist
+
+import (
+	"context"
+	"go-common/app/interface/main/creative/model/assist"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAssistAssists(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		ip  = ""
+	)
+	convey.Convey("Assists", t, func(ctx convey.C) {
+		var res = struct {
+			Code int              `json:"code"`
+			Data []*assist.Assist `json:"data"`
+		}{
+			Code: 0,
+			Data: []*assist.Assist{
+				{
+					AssistMid: 1,
+					Banned:    1,
+				},
+			},
+		}
+		httpMock("GET", d.assistListURL).Reply(200).JSON(res)
+		assists, err := d.Assists(c, mid, ip)
+		ctx.Convey("Then err should be nil.assists should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(assists, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+var assLogRes = struct {
+	Code int               `json:"code"`
+	Data *assist.AssistLog `json:"data"`
+}{
+	Code: 0,
+	Data: &assist.AssistLog{
+		ID:           1,
+		Mid:          0,
+		AssistMid:    0,
+		AssistAvatar: "",
+		AssistName:   "",
+		Type:         0,
+		Action:       0,
+		SubjectID:    0,
+		ObjectID:     "",
+		Detail:       "",
+		State:        0,
+		CTime:        0,
+	},
+}
+
+func TestAssistAssistLog(t *testing.T) {
+	var (
+		c         = context.TODO()
+		mid       = int64(0)
+		assistMid = int64(0)
+		logID     = int64(0)
+		ip        = ""
+	)
+	convey.Convey("AssistLog", t, func(ctx convey.C) {
+		httpMock("GET", d.assistLogInfoURL).Reply(200).JSON(assLogRes)
+		assistLog, err := d.AssistLog(c, mid, assistMid, logID, ip)
+		ctx.Convey("Then err should be nil.assistLog should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(assistLog, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestAssistAssistLogs(t *testing.T) {
+	var (
+		c         = context.TODO()
+		mid       = int64(0)
+		assistMid = int64(0)
+		pn        = int64(0)
+		ps        = int64(0)
+		stime     = int64(0)
+		etime     = int64(0)
+		ip        = ""
+		res       = struct {
+			Code  int                 `json:"code"`
+			Data  []*assist.AssistLog `json:"data"`
+			Pager map[string]int64    `json:"pager"`
+		}{
+			Code: 0,
+			Data: []*assist.AssistLog{
+				{
+					ID:           0,
+					Mid:          0,
+					AssistMid:    0,
+					AssistAvatar: "",
+					AssistName:   "",
+					Type:         0,
+					Action:       0,
+					SubjectID:    0,
+					ObjectID:     "",
+					Detail:       "",
+					State:        0,
+					CTime:        0,
+				},
+			},
+			Pager: map[string]int64{
+				"pn": 1,
+				"ps": 10,
+			},
+		}
+	)
+	convey.Convey("AssistLogs", t, func(ctx convey.C) {
+		httpMock("GET", d.assistLogsURL).Reply(200).JSON(res)
+		logs, pager, err := d.AssistLogs(c, mid, assistMid, pn, ps, stime, etime, ip)
+		ctx.Convey("Then err should be nil.logs,pager should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(pager, convey.ShouldNotBeNil)
+			ctx.So(logs, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestAssistAddAssist(t *testing.T) {
+	var (
+		c         = context.TODO()
+		mid       = int64(0)
+		assistMid = int64(0)
+		ip        = "127.0.0.1"
+		upUname   = "12"
+	)
+	convey.Convey("AddAssist", t, func(ctx convey.C) {
+		httpMock("POST", d.assistAddURL).Reply(200).JSON(`{"code":0}`)
+		err := d.AddAssist(c, mid, assistMid, ip, upUname)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestAssistDelAssist(t *testing.T) {
+	var (
+		c         = context.TODO()
+		mid       = int64(0)
+		assistMid = int64(0)
+		ip        = ""
+		upUname   = ""
+	)
+	convey.Convey("DelAssist", t, func(ctx convey.C) {
+		httpMock("POST", d.assistDelURL).Reply(200).JSON(`{"code":0}`)
+		err := d.DelAssist(c, mid, assistMid, ip, upUname)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestAssistRevocAssistLog(t *testing.T) {
+	var (
+		c         = context.TODO()
+		mid       = int64(0)
+		assistMid = int64(0)
+		logID     = int64(0)
+		ip        = ""
+	)
+	convey.Convey("RevocAssistLog", t, func(ctx convey.C) {
+		httpMock("POST", d.assistLogRevocURL).Reply(200).JSON(`{"code":0}`)
+		err := d.RevocAssistLog(c, mid, assistMid, logID, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestAssistStat(t *testing.T) {
+	var (
+		c          = context.TODO()
+		mid        = int64(0)
+		assistMids = []int64{}
+		ip         = ""
+		res        = struct {
+			Code int                             `json:"code"`
+			Data map[int64]map[int8]map[int8]int `json:"data"`
+		}{
+			Code: 0,
+			Data: map[int64]map[int8]map[int8]int{},
+		}
+	)
+	convey.Convey("Stat", t, func(ctx convey.C) {
+		httpMock("GET", d.assistStatURL).Reply(200).JSON(res)
+		stat, err := d.Stat(c, mid, assistMids, ip)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(stat, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestAssistInfo(t *testing.T) {
+	var (
+		c         = context.TODO()
+		mid       = int64(0)
+		assistMid = int64(0)
+		ip        = ""
+		res       = struct {
+			Code int `json:"code"`
+			Data struct {
+				Assist int8 `json:"assist"`
+			} `json:"data"`
+		}{
+			Code: 0,
+			Data: struct {
+				Assist int8 `json:"assist"`
+			}{
+				Assist: 1,
+			},
+		}
+	)
+	convey.Convey("Info", t, func(ctx convey.C) {
+		httpMock("GET", d.assistInfoURL).Reply(200).JSON(res)
+		assist, err := d.Info(c, mid, assistMid, ip)
+		ctx.Convey("Then err should be nil.assist should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(assist, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestAssistAssistLogObj(t *testing.T) {
+	var (
+		c     = context.TODO()
+		tp    = int8(0)
+		act   = int8(0)
+		mid   = int64(0)
+		objID = int64(0)
+	)
+	convey.Convey("AssistLogObj", t, func(ctx convey.C) {
+		httpMock("GET", d.assistLogObjURL).Reply(200).JSON(assLogRes)
+		assLog, err := d.AssistLogObj(c, tp, act, mid, objID)
+		ctx.Convey("Then err should be nil.assLog should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(assLog, convey.ShouldNotBeNil)
+		})
+	})
+}

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

@@ -0,0 +1,56 @@
+package assist
+
+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
+	assistLogsURL      string
+	assistListURL      string
+	assistInfoURL      string
+	assistLogInfoURL   string
+	assistAddURL       string
+	assistDelURL       string
+	assistLogAddURL    string
+	assistLogRevocURL  string
+	assistStatURL      string
+	assistLogObjURL    string
+	liveStatusURL      string
+	liveAddAssistURL   string
+	liveDelAssistURL   string
+	liveRevocBannedURL string
+	liveAssistsURL     string
+	liveCheckAssURL    string
+}
+
+// New init api url
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:                  c,
+		client:             bm.NewClient(c.HTTPClient.Normal),
+		assistAddURL:       c.Host.API + _addAssistURI,
+		assistDelURL:       c.Host.API + _delAssistURI,
+		assistInfoURL:      c.Host.API + _getAssistInfoURI,
+		assistLogInfoURL:   c.Host.API + _getAssistLogInfoURI,
+		assistLogsURL:      c.Host.API + _getAssistLogsURI,
+		assistLogAddURL:    c.Host.API + _addAssistLogURI,
+		assistListURL:      c.Host.API + _getAssistURI,
+		assistLogRevocURL:  c.Host.API + _revocAssistLogURI,
+		assistStatURL:      c.Host.API + _getAssistStatURI,
+		assistLogObjURL:    c.Host.API + _getAssistLogObjURI,
+		liveStatusURL:      c.Host.Live + _liveStatus,
+		liveAddAssistURL:   c.Host.Live + _liveAddAssist,
+		liveDelAssistURL:   c.Host.Live + _liveDelAssist,
+		liveRevocBannedURL: c.Host.Live + _liveRevocBanned,
+		liveAssistsURL:     c.Host.Live + _liveAssists,
+		liveCheckAssURL:    c.Host.Live + _liveCheckAssist,
+	}
+	return
+}

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

@@ -0,0 +1,45 @@
+package assist
+
+import (
+	"flag"
+	"go-common/app/interface/main/creative/conf"
+	"os"
+	"strings"
+	"testing"
+
+	"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/assist/live.go

@@ -0,0 +1,231 @@
+package assist
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/creative/model/assist"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	gtime "go-common/library/time"
+)
+
+const (
+	// api
+	_liveStatus      = "/user/v1/UserRoom/isAnchor"
+	_liveAddAssist   = "/live_user/v1/RoomAdmin/add"
+	_liveDelAssist   = "/live_user/v1/RoomAdmin/del"
+	_liveRevocBanned = "/live_user/v1/RoomSilent/del"
+	_liveAssists     = "/live_user/v1/RoomAdmin/get_by_anchor"
+	_liveCheckAssist = "/live_user/v1/RoomAdmin/is_admin"
+)
+
+// LiveStatus check if user opened live room. 0:yes 500401: no
+func (d *Dao) LiveStatus(c context.Context, mid int64, ip string) (ok int8, err error) {
+	var req *http.Request
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	if req, err = http.NewRequest("GET", d.liveStatusURL+"?"+params.Encode(), nil); err != nil {
+		log.Error("LiveStatus url(%s) error(%v)", d.liveStatusURL+"?"+params.Encode(), err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	req.Header.Set("X-BiliLive-UID", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		log.Error("LiveStatus url(%s) response(%+v) error(%v)", d.liveStatusURL+"?"+params.Encode(), res, err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	if res.Code == 500401 {
+		return
+	}
+	if res.Code != 0 {
+		log.Error("LiveStatus url(%s) res(%v)", d.liveStatusURL+"?"+params.Encode(), res)
+		err = ecode.Int(res.Code)
+		return
+	}
+	ok = 1
+	return
+}
+
+// LiveAddAssist add assist in live room   120013: 直播间不存在
+func (d *Dao) LiveAddAssist(c context.Context, mid, assistMid int64, cookie, ip string) (err error) {
+	var req *http.Request
+	params := url.Values{}
+	params.Set("admin", strconv.FormatInt(assistMid, 10))
+	params.Set("anchor_id", strconv.FormatInt(mid, 10))
+	if req, err = http.NewRequest("POST", d.liveAddAssistURL+"?"+params.Encode(), nil); err != nil {
+		log.Error("LiveAddAssist url(%s) error(%v)", d.liveAddAssistURL+"?"+params.Encode(), err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	req.Header.Set("X-BiliLive-UID", strconv.FormatInt(mid, 10))
+	req.Header.Set("Cookie", cookie)
+	var res struct {
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		log.Error("LiveAddAssist url(%s) response(%+v) error(%v)", d.liveAddAssistURL+"?"+params.Encode(), res, err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	if res.Code == 120013 {
+		log.Error("LiveAddAssist url(%s) mid(%d) not opened(%v)", d.liveAddAssistURL+"?"+params.Encode(), mid, 120013)
+		err = ecode.CreativeLiveNotOpenErr
+		return
+	}
+	if res.Code != 0 {
+		log.Error("LiveAddAssist url(%s) res(%v)", d.liveAddAssistURL+"?"+params.Encode(), res)
+		err = ecode.Int(res.Code)
+		return
+	}
+	return
+}
+
+// LiveDelAssist del assist in live room
+func (d *Dao) LiveDelAssist(c context.Context, mid, assistMid int64, cookie, ip string) (err error) {
+	var req *http.Request
+	params := url.Values{}
+	params.Set("admin", strconv.FormatInt(assistMid, 10))
+	params.Set("anchor_id", strconv.FormatInt(mid, 10))
+	if req, err = http.NewRequest("POST", d.liveDelAssistURL+"?"+params.Encode(), nil); err != nil {
+		log.Error("LiveDelAssist url(%s) error(%v)", d.liveDelAssistURL+"?"+params.Encode(), err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	req.Header.Set("X-BiliLive-UID", strconv.FormatInt(mid, 10))
+	req.Header.Set("Cookie", cookie)
+	var res struct {
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		log.Error("LiveDelAssist url(%s) response(%+v) error(%v)", d.liveDelAssistURL+"?"+params.Encode(), res, err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	if res.Code == 120013 {
+		log.Error("LiveDelAssist url(%s) mid(%d) not opened(%v)", d.liveDelAssistURL+"?"+params.Encode(), mid, 120013)
+		err = ecode.CreativeLiveNotOpenErr
+		return
+	}
+	if res.Code != 0 {
+		log.Error("LiveDelAssist url(%s) res(%v)", d.liveDelAssistURL+"?"+params.Encode(), res)
+		err = ecode.Int(res.Code)
+		return
+	}
+	return
+}
+
+// LiveBannedRevoc recover assist banned state
+func (d *Dao) LiveBannedRevoc(c context.Context, mid int64, banID, cookie, ip string) (err error) {
+	var req *http.Request
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	params.Set("id", banID)
+	if req, err = http.NewRequest("POST", d.liveRevocBannedURL+"?"+params.Encode(), nil); err != nil {
+		log.Error("liveRevocBanned url(%s) error(%v)", d.liveRevocBannedURL+"?"+params.Encode(), err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	req.Header.Set("X-BiliLive-UID", strconv.FormatInt(mid, 10))
+	req.Header.Set("Cookie", cookie)
+	var res struct {
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		log.Error("liveRevocBanned url(%s) response(%+v) error(%v)", d.liveRevocBannedURL+"?"+params.Encode(), res, err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	if res.Code != 0 {
+		log.Error("liveRevocBanned url(%s) res(%v)", d.liveRevocBannedURL+"?"+params.Encode(), res)
+		err = ecode.Int(res.Code)
+		return
+	}
+	return
+}
+
+// LiveAssists get assists from live
+func (d *Dao) LiveAssists(c context.Context, mid int64, ip string) (assists []*assist.LiveAssist, err error) {
+	var req *http.Request
+	params := url.Values{}
+	params.Set("anchor_id", strconv.FormatInt(mid, 10))
+	if req, err = http.NewRequest("GET", d.liveAssistsURL+"?"+params.Encode(), nil); err != nil {
+		log.Error("LiveAssists url(%s) error(%v)", d.liveAssistsURL+"?"+params.Encode(), err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	req.Header.Set("X-BiliLive-UID", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int                  `json:"code"`
+		Data []*assist.LiveAssist `json:"data"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		log.Error("LiveAssists url(%s) response(%+v) error(%v)", d.liveAssistsURL+"?"+params.Encode(), res, err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	if res.Code == 120013 {
+		err = nil
+		return
+	}
+	if res.Code != 0 {
+		log.Error("LiveAssists url(%s) res(%v)", d.liveAssistsURL+"?"+params.Encode(), res)
+		err = ecode.Int(res.Code)
+		return
+	}
+	assists = res.Data
+	// set ctime
+	for _, ass := range assists {
+		intTime, err := time.Parse("2006-01-02 15:04:05", ass.Datetime)
+		if err == nil {
+			var ctime gtime.Time
+			ctime.Scan(intTime)
+			ass.CTime = ctime - 8*3600 // adjust timezone for fe
+		}
+	}
+	return
+}
+
+// LiveCheckAssist check assist in live room
+func (d *Dao) LiveCheckAssist(c context.Context, mid, assistMid int64, ip string) (isAss int8, err error) {
+	var req *http.Request
+	params := url.Values{}
+	params.Set("uid", strconv.FormatInt(assistMid, 10))
+	params.Set("anchor_id", strconv.FormatInt(mid, 10))
+	if req, err = http.NewRequest("POST", d.liveCheckAssURL+"?"+params.Encode(), nil); err != nil {
+		log.Error("LiveCheckAssist url(%s) error(%v)", d.liveCheckAssURL+"?"+params.Encode(), err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	req.Header.Set("X-BiliLive-UID", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		log.Error("LiveCheckAssist url(%s) response(%+v) error(%v)", d.liveCheckAssURL+"?"+params.Encode(), res, err)
+		err = ecode.CreativeLiveErr
+		return
+	}
+	if res.Code == 120013 {
+		log.Error("LiveCheckAssist url(%s) mid(%d) not opened(%v)", d.liveCheckAssURL+"?"+params.Encode(), mid, 120013)
+		err = ecode.CreativeLiveNotOpenErr
+		return
+	}
+	if res.Code != 0 {
+		log.Error("LiveCheckAssist url(%s) res(%v)", d.liveCheckAssURL+"?"+params.Encode(), res)
+		err = ecode.Int(res.Code)
+		return
+	}
+	isAss = 1
+	return
+}

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

@@ -0,0 +1,159 @@
+package assist
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+	"testing"
+
+	"go-common/app/interface/main/creative/model/assist"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAssistLiveStatus(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		ip  = ""
+		res = struct {
+			Code int `json:"code"`
+		}{
+			Code: 0,
+		}
+	)
+	convey.Convey("LiveStatus", t, func(ctx convey.C) {
+		httpMock("GET", d.liveStatusURL+"?uid="+strconv.FormatInt(mid, 10)).Reply(0).JSON(res)
+		ok, err := d.LiveStatus(c, mid, ip)
+		ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(ok, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+var msgRes = struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}{
+	Code:    0,
+	Message: "message",
+}
+
+func TestAssistLiveAddAssist(t *testing.T) {
+	var (
+		c         = context.TODO()
+		mid       = int64(1)
+		assistMid = int64(10)
+		cookie    = ""
+		ip        = ""
+		params    = url.Values{}
+	)
+	params.Set("admin", strconv.FormatInt(assistMid, 10))
+	params.Set("anchor_id", strconv.FormatInt(mid, 10))
+	convey.Convey("LiveAddAssist", t, func(ctx convey.C) {
+		httpMock("POST", d.liveAddAssistURL+"?"+params.Encode()).
+			Reply(0).JSON(msgRes)
+		err := d.LiveAddAssist(c, mid, assistMid, cookie, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestAssistLiveDelAssist(t *testing.T) {
+	var (
+		c         = context.TODO()
+		mid       = int64(0)
+		assistMid = int64(0)
+		cookie    = ""
+		ip        = ""
+		params    = url.Values{}
+	)
+	params.Set("admin", strconv.FormatInt(assistMid, 10))
+	params.Set("anchor_id", strconv.FormatInt(mid, 10))
+	convey.Convey("LiveDelAssist", t, func(ctx convey.C) {
+		httpMock("POST", d.liveDelAssistURL+"?"+params.Encode()).Reply(0).JSON(msgRes)
+		err := d.LiveDelAssist(c, mid, assistMid, cookie, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestAssistLiveBannedRevoc(t *testing.T) {
+	var (
+		c      = context.TODO()
+		mid    = int64(0)
+		banID  = ""
+		cookie = ""
+		ip     = ""
+		params = url.Values{}
+	)
+	params.Set("uid", strconv.FormatInt(mid, 10))
+	params.Set("id", banID)
+	convey.Convey("LiveBannedRevoc", t, func(ctx convey.C) {
+		httpMock("POST", d.liveRevocBannedURL+"?"+params.Encode()).Reply(200).JSON(msgRes)
+		err := d.LiveBannedRevoc(c, mid, banID, cookie, ip)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestAssistLiveAssists(t *testing.T) {
+	var (
+		c      = context.TODO()
+		mid    = int64(0)
+		ip     = ""
+		params = url.Values{}
+		res    = struct {
+			Code int                  `json:"code"`
+			Data []*assist.LiveAssist `json:"data"`
+		}{
+			Code: 0,
+			Data: []*assist.LiveAssist{
+				{
+					AssistMid: 0,
+					RoomID:    0,
+					CTime:     0,
+					Datetime:  "",
+				},
+			},
+		}
+	)
+	params.Set("anchor_id", strconv.FormatInt(mid, 10))
+	convey.Convey("LiveAssists", t, func(ctx convey.C) {
+		httpMock("GET", d.liveAssistsURL+"?"+params.Encode()).Reply(200).JSON(res)
+		assists, err := d.LiveAssists(c, mid, ip)
+		ctx.Convey("Then err should be nil.assists should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(assists, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestAssistLiveCheckAssist(t *testing.T) {
+	var (
+		c         = context.TODO()
+		mid       = int64(0)
+		assistMid = int64(0)
+		ip        = ""
+		params    = url.Values{}
+		res       = struct {
+			Code int `json:"code"`
+		}{
+			Code: 0,
+		}
+	)
+	params.Set("uid", strconv.FormatInt(assistMid, 10))
+	params.Set("anchor_id", strconv.FormatInt(mid, 10))
+	convey.Convey("LiveCheckAssist", t, func(ctx convey.C) {
+		httpMock("POST", d.liveCheckAssURL+"?"+params.Encode()).Reply(200).JSON(res)
+		isAss, err := d.LiveCheckAssist(c, mid, assistMid, ip)
+		ctx.Convey("Then err should be nil.isAss should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(isAss, convey.ShouldNotBeNil)
+		})
+	})
+}