Initial commit

app/admin/main/spy/dao/BUILD

@@ -0,0 +1,61 @@
+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",
+        "mysql_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",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.go",
+        "mysql.go",
+        "rpc.go",
+    ],
+    importpath = "go-common/app/admin/main/spy/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/spy/conf:go_default_library",
+        "//app/admin/main/spy/model:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//app/service/main/account/rpc/client:go_default_library",
+        "//app/service/main/spy/model:go_default_library",
+        "//app/service/main/spy/rpc/client:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log: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/spy/dao/dao.go

@@ -0,0 +1,72 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/admin/main/spy/conf"
+	account "go-common/app/service/main/account/rpc/client"
+	spy "go-common/app/service/main/spy/rpc/client"
+	"go-common/library/cache/memcache"
+	"go-common/library/database/sql"
+)
+
+// Dao struct user of Dao.
+type Dao struct {
+	c *conf.Config
+	// db
+	db              *sql.DB
+	getUserInfoStmt []*sql.Stmt
+	eventStmt       *sql.Stmt
+	factorAllStmt   *sql.Stmt
+	allGroupStmt    *sql.Stmt
+	// cache
+	mcUser       *memcache.Pool
+	mcUserExpire int32
+	// rpc
+	spyRPC *spy.Service
+	accRPC *account.Service3
+}
+
+// New create a instance of Dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// conf
+		c: c,
+		// db
+		db: sql.NewMySQL(c.DB.Spy),
+		// mc
+		mcUser:       memcache.NewPool(c.Memcache.User),
+		mcUserExpire: int32(time.Duration(c.Memcache.UserExpire) / time.Second),
+		// rpc
+		spyRPC: spy.New(c.SpyRPC),
+		accRPC: account.New3(c.AccountRPC),
+	}
+	if conf.Conf.Property.UserInfoShard <= 0 {
+		panic("conf.Conf.Property.UserInfoShard <= 0")
+	}
+	if conf.Conf.Property.HistoryShard <= 0 {
+		panic("conf.Conf.Property.HistoryShard <= 0")
+	}
+	d.getUserInfoStmt = make([]*sql.Stmt, conf.Conf.Property.UserInfoShard)
+	for i := int64(0); i < conf.Conf.Property.UserInfoShard; i++ {
+		d.getUserInfoStmt[i] = d.db.Prepared(fmt.Sprintf(_getUserInfoSQL, i))
+	}
+	d.eventStmt = d.db.Prepared(_eventSQL)
+	d.factorAllStmt = d.db.Prepared(_factorAllSQL)
+	d.allGroupStmt = d.db.Prepared(_allGroupSQL)
+	return
+}
+
+// Ping check connection of db , mc.
+func (d *Dao) Ping(c context.Context) (err error) {
+	return d.db.Ping(c)
+}
+
+// Close close connection of db , mc.
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}

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

@@ -0,0 +1,159 @@
+package dao
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/spy/conf"
+	"go-common/app/admin/main/spy/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	dataMID   = int64(15555180)
+	noDataMID = int64(1)
+	d         *Dao
+)
+
+const (
+	_cleanFactorSQL  = "delete from spy_factor where nick_name = ? AND service_id = ? AND event_id = ? AND risk_level = ?"
+	_cleanEventSQL   = "delete from spy_event where name = ? AND service_id = ? AND status = ?"
+	_cleanServiceSQL = "delete from spy_service where name = ? AND status = ?"
+	_cleanGroupSQL   = "delete from spy_factor_group where name = ?"
+)
+
+func CleanMysql() {
+	ctx := context.Background()
+	d.db.Exec(ctx, _cleanFactorSQL, "test", 1, 1, 2)
+	d.db.Exec(ctx, _cleanEventSQL, "test", 1, 1)
+	d.db.Exec(ctx, _cleanServiceSQL, "test", 1)
+	d.db.Exec(ctx, _cleanGroupSQL, "test")
+}
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account-law.spy-admin")
+		flag.Set("conf_token", "bc3d60c2bb2b08a1b690b004a1953d3c")
+		flag.Set("tree_id", "2857")
+		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/spy-admin-test.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	CleanMysql()
+	m.Run()
+	os.Exit(0)
+}
+
+func WithMysql(f func(d *Dao)) func() {
+	return func() {
+		f(d)
+	}
+}
+
+func Test_Mysql(t *testing.T) {
+	Convey("get user info", t, WithMysql(func(d *Dao) {
+		res, err := d.Info(context.TODO(), dataMID)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	}))
+	Convey("get user info no data ", t, WithMysql(func(d *Dao) {
+		res, err := d.Info(context.TODO(), noDataMID)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	}))
+	Convey("get event history", t, WithMysql(func(d *Dao) {
+		hpConf := &model.HisParamReq{
+			Mid: 46333,
+			Ps:  10,
+			Pn:  1,
+		}
+		res, err := d.HistoryPage(context.TODO(), hpConf)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	}))
+	Convey("get event history count", t, WithMysql(func(d *Dao) {
+		hpConf := &model.HisParamReq{
+			Mid: 46333,
+			Ps:  10,
+			Pn:  1,
+		}
+		res, err := d.HistoryPageTotalC(context.TODO(), hpConf)
+		So(err, ShouldBeNil)
+		fmt.Printf("history count : %d\n", res)
+		So(res, ShouldNotBeEmpty)
+	}))
+	Convey("get setting list", t, WithMysql(func(d *Dao) {
+		res, err := d.SettingList(context.TODO())
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	}))
+	Convey("update setting", t, WithMysql(func(d *Dao) {
+		list, err := d.SettingList(context.TODO())
+		So(err, ShouldBeNil)
+		setting := list[0]
+		res, err := d.UpdateSetting(context.TODO(), setting.Val, setting.Property)
+		So(err, ShouldBeNil)
+		fmt.Println(res)
+	}))
+	Convey(" add factor ", t, WithMysql(func(d *Dao) {
+		res, err := d.AddFactor(context.TODO(), &model.Factor{
+			NickName:   "test",
+			ServiceID:  int64(1),
+			EventID:    int64(1),
+			GroupID:    int64(1),
+			RiskLevel:  int8(2),
+			FactorVal:  float32(1),
+			CategoryID: int8(1),
+			CTime:      time.Now(),
+			MTime:      time.Now(),
+		})
+		So(err, ShouldBeNil)
+		So(res == 1, ShouldBeTrue)
+	}))
+	Convey(" add event ", t, WithMysql(func(d *Dao) {
+		res, err := d.AddEvent(context.TODO(), &model.Event{
+			Name:      "test",
+			NickName:  "nickname",
+			ServiceID: 1,
+			Status:    1,
+			CTime:     time.Now(),
+			MTime:     time.Now(),
+		})
+		So(err, ShouldBeNil)
+		So(res == 1, ShouldBeTrue)
+	}))
+	Convey(" add service ", t, WithMysql(func(d *Dao) {
+		res, err := d.AddService(context.TODO(), &model.Service{
+			Name:     "test",
+			NickName: "nickname",
+			Status:   1,
+			CTime:    time.Now(),
+			MTime:    time.Now(),
+		})
+		So(err, ShouldBeNil)
+		So(res == 1, ShouldBeTrue)
+	}))
+	Convey(" add group ", t, WithMysql(func(d *Dao) {
+		res, err := d.AddGroup(context.TODO(), &model.FactorGroup{
+			Name:  "test",
+			CTime: time.Now(),
+		})
+		So(err, ShouldBeNil)
+		So(res == 1, ShouldBeTrue)
+	}))
+}

app/admin/main/spy/dao/mysql.go

@@ -0,0 +1,584 @@
+package dao
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"go-common/app/admin/main/spy/conf"
+	"go-common/app/admin/main/spy/model"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_eventSQL              = "SELECT id,name,nick_name,service_id,ctime,mtime FROM spy_event WHERE name=? AND deleted = 0 LIMIT 1;"
+	_allGroupSQL           = "SELECT id, name, ctime FROM spy_factor_group;"
+	_updateFactorSQL       = "UPDATE spy_factor SET factor_val = ? WHERE id = ?;"
+	_factorAllSQL          = "SELECT id,nick_name,service_id,event_id,group_id,risk_level,factor_val,ctime,mtime FROM spy_factor WHERE group_id = ? ORDER BY factor_val;"
+	_getList               = "SELECT id,mid,event_id,score,base_score,event_score,remark,reason,factor_val,ctime FROM spy_user_event_history_%02d WHERE %s ORDER BY id DESC LIMIT %d,%d;"
+	_getListTc             = "SELECT COUNT(1) FROM spy_user_event_history_%02d WHERE %s;"
+	_addLogSQL             = "INSERT INTO `spy_log`(`name`,`module`,`context`,`ref_id`,`ctime`)VALUES(?,?,?,?,?);"
+	_getSettingListSQL     = "SELECT id,property,name,val,ctime,mtime FROM spy_system_config"
+	_updateSettingSQL      = "UPDATE spy_system_config SET val=? WHERE property=?"
+	_getUserInfoSQL        = "SELECT id,mid,score,base_score,event_score,state,relive_times,mtime FROM spy_user_info_%02d WHERE mid=?"
+	_addFactorSQL          = "INSERT INTO `spy_factor`(`nick_name`,`service_id`,`event_id`,`group_id`,`risk_level`,`factor_val`,`category_id`,`ctime`)VALUES(?,?,?,?,?,?,?,?);"
+	_addEventSQL           = "INSERT INTO `spy_event`(`name`,`nick_name`,`service_id`,`status`,`ctime`,`mtime`)VALUES(?,?,?,?,?,?);"
+	_addServiceSQL         = "INSERT INTO `spy_service`(`name`,`nick_name`,`status`,`ctime`,`mtime`)VALUES(?,?,?,?,?);"
+	_addGroupSQL           = "INSERT INTO `spy_factor_group`(`name`,`ctime`)VALUES(?,?);"
+	_getReportList         = "SELECT id, name, date_version, val, ctime FROM spy_report limit ?,?;"
+	_getReportCount        = "SELECT COUNT(1) FROM spy_report;"
+	_updateStatStateSQL    = "UPDATE spy_statistics SET state=? WHERE id=?"
+	_updateStatQuantitySQL = "UPDATE spy_statistics SET quantity=? WHERE id=?"
+	_updateStatDeleteSQL   = "UPDATE spy_statistics SET isdel=? WHERE id=?"
+	_statByIDSQL           = "SELECT id,target_mid,target_id,event_id,state,type,quantity,isdel,ctime,mtime FROM spy_statistics WHERE id = ?;"
+	_logListSQL            = "SELECT id,ref_id,name,module,context,ctime FROM spy_log WHERE ref_id = ? AND module = ?;"
+	_statListByMidSQL      = "SELECT id,target_mid,target_id,event_id,state,type,quantity,isdel,ctime,mtime FROM spy_statistics WHERE target_mid = ? AND isdel = 0  ORDER BY id desc limit ?,?;"
+	_statListByIDSQL       = "SELECT id,target_mid,target_id,event_id,state,type,quantity,isdel,ctime,mtime FROM spy_statistics WHERE target_id = ? AND type = ? AND isdel = 0  ORDER BY id desc limit ?,?;"
+	_statCountByMidSQL     = "SELECT COUNT(1) FROM spy_statistics WHERE target_mid = ? AND isdel = 0;"
+	_statCountByIDSQL      = "SELECT COUNT(1) FROM spy_statistics WHERE target_id = ? AND type = ? AND isdel = 0;"
+	_allEventSQL           = "SELECT id,name,nick_name,service_id,status,ctime,mtime FROM spy_event WHERE status<>0"
+	_updateEventNameSQL    = "UPDATE spy_event SET nick_name = ? WHERE id = ?;"
+)
+
+// Event get event from db.
+func (d *Dao) Event(ctx context.Context, eventName string) (event *model.Event, err error) {
+	var (
+		row *xsql.Row
+	)
+	event = &model.Event{}
+	row = d.eventStmt.QueryRow(ctx, eventName)
+	if err = row.Scan(&event.ID, &event.Name, &event.NickName, &event.ServiceID, &event.CTime, &event.MTime); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			return
+		}
+		log.Error("row.Scan() error(%v)", err)
+	}
+	return
+}
+
+// Factors get all factor info by group id.
+func (d *Dao) Factors(c context.Context, gid int64) (res []*model.Factor, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.factorAllStmt.Query(c, gid); err != nil {
+		log.Error("d.allTypesStmt.Query(%d) error(%v)", gid, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.Factor)
+		if err = rows.Scan(&r.ID, &r.NickName, &r.ServiceID, &r.EventID, &r.GroupID, &r.RiskLevel, &r.FactorVal, &r.CTime, &r.MTime); err != nil {
+			log.Error("row.Scan() error(%v)", err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	err = rows.Err()
+	return
+}
+
+// Groups get all group info.
+func (d *Dao) Groups(c context.Context) (res []*model.FactorGroup, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.allGroupStmt.Query(c); err != nil {
+		log.Error("d.allGroupStmt.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.FactorGroup)
+		if err = rows.Scan(&r.ID, &r.Name, &r.CTime); err != nil {
+			log.Error("row.Scan() error(%v)", err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	err = rows.Err()
+	return
+}
+
+// UpdateFactor update factor.
+func (d *Dao) UpdateFactor(c context.Context, factorVal float32, id int64) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _updateFactorSQL, factorVal, id); err != nil {
+		log.Error("_updateFactorSQL: db.Exec(%v, %d) error(%v)", factorVal, id, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+func hitHistory(id int64) int64 {
+	return id % conf.Conf.Property.HistoryShard
+}
+
+// genListSQL get history sql
+func (d *Dao) genListSQL(SQLType string, h *model.HisParamReq) (SQL string, values []interface{}) {
+	values = make([]interface{}, 0, 1)
+	cond := " mid = ?"
+	values = append(values, h.Mid)
+	switch SQLType {
+	case "list":
+		SQL = fmt.Sprintf(_getList, hitHistory(h.Mid), cond, (h.Pn-1)*h.Ps, h.Ps)
+	case "count":
+		SQL = fmt.Sprintf(_getListTc, hitHistory(h.Mid), cond)
+	}
+	return
+}
+
+//HistoryPage user event history.
+func (d *Dao) HistoryPage(c context.Context, h *model.HisParamReq) (hs []*model.EventHistoryDto, err error) {
+	SQL, values := d.genListSQL("list", h)
+	rows, err := d.db.Query(c, SQL, values...)
+	if err != nil {
+		log.Error("dao.QuestionPage(%v,%v) error(%v)", SQL, values, err)
+		return
+	}
+	defer rows.Close()
+	hs = make([]*model.EventHistoryDto, 0, h.Ps)
+	for rows.Next() {
+		hdb := &model.EventHistory{}
+		err = rows.Scan(&hdb.ID, &hdb.Mid, &hdb.EventID, &hdb.Score, &hdb.BaseScore, &hdb.EventScore,
+			&hdb.Remark, &hdb.Reason, &hdb.FactorVal, &hdb.Ctime)
+		eventMSG := &model.EventMessage{}
+		if err = json.Unmarshal([]byte(hdb.Remark), eventMSG); err != nil {
+			log.Error("json.Unmarshal(%s) error(%v)", hdb.Remark, err)
+		} else {
+			hdb.TargetID = eventMSG.TargetID
+			hdb.TargetMid = eventMSG.TargetMid
+		}
+		if err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		h := &model.EventHistoryDto{
+			ID:         hdb.ID,
+			Score:      hdb.Score,
+			BaseScore:  hdb.BaseScore,
+			EventScore: hdb.EventScore,
+			Reason:     hdb.Reason,
+			Ctime:      hdb.Ctime.Unix(),
+			TargetID:   hdb.TargetID,
+			TargetMid:  hdb.TargetMid,
+		}
+		if eventMSG.Time != 0 {
+			_, offset := time.Now().Zone()
+			t := time.Unix(eventMSG.Time, 0).Add(-time.Duration(offset) * time.Second)
+			h.SpyTime = t.Unix()
+		}
+		hs = append(hs, h)
+	}
+	return
+}
+
+// HistoryPageTotalC user ecent history page.
+func (d *Dao) HistoryPageTotalC(c context.Context, h *model.HisParamReq) (totalCount int, err error) {
+	SQL, values := d.genListSQL("count", h)
+	row := d.db.QueryRow(c, SQL, values...)
+	if err = row.Scan(&totalCount); err != nil {
+		if err == sql.ErrNoRows {
+			row = nil
+			err = nil
+		} else {
+			log.Error("row.Scan error(%v)", err)
+		}
+	}
+	return
+}
+
+//AddLog add log.
+func (d *Dao) AddLog(c context.Context, l *model.Log) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _addLogSQL, l.Name, l.Module, l.Context, l.RefID, l.Ctime); err != nil {
+		fmt.Println("add log ", err)
+		log.Error("add question: d.db.Exec(%v) error(%v)", l, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// SettingList get all setting list
+func (d *Dao) SettingList(c context.Context) (list []*model.Setting, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	list = make([]*model.Setting, 0)
+	if rows, err = d.db.Query(c, _getSettingListSQL); err != nil {
+		log.Error("d.db.Query(%s) error(%v)", _getSettingListSQL, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var setting = &model.Setting{}
+		if err = rows.Scan(&setting.ID, &setting.Property, &setting.Name, &setting.Val, &setting.CTime, &setting.MTime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		list = append(list, setting)
+	}
+	return
+}
+
+// UpdateSetting update setting
+func (d *Dao) UpdateSetting(c context.Context, property string, val string) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _updateSettingSQL, val, property); err != nil {
+		log.Error("d.db.Exec(%s,%d,%s) error(%v)", _updateSettingSQL, val, property)
+		return
+	}
+	if affected, err = res.RowsAffected(); err != nil {
+		log.Error("res.RowsAffected() error(%v)", err)
+		return
+	}
+	return
+}
+
+func hitInfo(id int64) int64 {
+	return id % conf.Conf.Property.UserInfoShard
+}
+
+// Info get lastest user info by mid.
+func (d *Dao) Info(c context.Context, mid int64) (res *model.UserInfo, err error) {
+	res = &model.UserInfo{}
+	hitIndex := hitInfo(mid)
+	row := d.getUserInfoStmt[hitIndex].QueryRow(c, mid)
+	if err = row.Scan(&res.ID, &res.Mid, &res.Score, &res.BaseScore, &res.EventScore, &res.State, &res.ReliveTimes,
+		&res.Mtime); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			res = nil
+			return
+		}
+		log.Error("Info:row.Scan() error(%v)", err)
+	}
+	return
+}
+
+//AddFactor add factor.
+func (d *Dao) AddFactor(c context.Context, f *model.Factor) (ret int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _addFactorSQL, f.NickName, f.ServiceID, f.EventID, f.GroupID, f.RiskLevel, f.FactorVal, f.CategoryID, f.CTime); err != nil {
+		log.Error("d.db AddFactor: d.db.Exec(%v) error(%v)", f, err)
+		return
+	}
+	ret, err = res.RowsAffected()
+	return
+}
+
+//AddEvent add event.
+func (d *Dao) AddEvent(c context.Context, f *model.Event) (ret int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _addEventSQL, f.Name, f.NickName, f.ServiceID, f.Status, f.CTime, f.MTime); err != nil {
+		log.Error("d.db AddEvent: d.db.Exec(%v) error(%v)", f, err)
+		return
+	}
+	ret, err = res.RowsAffected()
+	return
+}
+
+//AddService add service.
+func (d *Dao) AddService(c context.Context, f *model.Service) (ret int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _addServiceSQL, f.Name, f.NickName, f.Status, f.CTime, f.MTime); err != nil {
+		log.Error("d.db AddService: d.db.Exec(%v) error(%v)", f, err)
+		return
+	}
+	ret, err = res.RowsAffected()
+	return
+}
+
+//AddGroup add group.
+func (d *Dao) AddGroup(c context.Context, f *model.FactorGroup) (ret int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _addGroupSQL, f.Name, f.CTime); err != nil {
+		log.Error("d.db AddGroup: d.db.Exec(%v) error(%v)", f, err)
+		return
+	}
+	ret, err = res.RowsAffected()
+	return
+}
+
+// ReportList report list.
+func (d *Dao) ReportList(c context.Context, ps, pn int) (list []*model.ReportDto, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	if ps == 0 || pn == 0 {
+		ps = 8
+		pn = 1
+	}
+	list = make([]*model.ReportDto, 0)
+	if rows, err = d.db.Query(c, _getReportList, (pn-1)*ps, ps); err != nil {
+		log.Error("d.db.Query(%s) error(%v)", _getReportList, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var r = &model.Report{}
+		if err = rows.Scan(&r.ID, &r.Name, &r.DateVersion, &r.Val, &r.Ctime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		list = append(list, &model.ReportDto{
+			ID:          r.ID,
+			Name:        r.Name,
+			DateVersion: r.DateVersion,
+			Val:         r.Val,
+			Ctime:       r.Ctime.Unix(),
+		})
+	}
+	return
+}
+
+// ReportCount get repoet total count.
+func (d *Dao) ReportCount(c context.Context) (totalCount int, err error) {
+	var row = d.db.QueryRow(c, _getReportCount)
+	if err = row.Scan(&totalCount); err != nil {
+		if err == sql.ErrNoRows {
+			row = nil
+			err = nil
+		} else {
+			log.Error("row.Scan error(%v)", err)
+		}
+	}
+	return
+}
+
+// UpdateStatState update stat state.
+func (d *Dao) UpdateStatState(c context.Context, state int8, id int64) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _updateStatStateSQL, state, id); err != nil {
+		log.Error("d.db.Exec(%s,%d,%s) error(%v)", _updateStatStateSQL, state, id)
+		return
+	}
+	if affected, err = res.RowsAffected(); err != nil {
+		log.Error("res.RowsAffected() error(%v)", err)
+		return
+	}
+	return
+}
+
+// UpdateStatQuantity update stat quantity
+func (d *Dao) UpdateStatQuantity(c context.Context, count int64, id int64) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _updateStatQuantitySQL, count, id); err != nil {
+		log.Error("d.db.Exec(%s,%d,%s) error(%v)", _updateStatQuantitySQL, count, id)
+		return
+	}
+	if affected, err = res.RowsAffected(); err != nil {
+		log.Error("res.RowsAffected() error(%v)", err)
+		return
+	}
+	return
+}
+
+// DeleteStat delete stat.
+func (d *Dao) DeleteStat(c context.Context, isdel int8, id int64) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _updateStatDeleteSQL, isdel, id); err != nil {
+		log.Error("d.db.Exec(%s,%d,%s) error(%v)", _updateStatDeleteSQL, isdel, id)
+		return
+	}
+	if affected, err = res.RowsAffected(); err != nil {
+		log.Error("res.RowsAffected() error(%v)", err)
+		return
+	}
+	return
+}
+
+// Statistics get stat info by id from db.
+func (d *Dao) Statistics(c context.Context, id int64) (stat *model.Statistics, err error) {
+	var (
+		row *xsql.Row
+	)
+	stat = &model.Statistics{}
+	row = d.db.QueryRow(c, _statByIDSQL, id)
+	if err = row.Scan(&stat.ID, &stat.TargetMid, &stat.TargetID, &stat.EventID, &stat.State, &stat.Type, &stat.Quantity, &stat.Isdel, &stat.Ctime, &stat.Mtime); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			stat = nil
+			return
+		}
+		log.Error("row.Scan() error(%v)", err)
+	}
+	return
+}
+
+//LogList log list.
+func (d *Dao) LogList(c context.Context, refID int64, module int8) (list []*model.Log, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	list = make([]*model.Log, 0)
+	if rows, err = d.db.Query(c, _logListSQL, refID, module); err != nil {
+		log.Error("d.db.Query(%s) error(%v)", _logListSQL, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var r = &model.Log{}
+		if err = rows.Scan(&r.ID, &r.RefID, &r.Name, &r.Module, &r.Context, &r.Ctime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		list = append(list, &model.Log{
+			ID:        r.ID,
+			RefID:     r.RefID,
+			Name:      r.Name,
+			Module:    r.Module,
+			Context:   r.Context,
+			CtimeUnix: r.Ctime.Unix(),
+		})
+	}
+	return
+}
+
+//StatListByMid stat list by mid.
+func (d *Dao) StatListByMid(c context.Context, mid int64, pn, ps int) (list []*model.Statistics, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	if ps == 0 || pn == 0 {
+		ps = 8
+		pn = 1
+	}
+	list = make([]*model.Statistics, 0)
+	if rows, err = d.db.Query(c, _statListByMidSQL, mid, (pn-1)*ps, ps); err != nil {
+		log.Error("d.db.Query(%s) error(%v)", _statListByMidSQL, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var stat = &model.Statistics{}
+		if err = rows.Scan(&stat.ID, &stat.TargetMid, &stat.TargetID, &stat.EventID, &stat.State, &stat.Type, &stat.Quantity, &stat.Isdel, &stat.Ctime, &stat.Mtime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		list = append(list, &model.Statistics{
+			ID:        stat.ID,
+			TargetMid: stat.TargetMid,
+			TargetID:  stat.TargetID,
+			EventID:   stat.EventID,
+			Type:      stat.Type,
+			State:     stat.State,
+			Quantity:  stat.Quantity,
+			Isdel:     stat.Isdel,
+			Ctime:     stat.Ctime,
+			Mtime:     stat.Mtime,
+			CtimeUnix: stat.Ctime.Unix(),
+			MtimeUnix: stat.Mtime.Unix(),
+		})
+	}
+	return
+}
+
+//StatListByID stat list by id.
+func (d *Dao) StatListByID(c context.Context, id int64, t int8, pn, ps int) (list []*model.Statistics, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	if ps == 0 || pn == 0 {
+		ps = 8
+		pn = 1
+	}
+	list = make([]*model.Statistics, 0)
+	if rows, err = d.db.Query(c, _statListByIDSQL, id, t, (pn-1)*ps, ps); err != nil {
+		log.Error("d.db.Query(%s) error(%v)", _statListByIDSQL, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var stat = &model.Statistics{}
+		if err = rows.Scan(&stat.ID, &stat.TargetMid, &stat.TargetID, &stat.EventID, &stat.State, &stat.Type, &stat.Quantity, &stat.Isdel, &stat.Ctime, &stat.Mtime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		list = append(list, &model.Statistics{
+			ID:        stat.ID,
+			TargetMid: stat.TargetMid,
+			TargetID:  stat.TargetID,
+			EventID:   stat.EventID,
+			Type:      stat.Type,
+			State:     stat.State,
+			Quantity:  stat.Quantity,
+			Isdel:     stat.Isdel,
+			Ctime:     stat.Ctime,
+			Mtime:     stat.Mtime,
+			CtimeUnix: stat.Ctime.Unix(),
+			MtimeUnix: stat.Mtime.Unix(),
+		})
+	}
+	return
+}
+
+// StatCountByMid count by mid.
+func (d *Dao) StatCountByMid(c context.Context, mid int64) (totalCount int64, err error) {
+	row := d.db.QueryRow(c, _statCountByMidSQL, mid)
+	if err = row.Scan(&totalCount); err != nil {
+		if err == sql.ErrNoRows {
+			row = nil
+			err = nil
+		} else {
+			log.Error("row.Scan error(%v)", err)
+		}
+	}
+	return
+}
+
+// StatCountByID count by id.
+func (d *Dao) StatCountByID(c context.Context, id int64, t int8) (totalCount int64, err error) {
+	row := d.db.QueryRow(c, _statCountByIDSQL, id, t)
+	if err = row.Scan(&totalCount); err != nil {
+		if err == sql.ErrNoRows {
+			row = nil
+			err = nil
+		} else {
+			log.Error("row.Scan error(%v)", err)
+		}
+	}
+	return
+}
+
+//AllEvent all event.
+func (d *Dao) AllEvent(c context.Context) (list []*model.Event, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	list = make([]*model.Event, 0)
+	if rows, err = d.db.Query(c, _allEventSQL); err != nil {
+		log.Error("d.db.Query(%s) error(%v)", _allEventSQL, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var event = &model.Event{}
+		if err = rows.Scan(&event.ID, &event.Name, &event.NickName, &event.ServiceID, &event.Status, &event.CTime, &event.MTime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		list = append(list, &model.Event{
+			ID:        event.ID,
+			Name:      event.Name,
+			NickName:  event.NickName,
+			ServiceID: event.ServiceID,
+			Status:    event.Status,
+			CTime:     event.CTime,
+			MTime:     event.MTime,
+		})
+	}
+	return
+}
+
+// UpdateEventName update event name.
+func (d *Dao) UpdateEventName(c context.Context, e *model.Event) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _updateEventNameSQL, e.NickName, e.ID); err != nil {
+		log.Error("_updateEventNameSQL: db.Exec(%v, %d) error(%v)", e.NickName, e.ID, err)
+		return
+	}
+	return res.RowsAffected()
+}

app/admin/main/spy/dao/mysql_test.go

@@ -0,0 +1,74 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"go-common/app/admin/main/spy/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	statID    int64 = 3
+	statState int8  = 1
+	statCount int64 = 1
+	statIsdel int8  = 1
+	statMid   int64 = 1
+	statType  int8  = 2
+	pn              = 1
+	ps              = 8
+)
+
+// go test  -test.v -test.run TestDB
+func TestDB(t *testing.T) {
+	Convey(" UpdateStatState ", t, WithMysql(func(d *Dao) {
+		_, err := d.UpdateStatState(context.TODO(), statState, statID)
+		So(err, ShouldBeNil)
+	}))
+	Convey(" UpdateStatQuantity ", t, WithMysql(func(d *Dao) {
+		_, err := d.UpdateStatQuantity(context.TODO(), statCount, statID)
+		So(err, ShouldBeNil)
+	}))
+	Convey(" DeleteStat ", t, WithMysql(func(d *Dao) {
+		_, err := d.DeleteStat(context.TODO(), statIsdel, statID)
+		So(err, ShouldBeNil)
+	}))
+	Convey(" Statistics ", t, WithMysql(func(d *Dao) {
+		stat, err := d.Statistics(context.TODO(), statID)
+		So(err, ShouldBeNil)
+		fmt.Println("stat", stat)
+	}))
+	Convey(" LogList ", t, WithMysql(func(d *Dao) {
+		logs, err := d.LogList(context.TODO(), statID, model.UpdateStat)
+		So(err, ShouldBeNil)
+		for _, l := range logs {
+			fmt.Println(l.Context)
+		}
+	}))
+	Convey(" StatListByMid ", t, WithMysql(func(d *Dao) {
+		stat, err := d.StatListByMid(context.TODO(), statMid, pn, ps)
+		So(err, ShouldBeNil)
+		for _, s := range stat {
+			fmt.Println(s.EventID)
+		}
+	}))
+	Convey(" StatListByID ", t, WithMysql(func(d *Dao) {
+		stat, err := d.StatListByID(context.TODO(), statID, statType, pn, ps)
+		So(err, ShouldBeNil)
+		for _, s := range stat {
+			fmt.Println(s.EventID)
+		}
+	}))
+	Convey(" StatCountByMid ", t, WithMysql(func(d *Dao) {
+		stat, err := d.StatCountByMid(context.TODO(), statMid)
+		So(err, ShouldBeNil)
+		fmt.Println("count ", stat)
+	}))
+	Convey(" StatCountByID ", t, WithMysql(func(d *Dao) {
+		stat, err := d.StatCountByID(context.TODO(), statID, statType)
+		So(err, ShouldBeNil)
+		fmt.Println("count ", stat)
+	}))
+}

app/admin/main/spy/dao/rpc.go

@@ -0,0 +1,88 @@
+package dao
+
+import (
+	"context"
+
+	accmdl "go-common/app/service/main/account/model"
+	spymdl "go-common/app/service/main/spy/model"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+)
+
+// UserScore get userscore by id , will init score if score not exist.
+func (d *Dao) UserScore(c context.Context, mid int64) (userScore *spymdl.UserScore, err error) {
+	var argUserScore = &spymdl.ArgUserScore{
+		Mid: mid,
+		IP:  metadata.String(c, metadata.RemoteIP),
+	}
+	if userScore, err = d.spyRPC.UserScore(c, argUserScore); err != nil {
+		log.Error("dao.spyRPC.UserScore(%v) error(%v)", argUserScore, err)
+		return
+	}
+	return
+}
+
+// AccInfo get account info by mid
+func (d *Dao) AccInfo(c context.Context, mid int64) (ai *accmdl.Info, err error) {
+	arg := &accmdl.ArgMid{Mid: mid}
+	if ai, err = d.accRPC.Info3(c, arg); err != nil || ai == nil {
+		log.Error("s.accRPC.Info(%d) error(%v)", mid, err)
+	}
+	return
+}
+
+// ResetBase reset user base score.
+func (d *Dao) ResetBase(c context.Context, mid int64, operator string) (err error) {
+	arg := &spymdl.ArgReset{
+		Mid:       mid,
+		BaseScore: true,
+		Operator:  operator,
+	}
+	if err = d.spyRPC.UpdateBaseScore(c, arg); err != nil {
+		log.Error("s.spyRPC.UpdateBaseScore(%v) error(%v)", arg, err)
+		return
+	}
+	return
+}
+
+// RefreshBase reset user base score.
+func (d *Dao) RefreshBase(c context.Context, mid int64, operator string) (err error) {
+	arg := &spymdl.ArgReset{
+		Mid:       mid,
+		BaseScore: true,
+		Operator:  operator,
+	}
+	if err = d.spyRPC.RefreshBaseScore(c, arg); err != nil {
+		log.Error("s.spyRPC.RefreshBaseScore(%v) error(%v)", arg, err)
+		return
+	}
+	return
+}
+
+// ResetEvent reset user event score.
+func (d *Dao) ResetEvent(c context.Context, mid int64, operator string) (err error) {
+	arg := &spymdl.ArgReset{
+		Mid:        mid,
+		EventScore: true,
+		Operator:   operator,
+	}
+	if err = d.spyRPC.UpdateEventScore(c, arg); err != nil {
+		log.Error("s.spyRPC.UpdateEventScore(%v) error(%v)", arg, err)
+		return
+	}
+	return
+}
+
+// ClearCount clear count.
+func (d *Dao) ClearCount(c context.Context, mid int64, operator string) (err error) {
+	arg := &spymdl.ArgReset{
+		Mid:        mid,
+		ReLiveTime: true,
+		Operator:   operator,
+	}
+	if err = d.spyRPC.ClearReliveTimes(c, arg); err != nil {
+		log.Error("d.spyRPC.ClearReliveTimes(%v) error(%v)", arg, err)
+		return
+	}
+	return
+}