Create & Init Project...

app/admin/main/credit/dao/account/BUILD

@@ -0,0 +1,50 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/credit/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/admin/main/credit/dao/account",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/credit/conf:go_default_library",
+        "//app/admin/main/credit/model:go_default_library",
+        "//app/admin/main/credit/model/blocked:go_default_library",
+        "//app/service/main/account/api:go_default_library",
+        "//library/log:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/credit/dao/account/dao.go

@@ -0,0 +1,82 @@
+package account
+
+import (
+	"context"
+	"sync"
+
+	"github.com/pkg/errors"
+
+	"go-common/app/admin/main/credit/conf"
+	creditMDL "go-common/app/admin/main/credit/model"
+	blocked "go-common/app/admin/main/credit/model/blocked"
+	accgrpc "go-common/app/service/main/account/api"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+)
+
+// Dao is account dao.
+type Dao struct {
+	// grpc
+	accountClient accgrpc.AccountClient
+}
+
+// New is initial for account .
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{}
+	var err error
+	if d.accountClient, err = accgrpc.NewClient(c.AccClient); err != nil {
+		panic(errors.WithMessage(err, "Failed to dial account service"))
+	}
+	return
+}
+
+// RPCInfo rpc info get by  muti mid .
+func (d *Dao) RPCInfo(c context.Context, mid int64) (res *accgrpc.InfoReply, err error) {
+	arg := &accgrpc.MidReq{Mid: mid}
+	if res, err = d.accountClient.Info3(c, arg); err != nil {
+		log.Error("d.accountClient.Info3 error(%v)", err)
+	}
+	return
+}
+
+// RPCInfos rpc info get by  muti mid .
+func (d *Dao) RPCInfos(c context.Context, mids []int64) (res map[int64]*accgrpc.Info, err error) {
+	var (
+		g      errgroup.Group
+		l      sync.RWMutex
+		args   *accgrpc.MidsReq
+		accRes *accgrpc.InfosReply
+	)
+	mids = creditMDL.ArrayUnique(mids)
+	total := len(mids)
+	pageNum := total / blocked.AccMaxPageSize
+	if total%blocked.AccMaxPageSize != 0 {
+		pageNum++
+	}
+	res = make(map[int64]*accgrpc.Info, total)
+	for i := 0; i < pageNum; i++ {
+		start := i * blocked.AccMaxPageSize
+		end := (i + 1) * blocked.AccMaxPageSize
+		if end > total {
+			end = total
+		}
+		g.Go(func() (err error) {
+			args = &accgrpc.MidsReq{Mids: mids[start:end]}
+			if accRes, err = d.accountClient.Infos3(c, args); err != nil {
+				log.Error("d.accountClient.Infos3(%+v) error(%v)", mids[start:end], err)
+				err = nil
+				return
+			}
+			for mid, info := range accRes.Infos {
+				l.Lock()
+				res[mid] = info
+				l.Unlock()
+			}
+			return
+		})
+	}
+	if err = g.Wait(); err != nil {
+		log.Error("g.Wait error(%v)", err)
+	}
+	return
+}

app/admin/main/credit/dao/account/dao_test.go

@@ -0,0 +1,54 @@
+package account
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/credit/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account-law.credit-admin")
+		flag.Set("conf_appid", "main.account-law.credit-admin")
+		flag.Set("conf_token", "eKmbn2M4jvSyyjMEOywLFOQlX5ggRG9x")
+		flag.Set("tree_id", "5885")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_env", "10")
+		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/convey-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func Test_RPCInfo(t *testing.T) {
+	Convey("return someting", t, func() {
+		res, err := d.RPCInfo(context.TODO(), 88889021)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func Test_RPCInfos(t *testing.T) {
+	Convey("return someting", t, func() {
+		res, err := d.RPCInfos(context.TODO(), []int64{88889021})
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}

app/admin/main/credit/dao/blocked/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/credit/conf:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//vendor/github.com/jinzhu/gorm: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/admin/main/credit/dao/blocked",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/credit/conf:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/jinzhu/gorm: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/admin/main/credit/dao/blocked/dao.go

@@ -0,0 +1,63 @@
+package blocked
+
+import (
+	"context"
+
+	"go-common/app/admin/main/credit/conf"
+	"go-common/library/database/orm"
+	bm "go-common/library/net/http/blademaster"
+
+	"github.com/jinzhu/gorm"
+)
+
+// Dao struct info of Dao.
+type Dao struct {
+	// mysql
+	ReadDB *gorm.DB
+	DB     *gorm.DB
+	// http
+	client *bm.Client
+	// conf
+	c *conf.Config
+}
+
+// New new a Dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// conf
+		c: c,
+		// http client
+		client: bm.NewClient(c.HTTPClient),
+		ReadDB: orm.NewMySQL(c.ORM.Read),
+		DB:     orm.NewMySQL(c.ORM.Write),
+	}
+	d.initORM()
+	return
+}
+
+func (d *Dao) initORM() {
+	d.ReadDB.LogMode(true)
+	d.DB.LogMode(true)
+}
+
+// Close close dao.
+func (d *Dao) Close() {
+	if d.ReadDB != nil {
+		d.ReadDB.Close()
+	}
+	if d.DB != nil {
+		d.DB.Close()
+	}
+}
+
+// Ping check connection of db , mc.
+func (d *Dao) Ping(c context.Context) (err error) {
+	if d.ReadDB != nil {
+		err = d.ReadDB.DB().PingContext(c)
+		return
+	}
+	if d.DB != nil {
+		err = d.DB.DB().PingContext(c)
+	}
+	return
+}

app/admin/main/credit/dao/blocked/dao_test.go

@@ -0,0 +1,69 @@
+package blocked
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/credit/conf"
+	_ "go-common/library/database/orm"
+
+	_ "github.com/jinzhu/gorm"
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account-law.credit-admin")
+		flag.Set("conf_appid", "main.account-law.credit-admin")
+		flag.Set("conf_token", "eKmbn2M4jvSyyjMEOywLFOQlX5ggRG9x")
+		flag.Set("tree_id", "5885")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_env", "10")
+		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/convey-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func WithDao(f func(d *Dao)) func() {
+	return func() {
+		f(d)
+	}
+}
+
+func WithMysql(f func(d *Dao)) func() {
+	return func() {
+		f(d)
+	}
+}
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func Test_initORM(t *testing.T) {
+	Convey("not need return", t, func() {
+		d.initORM()
+	})
+}
+
+func Test_Ping(t *testing.T) {
+	Convey("return someting", t, func() {
+		err := d.Ping(context.TODO())
+		So(err, ShouldBeNil)
+	})
+}

app/admin/main/credit/dao/manager/BUILD

@@ -0,0 +1,48 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/credit/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/admin/main/credit/dao/manager",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/credit/conf:go_default_library",
+        "//app/admin/main/credit/model:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/sync/errgroup: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/admin/main/credit/dao/manager/dao.go

@@ -0,0 +1,131 @@
+package manager
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+	"sync"
+
+	"go-common/app/admin/main/credit/conf"
+	"go-common/app/admin/main/credit/model"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/sync/errgroup"
+)
+
+const (
+	_managersURI     = "/x/admin/manager/users"
+	_managerTotalURI = "/x/admin/manager/users/total"
+)
+
+// Dao struct info of Dao.
+type Dao struct {
+	// http
+	client *bm.Client
+	// conf
+	c               *conf.Config
+	managersURL     string
+	managerTotalURL string
+}
+
+// New new a Dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// conf
+		c: c,
+		// http client
+		client: bm.NewClient(c.HTTPClient),
+	}
+	d.managersURL = c.Host.Manager + _managersURI
+	d.managerTotalURL = c.Host.Manager + _managerTotalURI
+	return
+}
+
+// Managers get manager users info.
+func (d *Dao) Managers(c context.Context) (manMap map[int64]string, err error) {
+	var (
+		count, page int64
+		g           errgroup.Group
+		l           sync.RWMutex
+	)
+	if count, err = d.ManagerTotal(c); err != nil {
+		log.Error("d.ManagerTotal error(%v)", err)
+		return
+	}
+	if count <= 0 {
+		return
+	}
+	manMap = make(map[int64]string, count)
+	ps := int64(500)
+	pageNum := count / ps
+	if count%ps != 0 {
+		pageNum++
+	}
+	for page = 1; page <= pageNum; page++ {
+		tmpPage := page
+		g.Go(func() (err error) {
+			mi, err := d.Manager(c, tmpPage, ps)
+			if err != nil {
+				log.Error("d.Manager(%d,%d) error(%v) ", tmpPage, ps, err)
+				err = nil
+				return
+			}
+			for _, v := range mi {
+				l.Lock()
+				manMap[v.OID] = v.Uname
+				l.Unlock()
+			}
+			return
+		})
+	}
+	g.Wait()
+	return
+}
+
+// Manager  get manager users.
+func (d *Dao) Manager(c context.Context, pn, ps int64) (mi []*model.MangerInfo, err error) {
+	params := url.Values{}
+	params.Set("pn", strconv.FormatInt(pn, 10))
+	params.Set("ps", strconv.FormatInt(ps, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Items []*model.MangerInfo `json:"items"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.managersURL, "", params, &res); err != nil {
+		log.Error("Manager(%s) error(%v)", d.managersURL+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		log.Warn("Manager(%s) code(%d) data(%+v)", d.managersURL+"?"+params.Encode(), res.Code, res.Data)
+		return
+	}
+	if res.Data != nil {
+		mi = res.Data.Items
+	}
+	return
+}
+
+// ManagerTotal get manager user total.
+func (d *Dao) ManagerTotal(c context.Context) (count int64, err error) {
+	params := url.Values{}
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Total int64 `json:"total"`
+		} `json:"data"`
+	}
+	if err = d.client.Get(c, d.managerTotalURL, "", params, &res); err != nil {
+		log.Error("ManagerTotal(%s) error(%v)", d.managerTotalURL+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		log.Warn("ManagerTotal(%s) code(%d) data(%+v)", d.managerTotalURL+"?"+params.Encode(), res.Code, res.Data)
+		return
+	}
+	if res.Data != nil {
+		count = res.Data.Total
+	}
+	return
+}

app/admin/main/credit/dao/manager/dao_test.go

@@ -0,0 +1,72 @@
+package manager
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/credit/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account-law.credit-admin")
+		flag.Set("conf_appid", "main.account-law.credit-admin")
+		flag.Set("conf_token", "eKmbn2M4jvSyyjMEOywLFOQlX5ggRG9x")
+		flag.Set("tree_id", "5885")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_env", "10")
+		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/convey-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func WithDao(f func(d *Dao)) func() {
+	return func() {
+		f(d)
+	}
+}
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func Test_Managers(t *testing.T) {
+	Convey("return someting", t, func() {
+		res, err := d.Managers(context.TODO())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func Test_Manager(t *testing.T) {
+	Convey("return someting", t, func() {
+		res, err := d.Manager(context.TODO(), 1, 2)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}
+
+func Test_ManagerTotal(t *testing.T) {
+	Convey("return someting", t, func() {
+		res, err := d.ManagerTotal(context.TODO())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}

app/admin/main/credit/dao/msg/BUILD

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

@@ -0,0 +1,68 @@
+package msg
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"go-common/app/admin/main/credit/conf"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+const (
+	_msgURL = "/api/notify/send.user.notify.do"
+)
+
+// Dao struct info of Dao.
+type Dao struct {
+	// http
+	client *bm.Client
+	// conf
+	c      *conf.Config
+	msgURL string
+}
+
+// New new a Dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// conf
+		c: c,
+		// http client
+		client: bm.NewClient(c.HTTPClient),
+	}
+	d.msgURL = c.Host.Msg + _msgURL
+	return
+}
+
+// SendSysMsg send sys msg.
+func (dao *Dao) SendSysMsg(c context.Context, mid int64, title string, context string) (err error) {
+	params := url.Values{}
+	params.Set("mc", "2_1_13")
+	params.Set("title", title)
+	params.Set("data_type", "4")
+	params.Set("context", context)
+	params.Set("mid_list", fmt.Sprintf("%d", mid))
+	var res struct {
+		Code int `json:"code"`
+		Data *struct {
+			Status int8   `json:"status"`
+			Remark string `json:"remark"`
+		} `json:"data"`
+	}
+	for i := 0; i <= 5; i++ {
+		if err = dao.client.Post(c, dao.msgURL, metadata.String(c, metadata.RemoteIP), params, &res); err != nil {
+			log.Error("sendMsgURI(%s) error(%v)", dao.msgURL+"?"+params.Encode(), err)
+			continue
+		}
+		if res.Code != 0 {
+			log.Error("sendMsgURI(%s) error(%v)", dao.msgURL+"?"+params.Encode(), res.Code)
+			err = ecode.Int(res.Code)
+			continue
+		}
+		return
+	}
+	return
+}

app/admin/main/credit/dao/msg/dao_test.go

@@ -0,0 +1,45 @@
+package msg
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/credit/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account-law.credit-admin")
+		flag.Set("conf_appid", "main.account-law.credit-admin")
+		flag.Set("conf_token", "eKmbn2M4jvSyyjMEOywLFOQlX5ggRG9x")
+		flag.Set("tree_id", "5885")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_env", "10")
+		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/convey-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func Test_SendSysMsg(t *testing.T) {
+	Convey("return someting", t, func() {
+		err := d.SendSysMsg(context.TODO(), 212213, "", "")
+		So(err, ShouldBeNil)
+	})
+}

app/admin/main/credit/dao/relation/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/admin/main/credit/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/admin/main/credit/dao/relation",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/credit/conf:go_default_library",
+        "//app/service/main/relation/model:go_default_library",
+        "//app/service/main/relation/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/admin/main/credit/dao/relation/dao.go

@@ -0,0 +1,33 @@
+package relation
+
+import (
+	"context"
+
+	"go-common/app/admin/main/credit/conf"
+	relationmdl "go-common/app/service/main/relation/model"
+	relationrpc "go-common/app/service/main/relation/rpc/client"
+	"go-common/library/log"
+)
+
+// Dao is account dao.
+type Dao struct {
+	// rpc
+	relationRPC *relationrpc.Service
+}
+
+// New is initial for account .
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		relationRPC: relationrpc.New(c.RPCClient.Relation),
+	}
+	return
+}
+
+// RPCStats rpc info get by  muti mid .
+func (d *Dao) RPCStats(c context.Context, mids []int64) (res map[int64]*relationmdl.Stat, err error) {
+	arg := &relationmdl.ArgMids{Mids: mids}
+	if res, err = d.relationRPC.Stats(c, arg); err != nil {
+		log.Error("d.relationRPC.Stats error(%v)", err)
+	}
+	return
+}

app/admin/main/credit/dao/relation/dao_test.go

@@ -0,0 +1,50 @@
+package relation
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/credit/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account-law.credit-admin")
+		flag.Set("conf_appid", "main.account-law.credit-admin")
+		flag.Set("conf_token", "eKmbn2M4jvSyyjMEOywLFOQlX5ggRG9x")
+		flag.Set("tree_id", "5885")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_env", "10")
+		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/convey-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func TestDaoRPCStats(t *testing.T) {
+	Convey("return someting", t, func() {
+		res, err := d.RPCStats(context.TODO(), []int64{88889018, 2089809})
+		for _, re := range res {
+			fmt.Printf("re:%#v \n", re)
+		}
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	})
+}

app/admin/main/credit/dao/search/BUILD

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

app/admin/main/credit/dao/search/dao.go

@@ -0,0 +1,226 @@
+package search
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/credit/conf"
+	"go-common/app/admin/main/credit/model"
+	"go-common/app/admin/main/credit/model/blocked"
+	"go-common/app/admin/main/credit/model/search"
+	"go-common/library/database/elastic"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+// Dao .
+type Dao struct {
+	elastic *elastic.Elastic
+}
+
+// New .
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		elastic: elastic.NewElastic(nil),
+	}
+	return
+}
+
+// Blocked get search blocked.
+func (d *Dao) Blocked(c context.Context, arg *blocked.ArgBlockedSearch) (ids []int64, pager *blocked.Pager, err error) {
+	req := d.elastic.NewRequest(blocked.BusinessBlockedInfo).Index(blocked.TableBlockedInfo).Fields("id")
+	if arg.Keyword != blocked.SearchDefaultString {
+		req.WhereLike([]string{"origin_content"}, []string{arg.Keyword}, true, elastic.LikeLevelHigh)
+	}
+	if arg.UID != blocked.SearchDefaultNum {
+		req.WhereEq("uid", arg.UID)
+	}
+	if arg.OPID != blocked.SearchDefaultNum {
+		req.WhereEq("oper_id", arg.OPID)
+	}
+	if arg.OriginType != blocked.SearchDefaultNum {
+		req.WhereEq("origin_type", arg.OriginType)
+	}
+	if arg.BlockedType != blocked.SearchDefaultNum {
+		req.WhereEq("blocked_type", arg.BlockedType)
+	}
+	if arg.PublishStatus != blocked.SearchDefaultNum {
+		req.WhereEq("publish_status", arg.PublishStatus)
+	}
+	req.WhereRange("punish_time", arg.Start, arg.End, elastic.RangeScopeLcRc)
+	req.WhereEq("status", blocked.SearchDefaultStatus)
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// Publish get search publish.
+func (d *Dao) Publish(c context.Context, arg *blocked.ArgPublishSearch) (ids []int64, pager *blocked.Pager, err error) {
+	req := d.elastic.NewRequest(blocked.BusinessBlockedPublish).Index(blocked.TableBlockedPublish).Fields("id")
+	if arg.Keyword != blocked.SearchDefaultString {
+		req.WhereLike([]string{"title", "sub_title"}, []string{arg.Keyword}, true, elastic.LikeLevelHigh)
+	}
+	if arg.Type != blocked.SearchDefaultNum {
+		req.WhereEq("ptype", arg.Type)
+	}
+	req.WhereRange("show_time", arg.ShowFrom, arg.ShowTo, elastic.RangeScopeLcRc)
+	req.WhereEq("status", blocked.SearchDefaultStatus)
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// Case get search case.
+func (d *Dao) Case(c context.Context, arg *blocked.ArgCaseSearch) (ids []int64, pager *blocked.Pager, err error) {
+	req := d.elastic.NewRequest(blocked.BusinessBlockedCase).Index(blocked.TableBlockedCase).Fields("id")
+	if arg.Keyword != blocked.SearchDefaultString {
+		req.WhereLike([]string{"origin_content"}, []string{arg.Keyword}, true, elastic.LikeLevelHigh)
+	}
+	if arg.OriginType != blocked.SearchDefaultNum {
+		req.WhereEq("origin_type", arg.OriginType)
+	}
+	if arg.Status != blocked.SearchDefaultNum {
+		req.WhereEq("status", arg.Status)
+	}
+	if arg.CaseType != blocked.SearchDefaultNum {
+		req.WhereEq("case_type", arg.CaseType)
+	}
+	if arg.UID != blocked.SearchDefaultNum {
+		req.WhereEq("mid", arg.UID)
+	}
+	if arg.OPID != blocked.SearchDefaultNum {
+		req.WhereEq("oper_id", arg.OPID)
+	}
+	req.WhereRange("start_time", arg.TimeFrom, arg.TimeTo, elastic.RangeScopeLcRc)
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// Jury get search jury.
+func (d *Dao) Jury(c context.Context, arg *blocked.ArgJurySearch) (ids []int64, pager *blocked.Pager, err error) {
+	req := d.elastic.NewRequest(blocked.BusinessBlockedJury).Index(blocked.TableBlockedJury).Fields("id")
+	if arg.UID != blocked.SearchDefaultNum {
+		req.WhereEq("mid", arg.UID)
+	}
+	if arg.Status != blocked.SearchDefaultNum {
+		req.WhereEq("status", arg.Status)
+	}
+	if arg.Black != blocked.SearchDefaultNum {
+		req.WhereEq("black", arg.Black)
+	}
+	req.WhereRange("expired", arg.ExpiredFrom, arg.ExpiredTo, elastic.RangeScopeLcRc)
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// Opinion get search opinion.
+func (d *Dao) Opinion(c context.Context, arg *blocked.ArgOpinionSearch) (ids []int64, pager *blocked.Pager, err error) {
+	req := d.elastic.NewRequest(blocked.BusinessBlockedOpinion).Index(blocked.TableBlockedOpinion).Fields("id")
+	if arg.UID != blocked.SearchDefaultNum {
+		req.WhereEq("mid", arg.UID)
+	}
+	if arg.CID != blocked.SearchDefaultNum {
+		req.WhereEq("cid", arg.CID)
+	}
+	if arg.Vote != blocked.SearchDefaultNum {
+		req.WhereEq("vote", arg.Vote)
+	}
+	if arg.State != blocked.SearchDefaultNum {
+		req.WhereEq("state", arg.State)
+	}
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// KPIPoint get search kpi point.
+func (d *Dao) KPIPoint(c context.Context, arg *blocked.ArgKpiPointSearch) (ids []int64, pager *blocked.Pager, err error) {
+	var (
+		dayFromT, dayToT time.Time
+		dayFrom, dayTo   string
+	)
+	req := d.elastic.NewRequest(blocked.BusinessBlockedKpiPoint).Index(blocked.TableBlockedKpiPoint).Fields("id")
+	if arg.UID != blocked.SearchDefaultNum {
+		req.WhereEq("mid", arg.UID)
+	}
+	if arg.Start != blocked.SearchDefaultString {
+		if dayFromT, err = time.ParseInLocation(model.TimeFormatSec, arg.Start, time.Local); err != nil {
+			err = errors.Errorf("time.ParseInLocation(%s) error(%v)", arg.Start, err)
+			return
+		}
+		dayFrom = dayFromT.Format(model.TimeFormatDay)
+	}
+	if arg.End != blocked.SearchDefaultString {
+		if dayToT, err = time.ParseInLocation(model.TimeFormatSec, arg.End, time.Local); err != nil {
+			err = errors.Errorf("time.ParseInLocation(%s) error(%v)", arg.End, err)
+			return
+		}
+		dayTo = dayToT.Format(model.TimeFormatDay)
+	}
+	req.WhereRange("day", dayFrom, dayTo, elastic.RangeScopeLcRc)
+	req.Pn(arg.PN).Ps(arg.PS).Order(arg.Order, arg.Sort)
+	var res *search.ReSearchData
+	if err = req.Scan(c, &res); err != nil {
+		err = errors.Errorf("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	ids, pager = pagerExtra(res)
+	return
+}
+
+// SearchUpdate update about seach data.
+func (d *Dao) SearchUpdate(c context.Context, appid string, table string, data []interface{}) (err error) {
+	us := d.elastic.NewUpdate(appid)
+	for _, v := range data {
+		us.AddData(table, v)
+	}
+	if err = us.Do(c); err != nil {
+		log.Info("appid(%s) table(%s) params(%s) ip(%s) search blocked update error(%v)", appid, table, us.Params(), metadata.String(c, metadata.RemoteIP), err)
+	}
+	return
+}
+
+func pagerExtra(res *search.ReSearchData) (ids []int64, pager *blocked.Pager) {
+	for _, v := range res.Result {
+		ids = append(ids, v.ID)
+	}
+	if res.Page != nil {
+		pager = &blocked.Pager{
+			Total: res.Page.Total,
+			PN:    res.Page.PN,
+			PS:    res.Page.PS,
+			Sort:  res.Sort,
+			Order: res.Order,
+		}
+	}
+	return
+}

app/admin/main/credit/dao/search/dao_test.go

@@ -0,0 +1,114 @@
+package search
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/credit/conf"
+	"go-common/app/admin/main/credit/model/blocked"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account-law.credit-admin")
+		flag.Set("conf_appid", "main.account-law.credit-admin")
+		flag.Set("conf_token", "eKmbn2M4jvSyyjMEOywLFOQlX5ggRG9x")
+		flag.Set("tree_id", "5885")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_env", "10")
+		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/convey-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func TestDao_Blocked(t *testing.T) {
+	arg := &blocked.ArgBlockedSearch{Order: "id"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.Blocked(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func TestDao_Publish(t *testing.T) {
+	arg := &blocked.ArgPublishSearch{Order: "id"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.Publish(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func Test_Case(t *testing.T) {
+	arg := &blocked.ArgCaseSearch{Order: "id"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.Case(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func Test_Jury(t *testing.T) {
+	arg := &blocked.ArgJurySearch{Order: "id"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.Jury(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func Test_Opinion(t *testing.T) {
+	arg := &blocked.ArgOpinionSearch{Order: "id"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.Opinion(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func Test_KPIPoint(t *testing.T) {
+	arg := &blocked.ArgKpiPointSearch{Order: "id", Start: "2006-01-02 15:04:05", End: "2019-01-02 15:04:05"}
+	Convey("return someting", t, func() {
+		ids, pagers, err := d.KPIPoint(context.TODO(), arg)
+		So(err, ShouldBeNil)
+		So(len(ids), ShouldBeGreaterThanOrEqualTo, 0)
+		So(pagers, ShouldNotBeNil)
+	})
+}
+
+func Test_BlockedUpdate(t *testing.T) {
+	single := map[string]interface{}{
+		"id":      1,
+		"oper_id": 1,
+		"status":  1,
+		"black":   1,
+	}
+	var multiple []interface{}
+	multiple = append(multiple, single)
+	Convey("return someting", t, func() {
+		err := d.SearchUpdate(context.TODO(), "block_info", "blocked_info", multiple)
+		So(err, ShouldBeNil)
+	})
+}

app/admin/main/credit/dao/upload/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 = ["dao_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/credit/conf: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 = ["dao.go"],
+    importpath = "go-common/app/admin/main/credit/dao/upload",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/credit/conf:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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/admin/main/credit/dao/upload/dao.go

@@ -0,0 +1,96 @@
+package upload
+
+import (
+	"context"
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/base64"
+	"fmt"
+	"hash"
+	"io"
+	"net/http"
+	"strconv"
+
+	"go-common/app/admin/main/credit/conf"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+const (
+	_uploadURL = "/bfs/%s/%s"
+	_template  = "%s\n%s\n%s\n%d\n"
+	_method    = "PUT"
+	_bucket    = "test" //blocked
+)
+
+// Dao .
+type Dao struct {
+	key    string
+	secret string
+	host   string
+	client *httpx.Client
+}
+
+// New .
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		key:    c.BFS.Key,
+		secret: c.BFS.Secret,
+		host:   c.Host.Bfs,
+		client: httpx.NewClient(c.HTTPClient),
+	}
+	return
+}
+
+// Upload upload picture or log file to bfs
+func (d *Dao) Upload(c context.Context, fileName, fileType string, expire int64, body io.Reader) (location string, err error) {
+	var (
+		url  string
+		req  *http.Request
+		resp *http.Response
+		code int
+	)
+	client := &http.Client{}
+	url = fmt.Sprintf(d.host+_uploadURL, _bucket, fileName)
+	if req, err = http.NewRequest(_method, url, body); err != nil {
+		log.Error("http.NewRequest() Upload(%v) error(%v)", url, err)
+		return
+	}
+	authorization := authorize(d.key, d.secret, _method, _bucket, fileName, expire)
+	req.Header.Set("Host", d.host)
+	req.Header.Add("Date", fmt.Sprint(expire))
+	req.Header.Add("Authorization", authorization)
+	req.Header.Add("Content-Type", fileType)
+	resp, err = client.Do(req)
+	if err != nil {
+		log.Error("resp.Do(%s) error(%v)", url, err)
+		return
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		err = fmt.Errorf("status code error:%v", resp.StatusCode)
+		return
+	}
+	code, err = strconv.Atoi(resp.Header.Get("code"))
+	if err != nil || code != 200 {
+		err = fmt.Errorf("response code error:%v", code)
+		return
+	}
+	location = resp.Header.Get("Location")
+	return
+}
+
+// authorize returns authorization for upload file to bfs
+func authorize(key, secret, method, bucket, file string, expire int64) (authorization string) {
+	var (
+		content   string
+		mac       hash.Hash
+		signature string
+	)
+	content = fmt.Sprintf(_template, method, bucket, file, expire)
+	mac = hmac.New(sha1.New, []byte(secret))
+	mac.Write([]byte(content))
+	signature = base64.StdEncoding.EncodeToString(mac.Sum(nil))
+	authorization = fmt.Sprintf("%s:%s:%d", key, signature, expire)
+	return
+}

app/admin/main/credit/dao/upload/dao_test.go

@@ -0,0 +1,46 @@
+package upload
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"go-common/app/admin/main/credit/conf"
+
+	. "github.com/smartystreets/goconvey/convey"
+	"gopkg.in/h2non/gock.v1"
+)
+
+var d *Dao
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/convey-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	d = New(conf.Conf)
+}
+
+func WithDao(f func(d *Dao)) func() {
+	return func() {
+		f(d)
+	}
+}
+
+func httpMock(method, url string) *gock.Request {
+	r := gock.New(url)
+	r.Method = strings.ToUpper(method)
+	return r
+}
+
+func ctx() context.Context {
+	return context.Background()
+}
+
+func Test_Upload(t *testing.T) {
+	Convey("return someting", t, func() {
+		_, err := d.Upload(context.TODO(), "blocked_info", "", 12313, nil)
+		So(err, ShouldBeNil)
+	})
+}