Create & Init Project...

app/admin/main/spy/service/BUILD

@@ -0,0 +1,57 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["service_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/spy/conf:go_default_library",
+        "//app/admin/main/spy/model:go_default_library",
+        "//library/ecode:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "factor.go",
+        "log.go",
+        "service.go",
+        "setting.go",
+        "stat.go",
+        "user.go",
+    ],
+    importpath = "go-common/app/admin/main/spy/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/spy/conf:go_default_library",
+        "//app/admin/main/spy/dao:go_default_library",
+        "//app/admin/main/spy/model:go_default_library",
+        "//library/ecode: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/spy/service/factor.go

@@ -0,0 +1,103 @@
+package service
+
+import (
+	"context"
+
+	"go-common/library/log"
+
+	"go-common/app/admin/main/spy/model"
+)
+
+// Factors get all factor.
+func (s *Service) Factors(c context.Context) (fs []*model.Factors, err error) {
+	var (
+		fds []*model.Factor
+	)
+	gs, err := s.spyDao.Groups(c)
+	if err != nil {
+		log.Error("spyDao.Groups error(%v)", err)
+		return
+	}
+	if len(gs) == 0 {
+		return
+	}
+	for _, v := range gs {
+		fds, err = s.spyDao.Factors(c, v.ID)
+		if err != nil {
+			log.Error("spyDao.Groups error(%v)", err)
+			return
+		}
+		if len(fds) == 0 {
+			continue
+		}
+		for _, f := range fds {
+			f := &model.Factors{
+				GroupID:   v.ID,
+				GroupName: v.Name,
+				NickName:  f.NickName,
+				FactorVal: f.FactorVal,
+				ID:        f.ID,
+			}
+			fs = append(fs, f)
+		}
+	}
+	return
+}
+
+// UpdateFactor update factor.
+func (s *Service) UpdateFactor(c context.Context, fs []*model.Factor, name string) (err error) {
+	for _, f := range fs {
+		_, err = s.spyDao.UpdateFactor(c, f.FactorVal, f.ID)
+		if err != nil {
+			log.Error("spyDao.UpdateFactor(%v,%d) error(%v)", f.FactorVal, f.ID, err)
+			return
+		}
+		s.AddLog(c, name, model.UpdateFactor, f)
+	}
+	return
+}
+
+// AddFactor add factor
+func (s *Service) AddFactor(c context.Context, f *model.Factor) (err error) {
+	ret, err := s.spyDao.AddFactor(c, f)
+	if err != nil || ret != 1 {
+		log.Error("s.spyDao.AddFactor(%v) error(%v,%d)", f, err, ret)
+	}
+	return
+}
+
+// AddEvent add event
+func (s *Service) AddEvent(c context.Context, f *model.Event) (err error) {
+	ret, err := s.spyDao.AddEvent(c, f)
+	if err != nil || ret != 1 {
+		log.Error("s.spyDao.AddEvent(%v) error(%v,%d)", f, err, ret)
+	}
+	return
+}
+
+// AddService add service
+func (s *Service) AddService(c context.Context, f *model.Service) (err error) {
+	ret, err := s.spyDao.AddService(c, f)
+	if err != nil || ret != 1 {
+		log.Error("s.spyDao.AddService(%v) error(%v,%d)", f, err, ret)
+	}
+	return
+}
+
+// AddGroup add group
+func (s *Service) AddGroup(c context.Context, f *model.FactorGroup) (err error) {
+	ret, err := s.spyDao.AddGroup(c, f)
+	if err != nil || ret != 1 {
+		log.Error("s.spyDao.AddGroup(%v) error(%v,%d)", f, err, ret)
+	}
+	return
+}
+
+// UpdateEventName update event name.
+func (s *Service) UpdateEventName(c context.Context, event *model.Event) (err error) {
+	ret, err := s.spyDao.UpdateEventName(c, event)
+	if err != nil || ret != 1 {
+		log.Error("s.spyDao.UpdateEventName(%v) error(%v,%d)", event, err, ret)
+	}
+	return
+}

app/admin/main/spy/service/log.go

@@ -0,0 +1,64 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"go-common/app/admin/main/spy/model"
+	"go-common/library/log"
+)
+
+// AddLog add log.
+func (s *Service) AddLog(c context.Context, name string, m int8, v interface{}) (err error) {
+	b, err := json.Marshal(v)
+	if err != nil {
+		log.Error("AddLog json.Marshal(%v) error(%v)", v, err)
+		return
+	}
+	l := &model.Log{Name: name, Module: m, Context: string(b)}
+	_, err = s.spyDao.AddLog(c, l)
+	if err != nil {
+		log.Error("userDao spyDao.AddLog(%v) error(%v)", l, err)
+		return
+	}
+	return
+}
+
+// AddLog2 add log.
+func (s *Service) AddLog2(c context.Context, l *model.Log) (err error) {
+	l.Ctime = time.Now()
+	_, err = s.spyDao.AddLog(c, l)
+	return
+}
+
+// LogList add log.
+func (s *Service) LogList(c context.Context, refID int64, module int8) (list []*model.Log, err error) {
+	list, err = s.spyDao.LogList(c, refID, module)
+	return
+}
+
+// UpdateStateLog get log.
+func (s *Service) UpdateStateLog(refID int64, state string) (log string) {
+	log = fmt.Sprintf("%d : 状态修改为[%s]", refID, state)
+	return
+}
+
+// AddRemarkLog add reamrk log.
+func (s *Service) AddRemarkLog(refID int64, remark string) (log string) {
+	log = fmt.Sprintf("%d : [备注]%s", refID, remark)
+	return
+}
+
+// DeleteStatLog delete log .
+func (s *Service) DeleteStatLog(refID int64) (log string) {
+	log = fmt.Sprintf("%d 删除记录", refID)
+	return
+}
+
+// UpdateStatCountLog update stat count log.
+func (s *Service) UpdateStatCountLog(refID int64, old int64, new int64) (log string) {
+	log = fmt.Sprintf("%d [修正数值] %d -> %d", refID, old, new)
+	return
+}

app/admin/main/spy/service/service.go

@@ -0,0 +1,72 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/spy/conf"
+	spydao "go-common/app/admin/main/spy/dao"
+	"go-common/app/admin/main/spy/model"
+	"go-common/library/log"
+)
+
+// Service biz service def.
+type Service struct {
+	c             *conf.Config
+	spyDao        *spydao.Dao
+	allEventName  map[int64]string
+	loadEventTick time.Duration
+}
+
+// New new a Service and return.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:             c,
+		spyDao:        spydao.New(c),
+		allEventName:  make(map[int64]string),
+		loadEventTick: time.Duration(c.Property.LoadEventTick),
+	}
+	s.loadeventname()
+	go s.loadeventproc()
+	return
+}
+
+// Ping check dao health.
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.spyDao.Ping(c)
+}
+
+// Wait wait all closed.
+func (s *Service) Wait() {
+}
+
+// Close close all dao.
+func (s *Service) Close() {
+	s.spyDao.Close()
+}
+
+func (s *Service) loadeventname() (err error) {
+	var (
+		c  = context.TODO()
+		es []*model.Event
+	)
+	es, err = s.spyDao.AllEvent(c)
+	if err != nil {
+		log.Error("loadeventname allevent error(%v)", err)
+		return
+	}
+	tmp := make(map[int64]string, len(es))
+	for _, e := range es {
+		tmp[e.ID] = e.NickName
+	}
+	s.allEventName = tmp
+	log.V(2).Info("loadeventname (%v) load success", tmp)
+	return
+}
+
+func (s *Service) loadeventproc() {
+	for {
+		time.Sleep(s.loadEventTick)
+		s.loadeventname()
+	}
+}

app/admin/main/spy/service/service_test.go

@@ -0,0 +1,106 @@
+package service
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"path/filepath"
+	"testing"
+
+	"go-common/app/admin/main/spy/conf"
+	"go-common/app/admin/main/spy/model"
+	"go-common/library/ecode"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	s *Service
+	c = context.TODO()
+)
+
+func init() {
+	var err error
+	dir, _ := filepath.Abs("../cmd/spy-admin-test.toml")
+	flag.Set("conf", dir)
+	if err = conf.Init(); err != nil {
+		panic(err)
+	}
+	s = New(conf.Conf)
+}
+
+func TestSetting(t *testing.T) {
+	Convey("test checkSettingVal", t, func() {
+		var err = s.checkSettingVal(model.AutoBlock, "abc")
+		So(err, ShouldEqual, ecode.SpySettingValTypeError)
+		err = s.checkSettingVal(model.AutoBlock, "3")
+		So(err, ShouldEqual, ecode.SpySettingValueOutOfRange)
+		err = s.checkSettingVal(model.AutoBlock, "1")
+		So(err, ShouldBeNil)
+		err = s.checkSettingVal(model.LessBlockScore, "abc")
+		So(err, ShouldEqual, ecode.SpySettingValTypeError)
+		err = s.checkSettingVal(model.LessBlockScore, "45")
+		So(err, ShouldEqual, ecode.SpySettingValueOutOfRange)
+		err = s.checkSettingVal(model.LessBlockScore, "1")
+		So(err, ShouldBeNil)
+		err = s.checkSettingVal(model.LimitBlockCount, "abc")
+		So(err, ShouldEqual, ecode.SpySettingValTypeError)
+		err = s.checkSettingVal(model.LimitBlockCount, "-2")
+		So(err, ShouldEqual, ecode.SpySettingValueOutOfRange)
+		err = s.checkSettingVal(model.LimitBlockCount, "20000")
+		So(err, ShouldBeNil)
+		err = s.checkSettingVal("unknown prop", "abc")
+		So(err, ShouldEqual, ecode.SpySettingUnknown)
+	})
+	Convey("test Setting", t, func() {
+		var (
+			list []*model.Setting
+			err  error
+		)
+		list, err = s.SettingList(c)
+		So(err, ShouldBeNil)
+		So(list, ShouldNotBeEmpty)
+		var (
+			name = "go test"
+			prop = list[0].Property
+			val  = list[0].Val
+		)
+		err = s.UpdateSetting(c, name, prop, val)
+		So(err, ShouldBeNil)
+		err = s.UpdateSetting(c, name, model.LessBlockScore, "100")
+		So(err, ShouldEqual, ecode.SpySettingValueOutOfRange)
+	})
+}
+
+// go test  -test.v -test.run TestStat
+func TestStat(t *testing.T) {
+	var (
+		state    int8  = 1
+		id       int64 = 3
+		isdel    int8  = 1
+		tid      int64 = 1
+		tmid     int64 = 1
+		ty       int8  = 1
+		count    int64 = 10
+		operater       = "admin"
+		pn             = 1
+		ps             = 8
+	)
+	Convey("test UpdateState", t, func() {
+		err := s.UpdateState(c, state, id, operater)
+		So(err, ShouldBeNil)
+	})
+	Convey("test UpdateStatQuantity", t, func() {
+		err := s.UpdateStatQuantity(c, count, id, operater)
+		So(err, ShouldBeNil)
+	})
+	Convey("test DeleteStat", t, func() {
+		err := s.DeleteStat(c, isdel, id, operater)
+		So(err, ShouldBeNil)
+	})
+	Convey("test StatPage", t, func() {
+		page, err := s.StatPage(c, tmid, tid, ty, pn, ps)
+		So(err, ShouldBeNil)
+		fmt.Println("page", page)
+	})
+}

app/admin/main/spy/service/setting.go

@@ -0,0 +1,76 @@
+package service
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/admin/main/spy/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// SettingList get all setting
+func (s *Service) SettingList(c context.Context) (list []*model.Setting, err error) {
+	if list, err = s.spyDao.SettingList(c); err != nil {
+		log.Error("s.spyDao.SettingList() error(%v)", err)
+		return
+	}
+	return
+}
+
+// UpdateSetting update setting
+func (s *Service) UpdateSetting(c context.Context, name string, property string, val string) (err error) {
+	if err = s.checkSettingVal(property, val); err != nil {
+		return
+	}
+	var effected int64
+	if effected, err = s.spyDao.UpdateSetting(c, property, val); err != nil {
+		log.Error("s.spyDao.UpdateSetting(%s,%d) error(%v)", property, val, err)
+		return
+	}
+	if effected > 0 {
+		updatedSetting := &model.Setting{Property: property, Val: val}
+		if err := s.AddLog(c, name, model.UpdateSetting, updatedSetting); err != nil {
+			log.Error("s.AddLog(%s,%d,%+v) error(%v)", name, model.UpdateSetting, updatedSetting, err)
+		}
+	}
+	return
+}
+
+func (s *Service) checkSettingVal(prop string, val string) (err error) {
+	switch prop {
+	case model.AutoBlock:
+		var block int64
+		if block, err = strconv.ParseInt(val, 10, 64); err != nil {
+			err = ecode.SpySettingValTypeError
+			return
+		}
+		if block != 1 && block != 0 {
+			err = ecode.SpySettingValueOutOfRange
+			return
+		}
+	case model.LimitBlockCount:
+		var count int64
+		if count, err = strconv.ParseInt(val, 10, 64); err != nil {
+			err = ecode.SpySettingValTypeError
+			return
+		}
+		if count < 0 {
+			err = ecode.SpySettingValueOutOfRange
+			return
+		}
+	case model.LessBlockScore:
+		var score int64
+		if score, err = strconv.ParseInt(val, 10, 64); err != nil {
+			err = ecode.SpySettingValTypeError
+			return
+		}
+		if score < 0 || score > 30 {
+			err = ecode.SpySettingValueOutOfRange
+			return
+		}
+	default:
+		err = ecode.SpySettingUnknown
+	}
+	return err
+}

app/admin/main/spy/service/stat.go

@@ -0,0 +1,95 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/admin/main/spy/model"
+)
+
+// UpdateState update spy state.
+func (s *Service) UpdateState(c context.Context, state int8, id int64, operater string) (err error) {
+	var (
+		context string
+	)
+	if _, err = s.spyDao.UpdateStatState(c, state, id); err != nil {
+		return
+	}
+	if state == 0 {
+		context = model.WaiteCheck
+	} else {
+		context = model.HadCheck
+	}
+	s.AddLog2(c, &model.Log{
+		Name:    operater,
+		RefID:   id,
+		Module:  model.UpdateStat,
+		Context: s.UpdateStateLog(id, context),
+		Ctime:   time.Now(),
+	})
+	return
+}
+
+// UpdateStatQuantity update stat quantity.
+func (s *Service) UpdateStatQuantity(c context.Context, count, id int64, operater string) (err error) {
+	var (
+		olds *model.Statistics
+	)
+	if olds, err = s.spyDao.Statistics(c, id); err != nil || olds == nil {
+		return
+	}
+	if _, err = s.spyDao.UpdateStatQuantity(c, count, id); err != nil {
+		return
+	}
+	s.AddLog2(c, &model.Log{
+		Name:    operater,
+		RefID:   id,
+		Module:  model.UpdateStat,
+		Context: s.UpdateStatCountLog(id, olds.Quantity, count),
+		Ctime:   time.Now(),
+	})
+	return
+}
+
+// DeleteStat delete stat.
+func (s *Service) DeleteStat(c context.Context, isdel int8, id int64, operater string) (err error) {
+	if _, err = s.spyDao.DeleteStat(c, isdel, id); err != nil {
+		return
+	}
+	s.AddLog2(c, &model.Log{
+		Name:    operater,
+		RefID:   id,
+		Module:  model.UpdateStat,
+		Context: s.DeleteStatLog(id),
+		Ctime:   time.Now(),
+	})
+	return
+}
+
+// StatPage  get  stat list.
+func (s *Service) StatPage(c context.Context, mid, id int64, t int8, pn, ps int) (page *model.StatPage, err error) {
+	var (
+		list  []*model.Statistics
+		count int64
+	)
+	page = &model.StatPage{Ps: ps, Pn: pn}
+	if t == model.AccountType {
+		count, err = s.spyDao.StatCountByMid(c, mid)
+		if err != nil || count == 0 {
+			return
+		}
+		list, err = s.spyDao.StatListByMid(c, mid, pn, ps)
+	} else {
+		count, err = s.spyDao.StatCountByID(c, id, t)
+		if err != nil || count == 0 {
+			return
+		}
+		list, err = s.spyDao.StatListByID(c, id, t, pn, ps)
+	}
+	for _, st := range list {
+		st.EventName = s.allEventName[st.EventID]
+	}
+	page.Items = list
+	page.TotalCount = count
+	return
+}

app/admin/main/spy/service/user.go

@@ -0,0 +1,126 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/admin/main/spy/model"
+	"go-common/library/log"
+)
+
+// UserInfo get UserInfo by mid , from cache or db or generate.
+func (s *Service) UserInfo(c context.Context, mid int64) (u *model.UserInfoDto, err error) {
+	var (
+		udb *model.UserInfo
+	)
+	if udb, err = s.spyDao.Info(c, mid); err != nil {
+		log.Error("s.spyDao.Info(%d) error(%v)", mid, err)
+		return
+	}
+
+	// init user score by rpc call
+	if udb == nil {
+		if _, err = s.spyDao.UserScore(c, mid); err != nil {
+			log.Error("s.spyDao.UserScore(%d) error(%v)", mid, err)
+			return
+		}
+		if udb, err = s.spyDao.Info(c, mid); err != nil {
+			log.Error("s.spyDao.Info(%d) error(%v)", mid, err)
+			return
+		}
+	}
+
+	if udb == nil {
+		log.Error("UserInfo init failed , still nil")
+		return
+	}
+	u = &model.UserInfoDto{
+		ID:          udb.ID,
+		Mid:         udb.Mid,
+		Score:       udb.Score,
+		BaseScore:   udb.BaseScore,
+		EventScore:  udb.EventScore,
+		State:       udb.State,
+		ReliveTimes: udb.ReliveTimes,
+		Mtime:       udb.Mtime.Unix(),
+	}
+	if m, err1 := s.spyDao.AccInfo(c, mid); err1 == nil && m != nil {
+		u.Name = m.Name
+	}
+	return
+}
+
+// HisoryPage history page.
+func (s *Service) HisoryPage(c context.Context, h *model.HisParamReq) (page *model.HistoryPage, err error) {
+	totalCount, err := s.spyDao.HistoryPageTotalC(c, h)
+	if err != nil {
+		log.Error("userDao HistoryPageTotalC(%v) error(%v)", h, err)
+		return
+	}
+	page = &model.HistoryPage{}
+	items, err := s.spyDao.HistoryPage(c, h)
+	if err != nil {
+		log.Error("spyDao.HistoryPage(%v) error(%v)", h, err)
+		return
+	}
+	page.TotalCount = totalCount
+	page.Items = items
+	page.Pn = h.Pn
+	page.Ps = h.Ps
+	return
+}
+
+// ResetBase reset user base score.
+func (s *Service) ResetBase(c context.Context, mid int64, operator string) (err error) {
+	if err = s.spyDao.ResetBase(c, mid, operator); err != nil {
+		log.Error("s.spyDao.ResetBase(%d,%s) error(%v)", mid, operator, err)
+		return
+	}
+	return
+}
+
+// Refresh reset user base score.
+func (s *Service) RefreshBase(c context.Context, mid int64, operator string) (err error) {
+	if err = s.spyDao.RefreshBase(c, mid, operator); err != nil {
+		log.Error("s.spyDao.RefreshBase(%d,%s) error(%v)", mid, operator, err)
+		return
+	}
+	return
+}
+
+// ResetEvent reset user event score.
+func (s *Service) ResetEvent(c context.Context, mid int64, operator string) (err error) {
+	if err = s.spyDao.ResetEvent(c, mid, operator); err != nil {
+		log.Error("s.spyDao.ResetEvent(%d,%s) error(%v)", mid, operator, err)
+		return
+	}
+	return
+}
+
+// ClearCount clear count.
+func (s *Service) ClearCount(c context.Context, mid int64, operator string) (err error) {
+	if err = s.spyDao.ClearCount(c, mid, operator); err != nil {
+		log.Error("s.spyDao.ClearCount(%d, %s) error(%v)", mid, operator, err)
+		return
+	}
+	return
+}
+
+// ReportList report list.
+func (s *Service) ReportList(c context.Context, ps, pn int) (page *model.ReportPage, err error) {
+	count, err := s.spyDao.ReportCount(c)
+	if err != nil {
+		log.Error("s.spyDao.ReportCount error(%v)", err)
+		return
+	}
+	page = &model.ReportPage{}
+	items, err := s.spyDao.ReportList(c, ps, pn)
+	if err != nil {
+		log.Error("s.spyDao.ReportPage(%d,%d) error(%v)", ps, pn, err)
+		return
+	}
+	page.TotalCount = count
+	page.Items = items
+	page.Pn = pn
+	page.Ps = ps
+	return
+}