Create & Init Project...

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)
+}