Create & Init Project...

app/admin/main/up-rating/dao/BUILD

@@ -0,0 +1,62 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "authority.go",
+        "dao.go",
+        "parameter.go",
+        "score.go",
+        "statistics.go",
+    ],
+    importpath = "go-common/app/admin/main/up-rating/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/up-rating/conf:go_default_library",
+        "//app/admin/main/up-rating/model:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/xstr:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/up-rating/dao/global:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "authority_test.go",
+        "dao_test.go",
+        "parameter_test.go",
+        "score_test.go",
+        "statistics_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/up-rating/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/admin/main/up-rating/dao/authority.go

@@ -0,0 +1,42 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"go-common/library/xstr"
+)
+
+const (
+	_addAuthoritySQL = "INSERT INTO up_white_list(mid) VALUES %s ON DUPLICATE KEY UPDATE is_deleted=0"
+	_rmAuthoritySQL  = "UPDATE up_white_list SET is_deleted = 1 WHERE mid IN (%s)"
+)
+
+// AddAuthority .
+func (d *Dao) AddAuthority(c context.Context, mids []int64) (int64, error) {
+	if len(mids) == 0 {
+		return 0, nil
+	}
+	s := make([]string, 0)
+	for _, v := range mids {
+		s = append(s, fmt.Sprintf("(%d)", v))
+	}
+	res, err := d.db.Exec(c, fmt.Sprintf(_addAuthoritySQL, strings.Join(s, ",")))
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}
+
+// RmAuthority .
+func (d *Dao) RmAuthority(c context.Context, mids []int64) (int64, error) {
+	if len(mids) == 0 {
+		return 0, nil
+	}
+	res, err := d.db.Exec(c, fmt.Sprintf(_rmAuthoritySQL, xstr.JoinInts(mids)))
+	if err != nil {
+		return 0, err
+	}
+	return res.RowsAffected()
+}

app/admin/main/up-rating/dao/authority_test.go

@@ -0,0 +1,40 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoAddAuthority(t *testing.T) {
+	convey.Convey("AddAuthority", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mids = []int64{1, 2}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			p1, err := d.AddAuthority(c, mids)
+			ctx.Convey("Then err should be nil.p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRmAuthority(t *testing.T) {
+	convey.Convey("RmAuthority", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mids = []int64{1, 2}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			p1, err := d.RmAuthority(c, mids)
+			ctx.Convey("Then err should be nil.p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/admin/main/up-rating/dao/dao.go

@@ -0,0 +1,36 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/admin/main/up-rating/conf"
+
+	"go-common/library/database/sql"
+)
+
+// Dao dao
+type Dao struct {
+	c  *conf.Config
+	db *sql.DB
+}
+
+// New fn
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:  c,
+		db: sql.NewMySQL(c.DB.Rating),
+	}
+	return
+}
+
+// Ping ping health.
+func (d *Dao) Ping(c context.Context) (err error) {
+	return d.db.Ping(c)
+}
+
+// Close close connections of db.
+func (d *Dao) Close() {
+	if d.db != nil {
+		d.db.Close()
+	}
+}

app/admin/main/up-rating/dao/dao_test.go

@@ -0,0 +1,34 @@
+package dao
+
+import (
+	"flag"
+	"go-common/app/admin/main/up-rating/conf"
+	"os"
+	"testing"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.up-rating-admin")
+		flag.Set("conf_token", "15a509f907688750c0f2fceb768005f5")
+		flag.Set("tree_id", "66972")
+		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/up-rating-admin.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/admin/main/up-rating/dao/global/BUILD

@@ -0,0 +1,53 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "account.go",
+        "resource.go",
+    ],
+    importpath = "go-common/app/admin/main/up-rating/dao/global",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/up-rating/conf:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//app/service/main/account/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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "account_test.go",
+        "resource_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/up-rating/conf:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/admin/main/up-rating/dao/global/account.go

@@ -0,0 +1,35 @@
+package global
+
+import (
+	"context"
+
+	accmdl "go-common/app/service/main/account/model"
+	"go-common/library/log"
+)
+
+// MID gets mid by nickname
+func MID(c context.Context, nickname string) (mid int64, err error) {
+	res, err := GetAccRPC().InfosByName3(c, &accmdl.ArgNames{Names: []string{nickname}})
+	if err != nil {
+		log.Error("InfosByName3 fail, nickname=%+v, err=%+v", nickname, err)
+		return
+	}
+	for k := range res {
+		mid = k
+	}
+	return
+}
+
+// Names get nicknames by mids
+func Names(c context.Context, mids []int64) (res map[int64]string, err error) {
+	res = make(map[int64]string)
+	infos, err := GetAccRPC().Infos3(c, &accmdl.ArgMids{Mids: mids})
+	if err != nil {
+		log.Error("Infos3 fail, mids=%+v, err=%+v", mids, err)
+		return
+	}
+	for k, v := range infos {
+		res[k] = v.Name
+	}
+	return
+}

app/admin/main/up-rating/dao/global/account_test.go

@@ -0,0 +1,40 @@
+package global
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestGlobalMID(t *testing.T) {
+	convey.Convey("MID", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			nickname = "hashbaz"
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			mid, err := MID(c, nickname)
+			ctx.Convey("Then err should be nil.mid should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(mid, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestGlobalNames(t *testing.T) {
+	convey.Convey("Names", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mids = []int64{40052}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err := Names(c, mids)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/admin/main/up-rating/dao/global/resource.go

@@ -0,0 +1,20 @@
+package global
+
+import (
+	"go-common/app/admin/main/up-rating/conf"
+	accrpc "go-common/app/service/main/account/rpc/client"
+)
+
+var (
+	accRPC *accrpc.Service3
+)
+
+// Init resources
+func Init(c *conf.Config) {
+	accRPC = accrpc.New3(c.RPCClient.Account)
+}
+
+// GetAccRPC .
+func GetAccRPC() *accrpc.Service3 {
+	return accRPC
+}

app/admin/main/up-rating/dao/global/resource_test.go

@@ -0,0 +1,47 @@
+package global
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/admin/main/up-rating/conf"
+	"go-common/library/net/rpc"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestGlobalInit(t *testing.T) {
+	convey.Convey("Init", t, func(ctx convey.C) {
+		var (
+			c = &conf.Config{RPCClient: &conf.RPCClient{Account: &rpc.ClientConfig{}}}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			Init(c)
+			ctx.Convey("No return values", func(ctx convey.C) {
+			})
+		})
+	})
+}
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.up-rating-admin")
+		flag.Set("conf_token", "15a509f907688750c0f2fceb768005f5")
+		flag.Set("tree_id", "66972")
+		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/up-rating-admin.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	Init(conf.Conf)
+	os.Exit(m.Run())
+}

app/admin/main/up-rating/dao/parameter.go

@@ -0,0 +1,50 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/log"
+)
+
+var (
+	// select
+	_allParameterSQL = "SELECT name, value FROM rating_parameter"
+
+	// insert
+	_inParameterSQL = "INSERT INTO rating_parameter(name, value, remark) VALUES %s ON DUPLICATE KEY UPDATE value=VALUES(value), remark=VALUES(remark)"
+)
+
+// GetAllParameter get all parameter
+func (d *Dao) GetAllParameter(c context.Context) (parameters map[string]int64, err error) {
+	parameters = make(map[string]int64)
+	rows, err := d.db.Query(c, _allParameterSQL)
+	if err != nil {
+		log.Error("d.db.Query GetAllParameter error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var name string
+		var vaule int64
+		err = rows.Scan(&name, &vaule)
+		if err != nil {
+			log.Error("rows.Scan GetAllParameter error(%v)", err)
+			return
+		}
+		parameters[name] = vaule
+	}
+	return
+}
+
+// InsertParameter insert vals into rating_parameter
+func (d *Dao) InsertParameter(c context.Context, val string) (rows int64, err error) {
+	if val == "" {
+		return
+	}
+	res, err := d.db.Exec(c, fmt.Sprintf(_inParameterSQL, val))
+	if err != nil {
+		return
+	}
+	return res.RowsAffected()
+}

app/admin/main/up-rating/dao/parameter_test.go

@@ -0,0 +1,39 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoGetAllParameter(t *testing.T) {
+	convey.Convey("GetAllParameter", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			parameters, err := d.GetAllParameter(c)
+			ctx.Convey("Then err should be nil.parameters should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(parameters, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoInsertParameter(t *testing.T) {
+	convey.Convey("InsertParameter", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			val = "('wmaafans',100,'活跃粉丝数')"
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			rows, err := d.InsertParameter(c, val)
+			ctx.Convey("Then err should be nil.rows should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rows, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/admin/main/up-rating/dao/score.go

@@ -0,0 +1,120 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/admin/main/up-rating/model"
+
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+const (
+	_scoreTotalSQL = "SELECT count(*) FROM up_rating_%02d WHERE cdate=? %s"
+	_scoreListSQL  = "SELECT mid, tag_id, cdate, creativity_score, influence_score, credit_score, magnetic_score FROM up_rating_%02d WHERE cdate=? %s"
+	_levelListSQL  = "SELECT mid, total_fans, total_avs FROM up_level_info_%02d WHERE cdate=? AND mid IN (%s)"
+	_upScoresSQL   = "SELECT cdate, creativity_score, influence_score, credit_score, magnetic_score FROM up_rating_%02d WHERE mid = ?"
+	_upScoreSQL    = "SELECT cdate, creativity_score, influence_score, credit_score, magnetic_score FROM up_rating_%02d WHERE mid = ? AND cdate=?"
+	_taskStatusSQL = "SELECT status FROM task_status WHERE date=?"
+)
+
+// Total counts scores
+func (d *Dao) Total(c context.Context, mon int, date, where string) (total int64, err error) {
+	row := d.db.QueryRow(c, fmt.Sprintf(_scoreTotalSQL, mon, where), date)
+	if err = row.Scan(&total); err != nil {
+		log.Error("d.Total row.Scan error(%v)", err)
+	}
+	return
+}
+
+// ScoreList return info
+func (d *Dao) ScoreList(c context.Context, mon int, date, where string) (list []*model.RatingInfo, err error) {
+	list = make([]*model.RatingInfo, 0)
+	rows, err := d.db.Query(c, fmt.Sprintf(_scoreListSQL, mon, where), date)
+	if err != nil {
+		log.Error("d.ScoreList d.db.Query error(%v)", err)
+		return
+	}
+
+	defer rows.Close()
+	for rows.Next() {
+		v := &model.RatingInfo{}
+		err = rows.Scan(&v.Mid, &v.TagID, &v.ScoreDate, &v.CreativityScore, &v.InfluenceScore, &v.CreditScore, &v.MagneticScore)
+		if err != nil {
+			log.Error("d.ScoreList rows.Scan error(%v)", err)
+			return
+		}
+		list = append(list, v)
+	}
+	err = rows.Err()
+	return
+}
+
+// LevelList returns info
+func (d *Dao) LevelList(c context.Context, mon int, date string, mids []int64) (list []*model.RatingInfo, err error) {
+	list = make([]*model.RatingInfo, 0, len(mids))
+	rows, err := d.db.Query(c, fmt.Sprintf(_levelListSQL, mon, xstr.JoinInts(mids)), date)
+	if err != nil {
+		log.Error("d.LevelList d.db.Query error(%v)", err)
+		return
+	}
+
+	defer rows.Close()
+	for rows.Next() {
+		v := &model.RatingInfo{}
+		if err = rows.Scan(&v.Mid, &v.TotalFans, &v.TotalAvs); err != nil {
+			log.Error("d.LevelList rows.Scan error(%v)", err)
+			return
+		}
+		list = append(list, v)
+	}
+	err = rows.Err()
+	return
+}
+
+// UpScores ...
+func (d *Dao) UpScores(c context.Context, mon int, mid int64) (list []*model.RatingInfo, err error) {
+	list = make([]*model.RatingInfo, 0)
+	rows, err := d.db.Query(c, fmt.Sprintf(_upScoresSQL, mon), mid)
+	if err != nil {
+		log.Error("d.db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		v := &model.RatingInfo{}
+		err = rows.Scan(&v.ScoreDate, &v.CreativityScore, &v.InfluenceScore, &v.CreditScore, &v.MagneticScore)
+		if err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		list = append(list, v)
+	}
+	err = rows.Err()
+	return
+}
+
+// UpScore ...
+func (d *Dao) UpScore(c context.Context, mon int, mid int64, date string) (res *model.RatingInfo, err error) {
+	res = new(model.RatingInfo)
+	row := d.db.QueryRow(c, fmt.Sprintf(_upScoreSQL, mon), mid, date)
+	err = row.Scan(&res.ScoreDate, &res.CreativityScore, &res.InfluenceScore, &res.CreditScore, &res.MagneticScore)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, nil
+		}
+		log.Error("row.Scan error(%v)", err)
+	}
+	return
+}
+
+// TaskStatus returns status of task on date
+func (d *Dao) TaskStatus(c context.Context, date string) (status int, err error) {
+	row := d.db.QueryRow(c, _taskStatusSQL, date)
+	if err = row.Scan(&status); err != nil {
+		log.Error("d.TaskStatus row.Scan error(%v)", err)
+	}
+	return
+}

app/admin/main/up-rating/dao/score_test.go

@@ -0,0 +1,118 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoTotal(t *testing.T) {
+	convey.Convey("Total", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			mon   = int(6)
+			date  = "2018-06-01"
+			where = ""
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.db.Exec(c, "INSERT INTO up_rating_06(mid,cdate,creativity_score) VALUES(1001, '2018-06-01', 100) ON DUPLICATE KEY UPDATE creativity_score=VALUES(creativity_score)")
+			total, err := d.Total(c, mon, date, where)
+			ctx.Convey("Then err should be nil.total should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(total, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoScoreList(t *testing.T) {
+	convey.Convey("ScoreList", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			mon   = int(6)
+			date  = "2018-06-01"
+			where = ""
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.db.Exec(c, "INSERT INTO up_rating_06(mid,cdate,creativity_score) VALUES(1001, '2018-06-01', 100) ON DUPLICATE KEY UPDATE creativity_score=VALUES(creativity_score)")
+			list, err := d.ScoreList(c, mon, date, where)
+			ctx.Convey("Then err should be nil.list should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(list, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoLevelList(t *testing.T) {
+	convey.Convey("LevelList", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mon  = int(6)
+			date = "2018-06-01"
+			mids = []int64{1001}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.db.Exec(c, "INSERT INTO up_rating_06(mid,cdate,creativity_score) VALUES(1001, '2018-06-01', 100) ON DUPLICATE KEY UPDATE creativity_score=VALUES(creativity_score)")
+			list, err := d.LevelList(c, mon, date, mids)
+			ctx.Convey("Then err should be nil.list should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(list, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpScore(t *testing.T) {
+	convey.Convey("UpScore", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mon  = int(6)
+			mid  = int64(1001)
+			date = "2018-06-01"
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err := d.UpScore(c, mon, mid, date)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoTaskStatus(t *testing.T) {
+	convey.Convey("TaskStatus", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			date = "2018-06-01"
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.db.Exec(c, "INSERT INTO task_status(date,type) VALUES('2018-06-01', 2) ON DUPLICATE KEY UPDATE type=VALUES(type)")
+			status, err := d.TaskStatus(c, date)
+			ctx.Convey("Then err should be nil.status should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(status, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpScores(t *testing.T) {
+	convey.Convey("UpScores", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mon = int(6)
+			mid = int64(1001)
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.db.Exec(c, "INSERT INTO up_rating_06(mid,cdate,creativity_score) VALUES(1001, '2018-06-01', 100) ON DUPLICATE KEY UPDATE creativity_score=VALUES(creativity_score)")
+			list, err := d.UpScores(c, mon, mid)
+			ctx.Convey("Then err should be nil.list should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(list, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/admin/main/up-rating/dao/statistics.go

@@ -0,0 +1,119 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/admin/main/up-rating/model"
+
+	"go-common/library/log"
+)
+
+const (
+	_totalType int64 = iota
+	_creativeType
+	_influenceType
+	_creditType
+)
+
+const (
+	// select
+	_ratingStatisticsSQL = "SELECT ups,section,tips,total_score,creativity_score,influence_score,credit_score,fans,avs,coin,play,tag_id,ctype,cdate FROM up_rating_statistics WHERE cdate = '%s' AND ctype = ? AND tag_id IN (%s)"
+
+	_trendAscCountSQL  = "SELECT count(*) FROM up_rating_trend_asc WHERE date='%s' %s"
+	_trendDescCountSQL = "SELECT count(*) FROM up_rating_trend_desc WHERE date='%s' %s"
+	_trendAscSQL       = "SELECT mid,magnetic_score,creativity_score,influence_score,credit_score,%s_diff FROM up_rating_trend_asc WHERE date='%s' %s"
+	_trendDescSQL      = "SELECT mid,magnetic_score,creativity_score,influence_score,credit_score,%s_diff FROM up_rating_trend_desc WHERE date='%s' %s"
+)
+
+// GetRatingStatis get rating statistics
+func (d *Dao) GetRatingStatis(c context.Context, ctype int64, date, tags string) (statis []*model.RatingStatis, err error) {
+	statis = make([]*model.RatingStatis, 0)
+	rows, err := d.db.Query(c, fmt.Sprintf(_ratingStatisticsSQL, date, tags), ctype)
+	if err != nil {
+		log.Error("d.db.Query error(%v)", err)
+		return
+	}
+
+	defer rows.Close()
+	for rows.Next() {
+		s := &model.RatingStatis{}
+		err = rows.Scan(
+			&s.Ups, &s.Section, &s.Tips, &s.TotalScore, &s.CreativityScore, &s.InfluenceScore, &s.CreditScore, &s.Fans, &s.Avs, &s.Coin, &s.Play, &s.TagID, &s.CType, &s.CDate)
+		if err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		switch ctype {
+		case _totalType:
+			s.Score = s.TotalScore
+		case _creativeType:
+			s.Score = s.CreativityScore
+		case _influenceType:
+			s.Score = s.InfluenceScore
+		case _creditType:
+			s.Score = s.CreditScore
+		}
+		statis = append(statis, s)
+	}
+	err = rows.Err()
+	return
+}
+
+// AscTrendCount asc trend count
+func (d *Dao) AscTrendCount(c context.Context, date string, query string) (count int, err error) {
+	row := d.db.QueryRow(c, fmt.Sprintf(_trendAscCountSQL, date, query))
+	if err = row.Scan(&count); err != nil {
+		log.Error("d.db.Query error(%v)", err)
+	}
+	return
+}
+
+// DescTrendCount desc trend count
+func (d *Dao) DescTrendCount(c context.Context, date string, query string) (count int, err error) {
+	row := d.db.QueryRow(c, fmt.Sprintf(_trendDescCountSQL, date, query))
+	if err = row.Scan(&count); err != nil {
+		log.Error("d.db.Query error(%v)", err)
+	}
+	return
+}
+
+// GetTrendAsc get asc trend
+func (d *Dao) GetTrendAsc(c context.Context, ctype string, date string, query string) (ts []*model.Trend, err error) {
+	rows, err := d.db.Query(c, fmt.Sprintf(_trendAscSQL, ctype, date, query))
+	if err != nil {
+		return
+	}
+	ts = make([]*model.Trend, 0)
+	defer rows.Close()
+	for rows.Next() {
+		t := &model.Trend{}
+		err = rows.Scan(&t.MID, &t.MagneticScore, &t.CreativityScore, &t.InfluenceScore, &t.CreditScore, &t.DValue)
+		if err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		ts = append(ts, t)
+	}
+	return
+}
+
+// GetTrendDesc get desc trend
+func (d *Dao) GetTrendDesc(c context.Context, ctype string, date string, query string) (ts []*model.Trend, err error) {
+	rows, err := d.db.Query(c, fmt.Sprintf(_trendDescSQL, ctype, date, query))
+	if err != nil {
+		return
+	}
+	ts = make([]*model.Trend, 0)
+	defer rows.Close()
+	for rows.Next() {
+		t := &model.Trend{}
+		err = rows.Scan(&t.MID, &t.MagneticScore, &t.CreativityScore, &t.InfluenceScore, &t.CreditScore, &t.DValue)
+		if err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		ts = append(ts, t)
+	}
+	return
+}

app/admin/main/up-rating/dao/statistics_test.go

@@ -0,0 +1,101 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoAscTrendCount(t *testing.T) {
+	convey.Convey("AscTrendCount", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			date  = "2018-06-01"
+			query = ""
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.db.Exec(c, "INSERT INTO up_rating_trend_asc(mid) VALUES(1001) ON DUPLICATE KEY UPDATE mid=VALUES(mid)")
+			count, err := d.AscTrendCount(c, date, query)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(count, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDescTrendCount(t *testing.T) {
+	convey.Convey("DescTrendCount", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			date  = "2018-06-01"
+			query = ""
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.db.Exec(c, "INSERT INTO up_rating_trend_desc(mid) VALUES(1001) ON DUPLICATE KEY UPDATE mid=VALUES(mid)")
+			count, err := d.DescTrendCount(c, date, query)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(count, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGetRatingStatis(t *testing.T) {
+	convey.Convey("GetRatingStatis", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			ctype = int64(0)
+			date  = "2018-06-01"
+			query = "2"
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.db.Exec(c, "INSERT INTO up_rating_statistics(cdate,tag_id,ctype,section) VALUES('2018-06-01',2,2,1) ON DUPLICATE KEY UPDATE tag_id=VALUES(tag_id)")
+			statis, err := d.GetRatingStatis(c, ctype, date, query)
+			ctx.Convey("Then err should be nil.statis should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(statis, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGetTrendAsc(t *testing.T) {
+	convey.Convey("GetTrendAsc", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			ctype = "magnetic"
+			date  = "2018-06-01"
+			query = ""
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.db.Exec(c, "INSERT INTO up_rating_trend_asc(mid,date) VALUES(1001,'2018-06-01') ON DUPLICATE KEY UPDATE mid=VALUES(mid)")
+			ts, err := d.GetTrendAsc(c, ctype, date, query)
+			ctx.Convey("Then err should be nil.ts should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ts, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGetTrendDesc(t *testing.T) {
+	convey.Convey("GetTrendDesc", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			ctype = "magnetic"
+			date  = "2018-06-01"
+			query = ""
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			d.db.Exec(c, "INSERT INTO up_rating_trend_desc(mid,date) VALUES(1001,'2018-06-01') ON DUPLICATE KEY UPDATE mid=VALUES(mid)")
+			ts, err := d.GetTrendDesc(c, ctype, date, query)
+			ctx.Convey("Then err should be nil.ts should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ts, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}