Initial commit

app/admin/main/space/BUILD

@@ -0,0 +1,22 @@
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/space/cmd:all-srcs",
+        "//app/admin/main/space/conf:all-srcs",
+        "//app/admin/main/space/dao:all-srcs",
+        "//app/admin/main/space/http:all-srcs",
+        "//app/admin/main/space/model:all-srcs",
+        "//app/admin/main/space/service:all-srcs",
+        "//app/admin/main/space/util:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/space/CHANGELOG.md

@@ -0,0 +1,8 @@
+# 空间管理后台
+
+##### Version 1.0.1
+> 1.空间黑名单
+
+#### Version 1.0.0
+##### Features
+> 1.项目init

app/admin/main/space/CONTRIBUTORS.md

@@ -0,0 +1,12 @@
+# Owner
+liweijia
+renwei
+
+# Author 
+wuhao02
+guanyanliang
+liweijia
+
+# Reviewer
+guanyanliang
+liweijia

app/admin/main/space/OWNERS

@@ -0,0 +1,17 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- guanyanliang
+- liweijia
+- renwei
+- wuhao02
+labels:
+- admin
+- admin/main/space
+- main
+options:
+  no_parent_owners: true
+reviewers:
+- guanyanliang
+- liweijia
+- wuhao02

app/admin/main/space/README.md

@@ -0,0 +1 @@
+### 空间信息管理后台

app/admin/main/space/cmd/BUILD

@@ -0,0 +1,46 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "cmd",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    data = ["space-admin-test.toml"],
+    importpath = "go-common/app/admin/main/space/cmd",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/space/conf:go_default_library",
+        "//app/admin/main/space/http:go_default_library",
+        "//app/admin/main/space/service:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/trace:go_default_library",
+        "//library/os/signal:go_default_library",
+        "//library/queue/databus/report:go_default_library",
+        "//library/syscall: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/space/cmd/main.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"flag"
+	"go-common/library/queue/databus/report"
+	"os"
+	"time"
+
+	"go-common/app/admin/main/space/conf"
+	"go-common/app/admin/main/space/http"
+	"go-common/app/admin/main/space/service"
+	"go-common/library/log"
+	"go-common/library/net/trace"
+	"go-common/library/os/signal"
+	"go-common/library/syscall"
+)
+
+var (
+	s *service.Service
+)
+
+func main() {
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		log.Error("conf.Init() error(%v)", err)
+		panic(err)
+	}
+	log.Init(conf.Conf.Log)
+	defer log.Close()
+	trace.Init(conf.Conf.Tracer)
+	defer trace.Close()
+	// service init
+	s = service.New(conf.Conf)
+	http.Init(conf.Conf, s)
+	report.InitManager(conf.Conf.ManagerReport)
+	log.Info("space-admin start")
+	ch := make(chan os.Signal, 1)
+	signal.Notify(ch, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT, syscall.SIGSTOP)
+	for {
+		si := <-ch
+		switch si {
+		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGSTOP, syscall.SIGINT:
+			log.Info("get a signal %s, stop the space-admin process", si.String())
+			time.Sleep(time.Second)
+			return
+		case syscall.SIGHUP:
+		default:
+			return
+		}
+	}
+}

app/admin/main/space/cmd/space-admin-test.toml

@@ -0,0 +1,46 @@
+[log]
+dir = "/data/log/space-admin/"
+
+[orm]
+dsn = "space:9TtI2XkoEqk6GpIL@tcp(172.16.33.205:3306)/space?timeout=5s&readTimeout=5s&writeTimeout=5s&parseTime=true&loc=Local&charset=utf8,utf8mb4"
+active = 5
+idle = 5
+idleTimeout = "4h"
+
+[permit]
+    managerHost = "http://uat-manager.bilibili.co"
+    dashboardHost = "http://dashboard-mng.bilibili.co"
+    dashboardCaller = "manager-go"
+    [permit.DsHTTPClient]
+    key = "manager-go"
+    secret = "949bbb2dd3178252638c2407578bc7ad"
+    dial = "1s"
+    timeout = "1s"
+    keepAlive = "60s"
+    [permit.MaHTTPClient]
+    key = "f6433799dbd88751"
+    secret = "36f8ddb1806207fe07013ab6a77a3935"
+    dial = "1s"
+    timeout = "1s"
+    keepAlive = "60s"
+    [permit.MaHTTPClient.breaker]
+    window  = "3s"
+    sleep   = "100ms"
+    bucket  = 10
+    ratio   = 0.5
+    request = 100
+    [permit.session]
+    sessionIDLength = 32
+    cookieLifeTime = 1800
+    cookieName = "mng-go"
+    domain = ".bilibili.co"
+    [permit.session.Memcache]
+    name = "go-business/auth"
+    proto = "tcp"
+    addr = "127.0.0.1:11211"
+    active = 10
+    idle = 5
+    dialTimeout = "1s"
+    readTimeout = "1s"
+    writeTimeout = "1s"
+    idleTimeout = "80s"

app/admin/main/space/conf/BUILD

@@ -0,0 +1,39 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["conf.go"],
+    importpath = "go-common/app/admin/main/space/conf",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/conf:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/permit:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//library/net/trace:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//vendor/github.com/BurntSushi/toml: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/space/conf/conf.go

@@ -0,0 +1,93 @@
+package conf
+
+import (
+	"errors"
+	"flag"
+
+	"go-common/library/conf"
+	"go-common/library/database/orm"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+	"go-common/library/net/rpc"
+	"go-common/library/net/trace"
+	"go-common/library/queue/databus"
+
+	"github.com/BurntSushi/toml"
+)
+
+var (
+	confPath string
+	client   *conf.Client
+	// Conf of config
+	Conf = &Config{}
+)
+
+// Config def.
+type Config struct {
+	// http
+	BM *bm.ServerConfig
+	// auth
+	Permit *permit.Config
+	// db
+	ORM *orm.Config
+	// log
+	Log *log.Config
+	// tracer
+	Tracer *trace.Config
+	// RelationRPC
+	RelationRPC *rpc.ClientConfig
+	// manager report
+	ManagerReport *databus.Config
+}
+
+func local() (err error) {
+	_, err = toml.DecodeFile(confPath, &Conf)
+	return
+}
+
+func remote() (err error) {
+	if client, err = conf.New(); err != nil {
+		return
+	}
+	if err = load(); err != nil {
+		return
+	}
+	go func() {
+		for range client.Event() {
+			log.Info("config reload")
+			if load() != nil {
+				log.Error("config reload error (%v)", err)
+			}
+		}
+	}()
+	return
+}
+
+func load() (err error) {
+	var (
+		s       string
+		ok      bool
+		tmpConf *Config
+	)
+	if s, ok = client.Value("space-admin.toml"); !ok {
+		return errors.New("load config center error")
+	}
+	if _, err = toml.Decode(s, &tmpConf); err != nil {
+		return errors.New("could not decode config")
+	}
+	*Conf = *tmpConf
+	return
+}
+
+func init() {
+	flag.StringVar(&confPath, "conf", "", "default config path")
+}
+
+// Init int config
+func Init() error {
+	if confPath != "" {
+		return local()
+	}
+	return remote()
+}

app/admin/main/space/dao/BUILD

@@ -0,0 +1,54 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "blacklist.go",
+        "dao.go",
+    ],
+    importpath = "go-common/app/admin/main/space/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/space/conf:go_default_library",
+        "//app/admin/main/space/model:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/log: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "blacklist_test.go",
+        "dao_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/space/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/admin/main/space/dao/blacklist.go

@@ -0,0 +1,95 @@
+package dao
+
+import (
+	"fmt"
+
+	"go-common/app/admin/main/space/model"
+	"go-common/library/log"
+)
+
+// BlacklistAdd add blacklist
+func (d *Dao) BlacklistAdd(addmids, upmids []int64) (err error) {
+	tx := d.DB.Begin()
+	if err = tx.Error; err != nil {
+		log.Error("dao.BlacklistAdd.Begin error(%v)", err)
+		return
+	}
+	if len(addmids) > 0 {
+		if err = tx.Model(&model.Blacklist{}).Exec(model.BlacklistBatchAddSQL(addmids)).Error; err != nil {
+			log.Error("dao.BlacklistAdd.BlacklistBatchAddSQL(%+v) error(%v)", addmids, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	if len(upmids) > 0 {
+		if err = tx.Model(&model.Blacklist{}).Exec(model.BlacklistBatchUpdateSQL(upmids)).Error; err != nil {
+			log.Error("dao.BlacklistAdd.BlacklistBatchUpdateSQL(%+v) error(%v)", upmids, err)
+			err = tx.Rollback().Error
+			return
+		}
+	}
+	err = tx.Commit().Error
+	return
+}
+
+// BlacklistIn query blackist count
+func (d *Dao) BlacklistIn(mids []int64) (blacks map[int64]*model.Blacklist, err error) {
+	var (
+		blacklist []*model.Blacklist
+	)
+	blacks = make(map[int64]*model.Blacklist, len(mids))
+	if len(mids) == 0 {
+		return nil, fmt.Errorf("mid不能为空")
+	}
+	if err = d.DB.Model(&model.Blacklist{}).Where("mid in (?)", mids).Find(&blacklist).
+		Error; err != nil {
+		log.Error("dao.BlacklistIn.Count(%+v) error(%v)", mids, err)
+		return
+	}
+	for _, v := range blacklist {
+		blacks[v.Mid] = v
+	}
+	return
+}
+
+// BlacklistUp blackist update
+func (d *Dao) BlacklistUp(id int64, status int) (err error) {
+	w := map[string]interface{}{
+		"id": id,
+	}
+	up := map[string]interface{}{
+		"status": status,
+	}
+	if err = d.DB.Model(&model.Blacklist{}).Where(w).Update(up).Error; err != nil {
+		log.Error("dao.BlacklistUp.Update error(%v)", err)
+		return
+	}
+	return
+}
+
+// BlacklistIndex blackist
+func (d *Dao) BlacklistIndex(mid int64, pn, ps int) (pager *model.BlacklistPager, err error) {
+	var (
+		blacklist []*model.Blacklist
+	)
+	pager = &model.BlacklistPager{
+		Page: model.Page{
+			Num:  pn,
+			Size: ps,
+		},
+	}
+	query := d.DB.Model(&model.Blacklist{})
+	if mid != 0 {
+		query = query.Where("mid = ?", mid)
+	}
+	if err = query.Count(&pager.Page.Total).Error; err != nil {
+		log.Error("dao.BlacklistIndex.Count error(%v)", err)
+		return
+	}
+	if err = query.Order("`id` DESC").Offset((pn - 1) * ps).Limit(ps).Find(&blacklist).Error; err != nil {
+		log.Error("dao.BlacklistIndex.Find error(%v)", err)
+		return
+	}
+	pager.Item = blacklist
+	return
+}

app/admin/main/space/dao/blacklist_test.go

@@ -0,0 +1,68 @@
+package dao
+
+import (
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoBlacklistAdd(t *testing.T) {
+	convey.Convey("BlacklistAdd", t, func(ctx convey.C) {
+		var (
+			mids = []int64{10000, 10001}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.BlacklistAdd(mids, mids)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoBlacklistIn(t *testing.T) {
+	convey.Convey("BlacklistIn", t, func(ctx convey.C) {
+		var (
+			mids = []int64{1, 2, 3, 4, 5, 6, 7, 8}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			blacklist, err := d.BlacklistIn(mids)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(blacklist, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoBlacklistUp(t *testing.T) {
+	convey.Convey("BlacklistUp", t, func(ctx convey.C) {
+		var (
+			id     = int64(1)
+			status = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.BlacklistUp(id, status)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoBlacklistIndex(t *testing.T) {
+	convey.Convey("BlacklistIndex", t, func(ctx convey.C) {
+		var (
+			mid = int64(1)
+			pn  = int(1)
+			ps  = int(10)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			pager, err := d.BlacklistIndex(mid, pn, ps)
+			ctx.Convey("Then err should be nil.pager should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(pager, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/admin/main/space/dao/dao.go

@@ -0,0 +1,33 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/admin/main/space/conf"
+	"go-common/library/database/orm"
+
+	"github.com/jinzhu/gorm"
+)
+
+// Dao .
+type Dao struct {
+	c  *conf.Config
+	DB *gorm.DB
+}
+
+// New .
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// conf
+		c: c,
+		// db
+		DB: orm.NewMySQL(c.ORM),
+	}
+	d.DB.LogMode(true)
+	return
+}
+
+// Ping .
+func (d *Dao) Ping(c context.Context) error {
+	return d.DB.DB().PingContext(c)
+}

app/admin/main/space/dao/dao_test.go

@@ -0,0 +1,45 @@
+package dao
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/space/conf"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.manager.space-admin")
+		flag.Set("conf_token", "c6a2a9a7c39af9f41704b59c031f6c9a")
+		flag.Set("tree_id", "63447")
+		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/space-admin-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func TestDao_Ping(t *testing.T) {
+	convey.Convey("", t, func(ctx convey.C) {
+		err := d.Ping(context.Background())
+		ctx.So(err, convey.ShouldBeNil)
+	})
+}

app/admin/main/space/http/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "account.go",
+        "blacklist.go",
+        "http.go",
+        "notice.go",
+    ],
+    importpath = "go-common/app/admin/main/space/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/space/conf:go_default_library",
+        "//app/admin/main/space/model:go_default_library",
+        "//app/admin/main/space/service:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/permit: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/space/http/account.go

@@ -0,0 +1,20 @@
+package http
+
+import bm "go-common/library/net/http/blademaster"
+
+func relation(c *bm.Context) {
+	v := new(struct {
+		Mid int64 `form:"mid" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, err := spcSvc.Relation(c, v.Mid)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(struct {
+		Follower int64 `json:"follower"`
+	}{Follower: data}, nil)
+}

app/admin/main/space/http/blacklist.go

@@ -0,0 +1,71 @@
+package http
+
+import (
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func blacklistIndex(c *bm.Context) {
+	param := &struct {
+		Mid int64 `form:"mid"`
+		Pn  int   `form:"pn" default:"1"`
+		Ps  int   `form:"ps" default:"20"`
+	}{}
+	if err := c.Bind(param); err != nil {
+		return
+	}
+	c.JSON(spcSvc.BlacklistIndex(param.Mid, param.Pn, param.Ps))
+}
+
+func blacklistAdd(c *bm.Context) {
+	var (
+		uid  int64
+		name string
+	)
+	res := map[string]interface{}{}
+	param := &struct {
+		Mids []int64 `form:"mids,split" validate:"required"`
+	}{}
+	if err := c.Bind(param); err != nil {
+		return
+	}
+	if uidInter, ok := c.Get("uid"); ok {
+		uid = uidInter.(int64)
+	}
+	if usernameCtx, ok := c.Get("username"); ok {
+		name = usernameCtx.(string)
+	}
+	if err := spcSvc.BlacklistAdd(param.Mids, name, uid); err != nil {
+		res["message"] = "添加失败:" + err.Error()
+		c.JSONMap(res, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func blacklistUp(c *bm.Context) {
+	var (
+		uid  int64
+		name string
+	)
+	res := map[string]interface{}{}
+	param := &struct {
+		ID     int64 `form:"id" validate:"required"`
+		Status int   `form:"status" validate:"min=0,gte=0"`
+	}{}
+	if err := c.Bind(param); err != nil {
+		return
+	}
+	if uidInter, ok := c.Get("uid"); ok {
+		uid = uidInter.(int64)
+	}
+	if usernameCtx, ok := c.Get("username"); ok {
+		name = usernameCtx.(string)
+	}
+	if err := spcSvc.BlacklistUp(param.ID, param.Status, name, uid); err != nil {
+		res["message"] = "更新失败:" + err.Error()
+		c.JSONMap(res, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, nil)
+}

app/admin/main/space/http/http.go

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/admin/main/space/conf"
+	"go-common/app/admin/main/space/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+)
+
+var (
+	spcSvc *service.Service
+	//idfSvc  *identify.Identify
+	permitSvc *permit.Permit
+)
+
+// Init init http sever instance.
+func Init(c *conf.Config, s *service.Service) {
+	spcSvc = s
+	permitSvc = permit.New(c.Permit)
+	engine := bm.DefaultServer(c.BM)
+	authRouter(engine)
+	// init internal server
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func authRouter(e *bm.Engine) {
+	e.Ping(ping)
+	group := e.Group("/x/admin/space")
+	{
+		noticeGroup := group.Group("/notice", permitSvc.Permit("SPACE_NOTICE"))
+		{
+			noticeGroup.GET("", notice)
+			noticeGroup.POST("/up", noticeUp)
+		}
+		group.GET("/relation", relation)
+		blacklist := group.Group("/blacklist", permitSvc.Permit("SPACE_BLACKLIST"))
+		{
+			blacklist.GET("", blacklistIndex)
+			blacklist.POST("add", blacklistAdd)
+			blacklist.POST("update", blacklistUp)
+		}
+	}
+}
+
+func ping(c *bm.Context) {
+	if err := spcSvc.Ping(c); err != nil {
+		log.Error("space-admin ping error")
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

app/admin/main/space/http/notice.go

@@ -0,0 +1,30 @@
+package http
+
+import (
+	"go-common/app/admin/main/space/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func notice(c *bm.Context) {
+	v := new(struct {
+		Mid int64 `form:"mid" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(spcSvc.Notice(c, v.Mid))
+}
+
+func noticeUp(c *bm.Context) {
+	v := new(model.NoticeUpArg)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if uidInter, ok := c.Get("uid"); ok {
+		v.UID = uidInter.(int64)
+	}
+	if usernameCtx, ok := c.Get("username"); ok {
+		v.Uname = usernameCtx.(string)
+	}
+	c.JSON(nil, spcSvc.NoticeUp(c, v))
+}

app/admin/main/space/model/BUILD

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

@@ -0,0 +1,59 @@
+package model
+
+import (
+	"fmt"
+	"strings"
+
+	"go-common/library/time"
+)
+
+const (
+	//_blacklistBatchAddSQL add blacklist batch sql
+	_blacklistBatchAddSQL    = "INSERT INTO blacklist (`mid`) VALUES %s"
+	_blacklistBatchUpdateSQL = "UPDATE blacklist SET `status` = 0 WHERE id in (%s)"
+	//StatusBlack blacklist
+	StatusBlack = 0
+)
+
+// Blacklist .
+type Blacklist struct {
+	ID     int64     `json:"id" form:"id"`
+	Mid    int64     `json:"mid" form:"mid"`
+	Status int       `json:"status" form:"status"`
+	Mtime  time.Time `json:"mtime"`
+}
+
+//BlacklistPager blacklist pager
+type BlacklistPager struct {
+	Item []*Blacklist
+	Page Page
+}
+
+// BlacklistBatchAddSQL .
+func BlacklistBatchAddSQL(mids []int64) string {
+	if len(mids) == 0 {
+		return ""
+	}
+	var rowStrings []string
+	for _, mid := range mids {
+		rowStrings = append(rowStrings, fmt.Sprintf("(%d)", mid))
+	}
+	return fmt.Sprintf(_blacklistBatchAddSQL, strings.Join(rowStrings, ","))
+}
+
+// BlacklistBatchUpdateSQL .
+func BlacklistBatchUpdateSQL(mids []int64) string {
+	if len(mids) == 0 {
+		return ""
+	}
+	var rowStrings []string
+	for _, mid := range mids {
+		rowStrings = append(rowStrings, fmt.Sprintf("%d", mid))
+	}
+	return fmt.Sprintf(_blacklistBatchUpdateSQL, strings.Join(rowStrings, ","))
+}
+
+// TableName .
+func (a Blacklist) TableName() string {
+	return "blacklist"
+}

app/admin/main/space/model/common.go

@@ -0,0 +1,13 @@
+package model
+
+const (
+	//LogBlacklist blacklist action log type id
+	LogBlacklist = 1
+)
+
+//Page pager
+type Page struct {
+	Num   int `json:"num"`
+	Size  int `json:"size"`
+	Total int `json:"total"`
+}

app/admin/main/space/model/notice.go

@@ -0,0 +1,37 @@
+package model
+
+import "fmt"
+
+// const .
+const (
+	NoticeLogID              = 241
+	NoticeForbid             = 1
+	NoticeNoForbid           = 0
+	NoticeClear              = "clear"
+	NoticeClearAndForbid     = "clear_forbid"
+	NoticeUnForbid           = "unforbid"
+	NoticeTypeClear          = 1
+	NoticeTypeClearAndForbid = 2
+	NoticeTypeUnForbid       = 3
+)
+
+// NoticeUpArg .
+type NoticeUpArg struct {
+	Mid   int64  `form:"mid" validate:"min=1"`
+	Type  int    `form:"type" validate:"min=1,max=3"`
+	UID   int64  `form:"-"`
+	Uname string `form:"-"`
+}
+
+// Notice .
+type Notice struct {
+	ID       int64  `json:"id" form:"id"`
+	Mid      int64  `json:"mid" form:"mid" validate:"required"`
+	Notice   string `json:"notice"`
+	IsForbid int    `json:"is_forbid"`
+}
+
+// TableName notice
+func (c *Notice) TableName() string {
+	return fmt.Sprintf("member_up_notice%d", c.Mid%10)
+}

app/admin/main/space/service/BUILD

@@ -0,0 +1,44 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "account.go",
+        "blacklist.go",
+        "notice.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/admin/main/space/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/space/conf:go_default_library",
+        "//app/admin/main/space/dao:go_default_library",
+        "//app/admin/main/space/model:go_default_library",
+        "//app/service/main/relation/model:go_default_library",
+        "//app/service/main/relation/rpc/client:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/queue/databus/report: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/space/service/account.go

@@ -0,0 +1,19 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/service/main/relation/model"
+	"go-common/library/log"
+)
+
+// Relation .
+func (s *Service) Relation(c context.Context, mid int64) (follower int64, err error) {
+	var stat *model.Stat
+	if stat, err = s.relation.Stat(c, &model.ArgMid{Mid: mid}); err != nil {
+		log.Error("Relation s.relation.Stat(mid:%d) error(%v)", mid, err)
+		return
+	}
+	follower = stat.Follower
+	return
+}

app/admin/main/space/service/blacklist.go

@@ -0,0 +1,107 @@
+package service
+
+import (
+	"fmt"
+	"time"
+
+	"go-common/app/admin/main/space/model"
+	"go-common/library/log"
+	"go-common/library/queue/databus/report"
+
+	"github.com/jinzhu/gorm"
+)
+
+const (
+	_BlacklistAdd   = "BlacklistAdd"
+	_BlacklistUp    = "BlacklistUp"
+	_StatusNotBlack = 1
+)
+
+// BlacklistAdd add blacklist
+func (s *Service) BlacklistAdd(mids []int64, name string, uid int64) (err error) {
+	var (
+		blacklist           map[int64]*model.Blacklist
+		updateMids, addMids []int64
+	)
+	if len(mids) > 30 {
+		err = fmt.Errorf("黑名单一次最多只能添加30个")
+		return
+	}
+	if blacklist, err = s.dao.BlacklistIn(mids); err != nil {
+		return
+	}
+	for _, v := range mids {
+		if blacklist[v] != nil {
+			if blacklist[v].Status == _StatusNotBlack {
+				updateMids = append(updateMids, blacklist[v].ID)
+			}
+		} else {
+			addMids = append(addMids, v)
+		}
+	}
+	if err = s.dao.BlacklistAdd(addMids, updateMids); err != nil {
+		return
+	}
+	for _, v := range mids {
+		if err = report.Manager(&report.ManagerInfo{
+			Uname:    name,
+			UID:      uid,
+			Business: model.NoticeLogID,
+			Type:     model.LogBlacklist,
+			Oid:      v,
+			Action:   _BlacklistAdd,
+			Ctime:    time.Now(),
+			Content: map[string]interface{}{
+				"mids": mids,
+			},
+		}); err != nil {
+			return
+		}
+	}
+	return
+}
+
+// BlacklistUp update blacklist
+func (s *Service) BlacklistUp(id int64, status int, name string, uid int64) (err error) {
+	var (
+		mids []int64
+	)
+	blacklist := &model.Blacklist{}
+	if err = s.dao.DB.Model(&model.Blacklist{}).Where("id in (?)", []int64{id}).First(blacklist).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			err = fmt.Errorf("找不用数据")
+			return
+		}
+		log.Error("Srv.BlacklistUp First error(%v)", err)
+		return
+	}
+	if err = s.dao.BlacklistUp(id, status); err != nil {
+		return
+	}
+	mids = []int64{blacklist.Mid}
+	if err = report.Manager(&report.ManagerInfo{
+		Uname:    name,
+		UID:      uid,
+		Business: model.NoticeLogID,
+		Type:     model.LogBlacklist,
+		Oid:      blacklist.Mid,
+		Action:   _BlacklistUp,
+		Ctime:    time.Now(),
+		Content: map[string]interface{}{
+			"id":     id,
+			"status": status,
+			"mids":   mids,
+		},
+	}); err != nil {
+		return
+	}
+	return
+}
+
+// BlacklistIndex .
+func (s *Service) BlacklistIndex(mid int64, pn, ps int) (pager *model.BlacklistPager, err error) {
+	if pager, err = s.dao.BlacklistIndex(mid, pn, ps); err != nil {
+		return
+	}
+	return
+}

app/admin/main/space/service/notice.go

@@ -0,0 +1,78 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/space/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/queue/databus/report"
+)
+
+// Notice get notice data.
+func (s *Service) Notice(c context.Context, mid int64) (data *model.Notice, err error) {
+	data = &model.Notice{Mid: mid}
+	if err = s.dao.DB.Table(data.TableName()).Where("mid=?", mid).First(&data).Error; err != nil {
+		log.Error("Notice (mid:%d) error (%v)", mid, err)
+		if err == ecode.NothingFound {
+			err = nil
+		}
+	}
+	return
+}
+
+// NoticeUp notice clear and forbid.
+func (s *Service) NoticeUp(c context.Context, arg *model.NoticeUpArg) (err error) {
+	var action string
+	notice := &model.Notice{Mid: arg.Mid}
+	if err = s.dao.DB.Table(notice.TableName()).Where("mid=?", arg.Mid).First(&notice).Error; err != nil {
+		log.Error("NoticeForbid error (mid:%d) (%v)", arg.Mid, err)
+		if err != ecode.NothingFound {
+			return
+		}
+	}
+	up := make(map[string]interface{})
+	switch arg.Type {
+	case model.NoticeTypeClear:
+		up["notice"] = ""
+		action = model.NoticeClear
+	case model.NoticeTypeClearAndForbid:
+		up["notice"] = ""
+		up["is_forbid"] = model.NoticeForbid
+		action = model.NoticeClearAndForbid
+	case model.NoticeTypeUnForbid:
+		up["is_forbid"] = model.NoticeNoForbid
+		action = model.NoticeUnForbid
+	}
+	if err != ecode.NothingFound {
+		if err = s.dao.DB.Table(notice.TableName()).Where("id=?", notice.ID).Update(up).Error; err != nil {
+			log.Error("NoticeForbid (mid:%d) update error (%v)", arg.Mid, err)
+			return
+		}
+	} else {
+		create := &model.Notice{Mid: arg.Mid}
+		if arg.Type == model.NoticeTypeClearAndForbid {
+			create.IsForbid = model.NoticeForbid
+		}
+		if err = s.dao.DB.Table(notice.TableName()).Create(create).Error; err != nil {
+			log.Error("NoticeForbid (mid:%d) insert error (%v)", arg.Mid, err)
+			return
+		}
+	}
+	if err = report.Manager(&report.ManagerInfo{
+		Uname:    arg.Uname,
+		UID:      arg.UID,
+		Business: model.NoticeLogID,
+		Type:     0,
+		Oid:      arg.Mid,
+		Action:   action,
+		Ctime:    time.Now(),
+		Content: map[string]interface{}{
+			"old": notice,
+		},
+	}); err != nil {
+		return
+	}
+	return
+}

app/admin/main/space/service/service.go

@@ -0,0 +1,31 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/space/conf"
+	"go-common/app/admin/main/space/dao"
+	relrpc "go-common/app/service/main/relation/rpc/client"
+)
+
+// Service biz service def.
+type Service struct {
+	c        *conf.Config
+	dao      *dao.Dao
+	relation *relrpc.Service
+}
+
+// New new a Service and return.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:        c,
+		dao:      dao.New(c),
+		relation: relrpc.New(c.RelationRPC),
+	}
+	return s
+}
+
+// Ping .
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}

app/admin/main/space/util/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/admin/main/space/util",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["//library/queue/databus/report: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/space/util/dao.go

@@ -0,0 +1,26 @@
+package util
+
+import (
+	"time"
+
+	"go-common/library/queue/databus/report"
+)
+
+//AddLogs add action logs
+func AddLogs(logtype int, uname string, uid int64, oid int64, action string, obj interface{}) (err error) {
+	report.Manager(&report.ManagerInfo{
+		Uname:    uname,
+		UID:      uid,
+		Business: 1,
+		Type:     logtype,
+		Oid:      oid,
+		Action:   action,
+		Ctime:    time.Now(),
+		// extra
+		Index: []interface{}{},
+		Content: map[string]interface{}{
+			"json": obj,
+		},
+	})
+	return
+}