Create & Init Project...

app/interface/main/creative/dao/data/BUILD

@@ -0,0 +1,85 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "archive.go",
+        "archive_play.go",
+        "article.go",
+        "dao.go",
+        "fan.go",
+        "memcache.go",
+        "overview.go",
+        "overview_mc.go",
+        "table.go",
+    ],
+    importpath = "go-common/app/interface/main/creative/dao/data",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/up/util/hbaseutil:go_default_library",
+        "//app/interface/main/creative/conf:go_default_library",
+        "//app/interface/main/creative/model/data:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/hbase.v2:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/tsuna/gohbase/hrpc:go_default_library",
+        "@org_golang_x_net//context: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 = [
+        "api_test.go",
+        "archive_play_test.go",
+        "archive_test.go",
+        "article_test.go",
+        "dao_test.go",
+        "fan_test.go",
+        "memcache_test.go",
+        "overview_mc_test.go",
+        "overview_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/creative/conf:go_default_library",
+        "//app/interface/main/creative/model/data:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/hbase.v2:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/bouk/monkey:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+        "//vendor/github.com/tsuna/gohbase/hrpc:go_default_library",
+        "//vendor/gopkg.in/h2non/gock.v1:go_default_library",
+    ],
+)

app/interface/main/creative/dao/data/api.go

@@ -0,0 +1,93 @@
+package data
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"go-common/app/interface/main/creative/model/data"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_statURL  = "/data/member/upinfo/%d.json"
+	_tagv2URL = "/tag_predict/v2"
+	_coverURL = "/cover_recomm"
+)
+
+// Stat get user stat play/fans/...
+func (d *Dao) stat(c context.Context, mid int64, ip string) (st *data.Stat, err error) {
+	var res struct {
+		Code int `json:"code"`
+		*data.Stat
+	}
+	if err = d.client.RESTfulGet(c, d.statURI, ip, url.Values{}, &res, mid); err != nil {
+		log.Error("statURI url(%s) mid(%d) error(%v)", d.statURI, mid, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if res.Code != 0 {
+		log.Error("data url(%s) res(%v)", d.statURI, res)
+		err = ecode.CreativeDataErr
+		return
+	}
+	st = res.Stat
+	return
+}
+
+// TagsWithChecked get predict tag with checked mark.
+func (d *Dao) TagsWithChecked(c context.Context, mid int64, tid uint16, title, filename, desc, cover string, tagFrom int8) (t []*data.CheckedTag, err error) {
+	params := url.Values{}
+	t = make([]*data.CheckedTag, 0)
+	params.Set("client_type", strconv.Itoa(int(tagFrom)))
+	params.Set("typeid", strconv.Itoa(int(tid)))
+	params.Set("title", title)
+	params.Set("filename", filename)
+	params.Set("desc", desc)
+	params.Set("cover", cover)
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	var res struct {
+		Code int `json:"code"`
+		Data struct {
+			Tags []*data.CheckedTag `json:"tags"`
+		} `json:"data"`
+	}
+	log.Info("TagsWithChecked url(%s)", d.tagV2URI+"?"+params.Encode())
+	if err = d.client.Get(c, d.tagV2URI, "", params, &res); err != nil {
+		log.Error("data url(%s) error(%v)", d.tagV2URI+"?"+params.Encode(), err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if res.Code != 0 {
+		log.Error("data url(%s) res(%v)", d.tagV2URI+"?"+params.Encode(), res)
+		err = ecode.CreativeDataErr
+		return
+	}
+	t = res.Data.Tags
+	return
+}
+
+// RecommendCovers get recommend covers from AI.
+func (d *Dao) RecommendCovers(c context.Context, mid int64, fns []string) (cvs []string, err error) {
+	params := url.Values{}
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("filename", strings.Join(fns, ","))
+	var res struct {
+		Code int      `json:"code"`
+		Data []string `json:"data"`
+	}
+	if err = d.client.Get(c, d.coverBFSURI, "", params, &res); err != nil {
+		log.Error("Covers url(%s) error(%v)", d.coverBFSURI+"?"+params.Encode(), err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if res.Code != 0 {
+		log.Error("Covers url(%s) res(%v)", d.coverBFSURI+"?"+params.Encode(), res)
+		err = ecode.CreativeDataErr
+		return
+	}
+	cvs = res.Data
+	return
+}

app/interface/main/creative/dao/data/api_test.go

@@ -0,0 +1,89 @@
+package data
+
+import (
+	"context"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"net/url"
+	"reflect"
+	"testing"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+	gock "gopkg.in/h2non/gock.v1"
+)
+
+func TestDatastat(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		ip  = ""
+	)
+	convey.Convey("stat1", t, func(ctx convey.C) {
+		mock := monkey.PatchInstanceMethod(reflect.TypeOf(d.client), "RESTfulGet",
+			func(_ *bm.Client, _ context.Context, _ string, _ string, _ url.Values, _ interface{}, _ ...interface{}) (err error) {
+				return ecode.CreativeDataErr
+			})
+		defer mock.Unpatch()
+		_, err := d.stat(c, mid, ip)
+		ctx.Convey("Then err should be nil.st should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+
+}
+
+func TestDataTagsWithChecked(t *testing.T) {
+	var (
+		c        = context.TODO()
+		mid      = int64(1)
+		tid      = uint16(1)
+		title    = ""
+		filename = ""
+		desc     = ""
+		cover    = ""
+		tagFrom  = int8(0)
+		err      error
+	)
+	convey.Convey("TagsWithChecked1", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("GET", d.tagV2URI).Reply(200).JSON(`{"code":20003}`)
+		_, err = d.TagsWithChecked(c, mid, tid, title, filename, desc, cover, tagFrom)
+		ctx.Convey("Then err should be nil.no should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("TagsWithChecked2", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("GET", d.tagV2URI).Reply(200).JSON(`{"code":0,"data":{"tags":[{"tag":"1","checked":1}]}}`)
+		_, err = d.TagsWithChecked(c, mid, tid, title, filename, desc, cover, tagFrom)
+		ctx.Convey("Then err should be nil.no should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataRecommendCovers(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		fns = []string{}
+		err error
+	)
+	convey.Convey("RecommendCovers1", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("GET", d.coverBFSURI).Reply(200).JSON(`{"code":20003}`)
+		_, err = d.RecommendCovers(c, mid, fns)
+		ctx.Convey("Then err should be nil.cvs should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("RecommendCovers2", t, func(ctx convey.C) {
+		defer gock.OffAll()
+		httpMock("GET", d.coverBFSURI).Reply(200).JSON(`{"code":0,"data":["bfs1"]}`)
+		_, err = d.RecommendCovers(c, mid, fns)
+		ctx.Convey("Then err should be nil.no should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/data/archive.go

@@ -0,0 +1,272 @@
+package data
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/hex"
+	"sort"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/creative/model/data"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/tsuna/gohbase/hrpc"
+
+	"golang.org/x/net/context"
+)
+
+func hbaseMd5Key(aid int64) string {
+	hasher := md5.New()
+	hasher.Write([]byte(strconv.Itoa(int(aid))))
+	return hex.EncodeToString(hasher.Sum(nil))
+}
+
+// VideoQuitPoints get video quit points.
+func (d *Dao) VideoQuitPoints(c context.Context, cid int64) (res []int64, err error) {
+	var (
+		ctx, cancel     = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName       = HBaseVideoTablePrefix + time.Now().AddDate(0, 0, -1).Add(-12*time.Hour).Format("20060102") // change table at 12:00am
+		backupTableName = HBaseVideoTablePrefix + time.Now().AddDate(0, 0, -2).Add(-12*time.Hour).Format("20060102") // change table at 12:00am
+		key             = hbaseMd5Key(cid)
+	)
+	defer cancel()
+	result, err := d.hbase.GetStr(ctx, tableName, key)
+	if err != nil {
+		if result, err = d.hbase.GetStr(ctx, backupTableName, key); err != nil {
+			log.Error("VideoQuitPoints d.hbase.GetStr backupTableName(%s)|cid(%d)|key(%v)|error(%v)", backupTableName, cid, key, err)
+			err = ecode.CreativeDataErr
+			return
+		}
+	}
+	if result == nil {
+		return
+	}
+	// get parts and max part for fill res
+	partMap := make(map[int]int64)
+	maxPart := 0
+	for _, c := range result.Cells {
+		if c != nil {
+			part, _ := strconv.Atoi(string(c.Qualifier[:]))
+			per, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+			partMap[part] = per
+			if part > maxPart {
+				maxPart = part
+			}
+		}
+	}
+	var restPercent int64 = 10000 // start from 100%
+	for i := 1; i <= maxPart; i++ {
+		if _, ok := partMap[i]; ok {
+			restPercent = restPercent - partMap[i]
+		}
+		res = append(res, restPercent)
+	}
+	return
+}
+
+// ArchiveStat get the stat of archive.
+func (d *Dao) ArchiveStat(c context.Context, aid int64) (stat *data.ArchiveData, err error) {
+	var (
+		ctx, cancel     = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName       = HBaseArchiveTablePrefix + time.Now().AddDate(0, 0, -1).Add(-12*time.Hour).Format("20060102") // change table at 12:00am
+		backupTableName = HBaseArchiveTablePrefix + time.Now().AddDate(0, 0, -2).Add(-12*time.Hour).Format("20060102") // change table at 12:00am
+		key             = hbaseMd5Key(aid)
+	)
+	defer cancel()
+	result, err := d.hbase.GetStr(ctx, tableName, key)
+	if err != nil {
+		if result, err = d.hbase.GetStr(ctx, backupTableName, key); err != nil {
+			log.Error("ArchiveStat d.hbase.GetStr backupTableName(%s)|aid(%d)|key(%v)|error(%v)", backupTableName, aid, key, err)
+			err = ecode.CreativeDataErr
+			return
+		}
+	}
+	if result == nil {
+		return
+	}
+	stat = &data.ArchiveData{}
+	stat.ArchiveSource = &data.ArchiveSource{}
+	stat.ArchiveGroup = &data.ArchiveGroup{}
+	stat.ArchiveStat = &data.ArchiveStat{}
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+		if !bytes.Equal(c.Family, HBaseFamilyPlat) {
+			continue
+		}
+		switch {
+		case bytes.Equal(c.Qualifier, HBaseColumnWebPC):
+			stat.ArchiveSource.WebPC = v
+		case bytes.Equal(c.Qualifier, HBaseColumnWebH5):
+			stat.ArchiveSource.WebH5 = v
+		case bytes.Equal(c.Qualifier, HBaseColumnOutsite):
+			stat.ArchiveSource.Outsite = v
+		case bytes.Equal(c.Qualifier, HBaseColumnIOS):
+			stat.ArchiveSource.IOS = v
+		case bytes.Equal(c.Qualifier, HBaseColumnAndroid):
+			stat.ArchiveSource.Android = v
+		case bytes.Equal(c.Qualifier, HBaseColumnElse):
+			stat.ArchiveSource.Others = v
+		case bytes.Equal(c.Qualifier, HBaseColumnFans):
+			stat.ArchiveGroup.Fans = v
+		case bytes.Equal(c.Qualifier, HBaseColumnGuest):
+			stat.ArchiveGroup.Guest = v
+		case bytes.Equal(c.Qualifier, HBaseColumnAll):
+			stat.ArchiveStat.Play = v
+		case bytes.Equal(c.Qualifier, HBaseColumnCoin):
+			stat.ArchiveStat.Coin = v
+		case bytes.Equal(c.Qualifier, HBaseColumnElec):
+			stat.ArchiveStat.Elec = v
+		case bytes.Equal(c.Qualifier, HBaseColumnFav):
+			stat.ArchiveStat.Fav = v
+		case bytes.Equal(c.Qualifier, HBaseColumnShare):
+			stat.ArchiveStat.Share = v
+			//【稿件分析】增加：播放、弹幕、评论、点赞 v:play v:danmu v:reply v:likes
+		case bytes.Equal(c.Qualifier, []byte("play")):
+			stat.ArchiveStat.Play = v
+		case bytes.Equal(c.Qualifier, []byte("danmu")):
+			stat.ArchiveStat.Dm = v
+		case bytes.Equal(c.Qualifier, []byte("reply")):
+			stat.ArchiveStat.Reply = v
+		case bytes.Equal(c.Qualifier, []byte("likes")):
+			stat.ArchiveStat.Like = v
+		}
+	}
+	stat.ArchiveSource.Mainsite = stat.ArchiveSource.WebPC + stat.ArchiveSource.WebH5
+	stat.ArchiveSource.Mobile = stat.ArchiveSource.Android + stat.ArchiveSource.IOS
+	return
+}
+
+// ArchiveArea get the count of area.
+func (d *Dao) ArchiveArea(c context.Context, aid int64) (res []*data.ArchiveArea, err error) {
+	var (
+		ctx, cancel     = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName       = HBaseAreaTablePrefix + time.Now().AddDate(0, 0, -1).Add(-12*time.Hour).Format("20060102") // change table at 12:00am
+		backupTableName = HBaseAreaTablePrefix + time.Now().AddDate(0, 0, -2).Add(-12*time.Hour).Format("20060102") // change table at 12:00am
+		key             = hbaseMd5Key(aid)
+	)
+	defer cancel()
+	result, err := d.hbase.GetStr(ctx, tableName, key)
+	if err != nil {
+		if result, err = d.hbase.GetStr(ctx, backupTableName, key); err != nil {
+			log.Error("ArchiveArea d.hbase.GetStr backupTableName(%s)|aid(%d)|key(%v)|error(%v)", backupTableName, aid, key, err)
+			err = ecode.CreativeDataErr
+			return
+		}
+	}
+	if result == nil {
+		return
+	}
+	var countArr []int
+	countMap := make(map[int64][]*data.ArchiveArea)
+	countSet := make(map[int]struct{}) // empty struct{} for saving memory
+	for _, c := range result.Cells {
+		if c != nil {
+			area := &data.ArchiveArea{}
+			area.Location = string(c.Qualifier[:])
+			area.Count, _ = strconv.ParseInt(string(c.Value[:]), 10, 64)
+			countMap[area.Count] = append(countMap[area.Count], area)
+			countSet[int(area.Count)] = struct{}{}
+		}
+	}
+	for key := range countSet {
+		countArr = append(countArr, key)
+	}
+	sort.Sort(sort.Reverse(sort.IntSlice(countArr)))
+	for _, c := range countArr {
+		if _, ok := countMap[int64(c)]; ok {
+			res = append(res, countMap[int64(c)]...)
+		}
+		if len(res) >= 10 {
+			res = res[:10] // exact 10 item
+			break
+		}
+	}
+	return
+}
+
+// BaseUpStat get base up stat.
+func (d *Dao) BaseUpStat(c context.Context, mid int64, date string) (stat *data.UpBaseStat, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, d.hbaseTimeOut)
+		tableName   = HBaseUpStatTablePrefix + date // change table at 12:00am
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("BaseUpStat d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil {
+		return
+	}
+	stat = &data.UpBaseStat{}
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+		if !bytes.Equal(c.Family, []byte("u")) {
+			continue
+		}
+		switch {
+		case bytes.Equal(c.Qualifier, []byte("play")):
+			stat.View = v
+		case bytes.Equal(c.Qualifier, []byte("dm")):
+			stat.Dm = v
+		case bytes.Equal(c.Qualifier, []byte("reply")):
+			stat.Reply = v
+		case bytes.Equal(c.Qualifier, []byte("fans")):
+			stat.Fans = v
+		case bytes.Equal(c.Qualifier, []byte("fav")):
+			stat.Fav = v
+		case bytes.Equal(c.Qualifier, []byte("like")):
+			stat.Like = v
+		case bytes.Equal(c.Qualifier, []byte("sh")):
+			stat.Share = v
+		case bytes.Equal(c.Qualifier, []byte("elec")): //【视频数据总览】增加：硬币、充电
+			stat.Elec = v
+		case bytes.Equal(c.Qualifier, []byte("coin")):
+			stat.Coin = v
+		}
+	}
+	log.Info("BaseUpStat d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|stat(%+v)", tableName, mid, key, stat)
+	return
+}
+
+// UpArchiveStatQuery 获取最高播放/评论/弹幕/...数
+func (d *Dao) UpArchiveStatQuery(c context.Context, mid int64, date string) (res *data.ArchiveMaxStat, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseupArchiveStatQuery + date // change table at 12:00am
+		rowkey      = hbaseMd5Key(mid)
+	)
+	defer cancel()
+	log.Info("UpArchiveStatQuery aid(%d)|rowkey(%s)", mid, rowkey)
+	if result, err = d.hbase.GetStr(ctx, tableName, rowkey); err != nil {
+		log.Error("UpArchiveStatQuery d.hbase.GetStr tableName(%s)|mid(%d)|rowkey(%+v)|error(%v)", tableName, mid, rowkey, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("UpArchiveStatQuery no data tableName(%s)|mid(%d)|rowkey(%+v)", tableName, mid, rowkey)
+		return
+	}
+	var cells data.ArchiveMaxStat
+	err = parser.Parse(result.Cells, &cells)
+	if err != nil {
+		log.Error("UpArchiveStatQuery parser.Parse tableName(%s)|mid(%d)|rowkey(%+v)|error(%v)", tableName, mid, rowkey, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	res = &cells
+	log.Info("UpArchiveStatQuery mid(%d)|rowkey(%s)|res(%+v)", mid, rowkey, *res)
+	return
+}

app/interface/main/creative/dao/data/archive_play.go

@@ -0,0 +1,273 @@
+package data
+
+import (
+	"context"
+	"encoding/binary"
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/up/util/hbaseutil"
+	"go-common/app/interface/main/creative/model/data"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/tsuna/gohbase/hrpc"
+)
+
+var (
+	//播放端占比
+	playProportion = map[string]string{
+		"pc":  "pc",      //pc端播放占比*10000
+		"h5":  "h5",      //h5端播放占比*10000
+		"out": "out",     //站外播放占比*10000
+		"adr": "android", //android端播放占比*10000
+		"ios": "ios",     //ios端播放占比*10000
+	}
+	//播放来源页面占比
+	pageSource = map[string]string{
+		"pv0":  "other",         //其他
+		"pv1":  "tenma",         //天马推荐
+		"pv2":  "related_video", //相关视频
+		"pv3":  "search",        //搜索
+		"pv4":  "h5",            //H5页面
+		"pv5":  "space",         //空间
+		"pv6":  "dynamic",       //动态
+		"pv7":  "history",       //播放历史
+		"pv8":  "tag",           //标签
+		"pv9":  "cache",         //离线缓存
+		"pv10": "rank",          //排行榜
+		"pv11": "type",          //分区
+	}
+	//粉丝来源页面占比
+	fanSource = map[string]string{
+		"pf0": "other",      //其他
+		"pf1": "space",      //主站空间
+		"pf2": "main",       //主站播放页
+		"pf3": "main_other", //主站其他
+		"pf4": "live",       //直播
+		"pf5": "audio",      //	音乐
+		"pf6": "article",    //	文章
+	}
+	parser = hbaseutil.Parser{}
+)
+
+func sourceOtherMerge(v string) bool { //合并这些页面来源为其他
+	if v == "other" || v == "h5" || v == "history" || v == "cache" ||
+		v == "rank" || v == "type" || v == "tag" {
+		return true
+	}
+	return false
+}
+
+// reverse for string.
+func reverseString(s string) string {
+	rs := []rune(s)
+	l := len(rs)
+	for f, t := 0, l-1; f < t; f, t = f+1, t-1 {
+		rs[f], rs[t] = rs[t], rs[f]
+	}
+	ns := string(rs)
+	if l < 10 {
+		for i := 0; i < 10-l; i++ {
+			ns = ns + "0"
+		}
+	}
+	return ns
+}
+
+// 播放来源 - up_play_analysis
+// mid倒置补（10位）+ yyyyMMdd
+func playSourceKey(id int64) string {
+	idStr := strconv.FormatInt(id, 10)
+	s := reverseString(idStr)
+	s = s + time.Now().AddDate(0, 0, -1).Add(-12*time.Hour).Format("20060102")
+	return s
+}
+
+// 平均观看时长、播放用户数、留存率 - up_archive_play_analysis
+// avid倒置补（10位）+ yyyyMMdd
+func arcPlayKey(id int64) string {
+	idStr := strconv.FormatInt(id, 10)
+	s := reverseString(idStr)
+	s = s + time.Now().AddDate(0, 0, -1).Add(-12*time.Hour).Format("20060102")
+	return s
+}
+
+// 稿件索引表 - up_archive_query
+// [mid倒置补0（10位）] + [投稿年月（4位）] + [原创/转载（1位）]
+func arcQueryKey(id int64, dt string, cp int) string {
+	idStr := strconv.FormatInt(id, 10)
+	cpStr := strconv.Itoa(cp)
+	s := reverseString(idStr)
+	s = s + dt + cpStr
+	return s
+}
+
+// UpPlaySourceAnalysis for play analysis.
+func (d *Dao) UpPlaySourceAnalysis(c context.Context, mid int64) (res *data.PlaySource, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpPlaySourceAnalysis
+		rowkey      = playSourceKey(mid)
+	)
+	defer cancel()
+	log.Info("UpPlaySourceAnalysis mid(%d)|rowkey(%s)", mid, rowkey)
+	if result, err = d.hbase.GetStr(ctx, tableName, rowkey); err != nil {
+		log.Error("d.hbase.GetStr tableName(%s)|mid(%d)|rowkey(%s)|error(%v)", tableName, mid, rowkey, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("UpPlaySourceAnalysis no data tableName(%s)|mid(%d)|rowkey(%s)", tableName, mid, rowkey)
+		return
+	}
+	pp := make(map[string]int32)
+	ps := make(map[string]int32)
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if string(c.Family) == "s" {
+			var v int32
+			if len(c.Value) == 4 {
+				v = int32(binary.BigEndian.Uint32(c.Value))
+			} else {
+				log.Error("UpPlaySourceAnalysis family[s] get dirty value  tableName(%s)|mid(%d)|rowkey(%s)", tableName, mid, rowkey)
+			}
+			if pyk, ok := playProportion[string(c.Qualifier[:])]; ok {
+				pp[pyk] = v
+			}
+			if pk, ok := pageSource[string(c.Qualifier[:])]; ok {
+				ps[pk] = v
+			}
+		}
+	}
+	for _, k := range playProportion { //播放平台设置数据平台未返回的key
+		if _, ok := pp[k]; !ok {
+			pp[k] = 0
+		}
+	}
+	for _, k := range pageSource { //播放页面设置数据平台未返回的key
+		if _, ok := ps[k]; !ok {
+			ps[k] = 0
+		}
+	}
+	var other int32
+	for k, v := range ps {
+		if sourceOtherMerge(k) { //如果该页面来源被计算入其他则删除该页面来源对应的key
+			other = other + v
+			delete(ps, k)
+		}
+	}
+	ps["other"] = other
+	res = &data.PlaySource{
+		PlayProportion: pp,
+		PageSource:     ps,
+	}
+	log.Info("UpPlaySourceAnalysis PlayProportion(%+v)|PageSource(%+v)|rowkey(%s)", pp, ps, rowkey)
+	return
+}
+
+// UpArcPlayAnalysis for  arc play analysis.
+func (d *Dao) UpArcPlayAnalysis(c context.Context, aid int64) (res *data.ArchivePlay, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpArcPlayAnalysis
+		rowkey      = arcPlayKey(aid)
+	)
+	defer cancel()
+	log.Info("UpArcPlayAnalysis aid(%d)|rowkey(%s)", aid, rowkey)
+	if result, err = d.hbase.GetStr(ctx, tableName, rowkey); err != nil {
+		log.Error("d.hbase.GetStr tableName(%s)|aid(%d)|rowkey(%+v)|error(%v)", tableName, aid, rowkey, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("UpArcPlayAnalysis no data tableName(%s)|aid(%d)|rowkey(%+v)", tableName, aid, rowkey)
+		return
+	}
+	ap := &data.ArchivePlay{}
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if string(c.Family) == "v" {
+			ap.AID = aid
+			switch string(c.Qualifier[:]) {
+			case "ctime":
+				if len(c.Value) == 4 {
+					ap.CTime = int32(binary.BigEndian.Uint32(c.Value))
+				} else {
+					log.Error("UpArcPlayAnalysis family[ctime] get dirty value  tableName(%s)|aid(%d)|rowkey(%s)", tableName, aid, rowkey)
+				}
+			case "uv":
+				if len(c.Value) == 4 {
+					ap.View = int32(binary.BigEndian.Uint32(c.Value))
+				} else {
+					log.Error("UpArcPlayAnalysis family[uv] get dirty value  tableName(%s)|aid(%d)|rowkey(%s)", tableName, aid, rowkey)
+				}
+			case "dur":
+				if len(c.Value) == 8 {
+					ap.Duration = int64(binary.BigEndian.Uint64(c.Value))
+				} else {
+					log.Error("UpArcPlayAnalysis family[dur] get dirty value  tableName(%s)|aid(%d)|rowkey(%s)", tableName, aid, rowkey)
+				}
+			case "avg_dur":
+				if len(c.Value) == 8 {
+					ap.AvgDuration = int64(binary.BigEndian.Uint64(c.Value))
+				} else {
+					log.Error("UpArcPlayAnalysis family[avg_dur] get dirty value  tableName(%s)|aid(%d)|rowkey(%s)", tableName, aid, rowkey)
+				}
+			case "rate":
+				if len(c.Value) == 4 {
+					ap.Rate = int32(binary.BigEndian.Uint32(c.Value))
+				} else {
+					log.Error("UpArcPlayAnalysis family[rate] get dirty value  tableName(%s)|aid(%d)|rowkey(%s)", tableName, aid, rowkey)
+				}
+			}
+		}
+	}
+	res = ap
+	log.Info("UpArcPlayAnalysis aid(%d)|rowkey(%s)|res(%+v)", aid, rowkey, res)
+	return
+}
+
+// UpArcQuery for play aids by mid.
+func (d *Dao) UpArcQuery(c context.Context, mid int64, dt string, cp int) (res []int64, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpArcQuery
+		rowkey      = arcQueryKey(mid, dt, cp)
+	)
+	defer cancel()
+	log.Info("UpArcQuery mid(%d)|rowkey(%s)", mid, rowkey)
+	if result, err = d.hbase.GetStr(ctx, tableName, rowkey); err != nil {
+		log.Error("d.hbase.GetStr tableName(%s)|mid(%d)|rowkey(%s)|error(%v)", tableName, mid, rowkey, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("UpArcQuery no data tableName(%s)|mid(%d)|rowkey(%s)", tableName, mid, rowkey)
+		return
+	}
+	res = make([]int64, 0)
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if string(c.Family) == "av" {
+			var v int64
+			if len(c.Value) == 4 {
+				v = int64(binary.BigEndian.Uint32(c.Value))
+			} else {
+				log.Error("UpArcQuery family[av] get dirty value  tableName(%s)|rowkey(%s)", tableName, rowkey)
+			}
+			res = append(res, v)
+		}
+	}
+	log.Info("UpArcQuery mid(%d)|rowkey(%s)|res(%+v)", mid, rowkey, res)
+	return
+}

app/interface/main/creative/dao/data/archive_play_test.go

@@ -0,0 +1,249 @@
+package data
+
+import (
+	"context"
+	"encoding/binary"
+	"go-common/app/interface/main/creative/model/data"
+	"go-common/library/ecode"
+	"reflect"
+	"testing"
+
+	hbase "go-common/library/database/hbase.v2"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+	"github.com/tsuna/gohbase/hrpc"
+)
+
+func TestDatasourceOtherMerge(t *testing.T) {
+	var (
+		v = ""
+	)
+	convey.Convey("sourceOtherMerge", t, func(ctx convey.C) {
+		p1 := sourceOtherMerge(v)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDatareverseString(t *testing.T) {
+	var (
+		s = ""
+	)
+	convey.Convey("reverseString", t, func(ctx convey.C) {
+		p1 := reverseString(s)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDatafansRowKey(t *testing.T) {
+	var (
+		id = int64(0)
+		ty = int(0)
+	)
+	convey.Convey("fansRowKey", t, func(ctx convey.C) {
+		p1 := fansRowKey(id, ty)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDataplaySourceKey(t *testing.T) {
+	var (
+		id = int64(0)
+	)
+	convey.Convey("playSourceKey", t, func(ctx convey.C) {
+		p1 := playSourceKey(id)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDataarcPlayKey(t *testing.T) {
+	var (
+		id = int64(0)
+	)
+	convey.Convey("arcPlayKey", t, func(ctx convey.C) {
+		p1 := arcPlayKey(id)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDataarcQueryKey(t *testing.T) {
+	var (
+		id = int64(1)
+		dt = ""
+		cp = int(0)
+	)
+	convey.Convey("arcQueryKey", t, func(ctx convey.C) {
+		p1 := arcQueryKey(id, dt, cp)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldEqual, p1)
+		})
+	})
+}
+
+func TestDataupFansMedalRowKey(t *testing.T) {
+	var (
+		id = int64(1)
+		ty = int(1)
+	)
+	convey.Convey("upFansMedalRowKey", t, func(ctx convey.C) {
+		p1 := upFansMedalRowKey(id, ty)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldEqual, p1)
+		})
+	})
+}
+
+func TestDatabyteToInt32(t *testing.T) {
+	var (
+		b = []byte{255, 255, 255, 249}
+	)
+	convey.Convey("byteToInt32", t, func(ctx convey.C) {
+		p1 := byteToInt32(b)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldEqual, -7)
+		})
+	})
+}
+
+func TestDataUpFansAnalysisForWeb(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		ty  = int(0)
+		err error
+		res *data.WebFan
+	)
+	convey.Convey("1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		res, err = d.UpFansAnalysisForWeb(c, mid, ty)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldEqual, ecode.CreativeDataErr)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		res, err = d.UpFansAnalysisForWeb(c, mid, ty)
+		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.ShouldBeNil)
+		})
+	})
+	convey.Convey("3", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("f"),
+				Qualifier: []byte("all"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		res, err = d.UpFansAnalysisForWeb(c, mid, ty)
+		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)
+		})
+	})
+	convey.Convey("4", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("t"),
+				Qualifier: []byte("dr"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		res, err = d.UpFansAnalysisForWeb(c, mid, ty)
+		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 TestDataUpPlaySourceAnalysis(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+	)
+	convey.Convey("UpPlaySourceAnalysis", t, func(ctx convey.C) {
+		res, err := d.UpPlaySourceAnalysis(c, mid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldEqual, ecode.CreativeDataErr)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataUpArcPlayAnalysis(t *testing.T) {
+	var (
+		c   = context.TODO()
+		aid = int64(0)
+	)
+	convey.Convey("UpArcPlayAnalysis", t, func(ctx convey.C) {
+		res, err := d.UpArcPlayAnalysis(c, aid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldEqual, ecode.CreativeDataErr)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataUpArcQuery(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		dt  = ""
+		cp  = int(0)
+	)
+	convey.Convey("UpArcQuery", t, func(ctx convey.C) {
+		res, err := d.UpArcQuery(c, mid, dt, cp)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldEqual, ecode.CreativeDataErr)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataUpFansMedal(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+	)
+	convey.Convey("UpFansMedal", t, func(ctx convey.C) {
+		res, err := d.UpFansMedal(c, mid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldEqual, ecode.CreativeDataErr)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/data/archive_test.go

@@ -0,0 +1,227 @@
+package data
+
+import (
+	"context"
+	"go-common/library/ecode"
+	"reflect"
+	"testing"
+
+	hbase "go-common/library/database/hbase.v2"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+	"github.com/tsuna/gohbase/hrpc"
+)
+
+func TestDatahbaseMd5Key(t *testing.T) {
+	var (
+		aid = int64(0)
+	)
+	convey.Convey("hbaseMd5Key", t, func(ctx convey.C) {
+		p1 := hbaseMd5Key(aid)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDataVideoQuitPoints(t *testing.T) {
+	var (
+		c   = context.TODO()
+		cid = int64(1)
+	)
+	convey.Convey("VideoQuitPoints1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    HBaseFamilyPlat,
+				Qualifier: HBaseColumnShare,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err := d.VideoQuitPoints(c, cid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("VideoQuitPoints2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err := d.VideoQuitPoints(c, cid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDataArchiveStat(t *testing.T) {
+	var (
+		c   = context.TODO()
+		aid = int64(1)
+		err error
+	)
+	convey.Convey("1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err = d.ArchiveStat(c, aid)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldEqual, ecode.CreativeDataErr)
+		})
+	})
+	convey.Convey("2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ArchiveStat(c, aid)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("3", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ArchiveStat(c, aid)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("4", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    HBaseFamilyPlat,
+				Qualifier: HBaseColumnWebPC,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ArchiveStat(c, aid)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("5", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    HBaseFamilyPlat,
+				Qualifier: HBaseColumnWebH5,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ArchiveStat(c, aid)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("6", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    HBaseFamilyPlat,
+				Qualifier: HBaseColumnShare,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ArchiveStat(c, aid)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataArchiveArea(t *testing.T) {
+	var (
+		c   = context.TODO()
+		aid = int64(1)
+	)
+	convey.Convey("ArchiveArea1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err := d.ArchiveArea(c, aid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldEqual, ecode.CreativeDataErr)
+		})
+	})
+	convey.Convey("ArchiveArea2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    HBaseFamilyPlat,
+				Qualifier: HBaseColumnShare,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err := d.ArchiveArea(c, aid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataBaseUpStat(t *testing.T) {
+	var (
+		c    = context.TODO()
+		mid  = int64(0)
+		date = ""
+	)
+	convey.Convey("BaseUpStat", t, func(ctx convey.C) {
+		_, err := d.BaseUpStat(c, mid, date)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldEqual, ecode.CreativeDataErr)
+		})
+	})
+}
+
+func TestDataUpArchiveStatQuery(t *testing.T) {
+	var (
+		c    = context.TODO()
+		mid  = int64(1)
+		date = ""
+	)
+	convey.Convey("UpArchiveStatQuery1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err := d.UpArchiveStatQuery(c, mid, date)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("UpArchiveStatQuery2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err := d.UpArchiveStatQuery(c, mid, date)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/data/article.go

@@ -0,0 +1,172 @@
+package data
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/creative/model/data"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/tsuna/gohbase/hrpc"
+)
+
+var (
+	trendTBLNameMap = map[byte]string{
+		data.ArtView:    ArtViewTBL,
+		data.ArtReply:   ArtReplyTBL,
+		data.ArtShare:   ArtShareTBL,
+		data.ArtCoin:    ArtCoinTBL,
+		data.ArtFavTBL:  ArtFavTBL,
+		data.ArtLikeTBL: ArtLikeTBL,
+	}
+
+	rankTBLNameMap = map[byte]string{
+		data.ArtView:    ArtViewIncTBL,
+		data.ArtReply:   ArtReplyIncTBL,
+		data.ArtShare:   ArtShareIncTBL,
+		data.ArtCoin:    ArtCoinIncTBL,
+		data.ArtFavTBL:  ArtFavIncTBL,
+		data.ArtLikeTBL: ArtLikeIncTBL,
+	}
+)
+
+// ArtThirtyDay for article trend 30 days.
+func (d *Dao) ArtThirtyDay(c context.Context, mid int64, ty byte) (res []*data.ArtTrend, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+
+	tableName, ok := trendTBLNameMap[ty]
+	if !ok {
+		log.Error("ArtThirtyDay not exist type(%d)|mid(%d)", ty, mid)
+		return
+	}
+
+	log.Info("ArtThirtyDay mid(%d)|tableName(%s)|family(u)|rowkey(%s)", mid, tableName, key)
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("ArtThirtyDay d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("ArtThirtyDay no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+
+	res = make([]*data.ArtTrend, 0, len(result.Cells))
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		qual := string(c.Qualifier[:])
+		val := string(c.Value[:])
+		if string(c.Family) == "u" {
+			t, v, err := parseKeyValue(qual, val)
+			if err != nil {
+				break
+			}
+			td := &data.ArtTrend{}
+			td.DateKey = t
+			td.TotalIncr = v
+			res = append(res, td)
+		}
+	}
+	log.Info("ArtThirtyDay mid(%d)|tableName(%s)|family(u)|rowkey(%s)|res(%+v)", mid, tableName, key, res)
+	return
+}
+
+// ArtRank for article rank
+func (d *Dao) ArtRank(c context.Context, mid int64, ty byte, date string) (res *data.ArtRankMap, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+
+	tableName, ok := rankTBLNameMap[ty]
+	if !ok {
+		log.Error("ArtRank not exist type(%d)|mid(%d)", ty, mid)
+		return
+	}
+	tableName += date
+
+	log.Info("ArtRank mid(%d)|tableName(%s)|family(rd,v)|rowkey(%s)", mid, tableName, key)
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("ArtRank d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("ArtRank no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+
+	aids := make(map[int]int64)
+	incrs := make(map[int]int)
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if string(c.Family) == "rd" {
+			k, _ := strconv.Atoi(string(c.Qualifier[:]))
+			v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+			aids[k] = v
+		} else if string(c.Family) == "v" {
+			k, _ := strconv.Atoi(string(c.Qualifier[:]))
+			v, _ := strconv.Atoi(string(c.Value[:]))
+			incrs[k] = v
+		}
+	}
+	res = &data.ArtRankMap{}
+	res.AIDs = aids
+	res.Incrs = incrs
+	log.Info("ArtRank mid(%d)|tableName(%s)|family(rd,v)|rowkey(%s)|res(%+v)", mid, tableName, key, res)
+	return
+}
+
+// 专栏阅读来源分析 rowkey mid倒置补（10位）+ yyyyMMdd
+func readSourceKey(id int64) string {
+	idStr := strconv.FormatInt(id, 10)
+	s := reverseString(idStr)
+	s = s + time.Now().AddDate(0, 0, -1).Add(-12*time.Hour).Format("20060102")
+	return s
+}
+
+// ReadAnalysis for article read source.
+func (d *Dao) ReadAnalysis(c context.Context, mid int64) (res *data.ArtRead, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = ArtReadAnalysisTBL
+		key         = readSourceKey(mid)
+	)
+	defer cancel()
+
+	log.Info("ReadAnalysis mid(%d)|tableName(%s)|family(f)|rowkey(%s)", mid, tableName, key)
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("ReadAnalysis d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("ReadAnalysis no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+
+	var cells data.ArtRead
+	err = parser.Parse(result.Cells, &cells)
+	if err != nil {
+		log.Error("ReadAnalysis parser.Parse tableName(%s)|mid(%d)|rowkey(%+v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	res = &cells
+	log.Info("ReadAnalysis mid(%d)|tableName(%s)|family(f)|rowkey(%s)|res(%+v)", mid, tableName, key, res)
+	return
+}

app/interface/main/creative/dao/data/article_test.go

@@ -0,0 +1,103 @@
+package data
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	"go-common/library/ecode"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+	"github.com/tsuna/gohbase/hrpc"
+	hbase "go-common/library/database/hbase.v2"
+)
+
+func TestArtThirtyDay(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(27515256)
+		tp  = byte(1)
+	)
+	convey.Convey("ArtThirtyDay1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err := d.ArtThirtyDay(c, mid, tp)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("ArtThirtyDay2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err := d.ArtThirtyDay(c, mid, tp)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestArtRank(t *testing.T) {
+	var (
+		c    = context.TODO()
+		mid  = int64(27515256)
+		tp   = byte(1)
+		date = ""
+	)
+	convey.Convey("TestArtRank1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err := d.ArtRank(c, mid, tp, date)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("TestArtRank2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err := d.ArtRank(c, mid, tp, date)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestReadAnalysis(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(27515256)
+	)
+
+	convey.Convey("TestReadAnalysis1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err := d.ReadAnalysis(c, mid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+
+	})
+	convey.Convey("TestReadAnalysis2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err := d.ReadAnalysis(c, mid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/data/dao.go

@@ -0,0 +1,132 @@
+package data
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/creative/conf"
+	"go-common/app/interface/main/creative/model/data"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+
+	"go-common/library/database/hbase.v2"
+)
+
+// Dao is data dao.
+type Dao struct {
+	c *conf.Config
+	// http
+	client     *bm.Client
+	statClient *bm.Client
+	// uri
+	statURI     string
+	tagV2URI    string
+	coverBFSURI string
+	// mc
+	mc          *memcache.Pool
+	mcExpire    int32
+	mcIdxExpire int32
+	statCacheOn bool
+	// hbase
+	hbase        *hbase.Client
+	hbaseTimeOut time.Duration
+	// chan
+	missch chan func()
+}
+
+// New init dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c: c,
+		// http
+		client:      bm.NewClient(c.HTTPClient.Slow),
+		statClient:  bm.NewClient(c.HTTPClient.Slow),
+		statURI:     c.Host.Data + _statURL,
+		tagV2URI:    c.Host.Tag + _tagv2URL,
+		coverBFSURI: c.Host.Coverrec + _coverURL,
+		// memcache
+		mc:          memcache.NewPool(c.Memcache.Data.Config),
+		mcExpire:    int32(time.Duration(c.Memcache.Data.DataExpire) / time.Second),
+		mcIdxExpire: int32(time.Duration(c.Memcache.Data.IndexExpire) / time.Second),
+		statCacheOn: c.StatCacheOn,
+		// hbase
+		hbase: hbase.NewClient(c.HBase.Config),
+		// chan
+		missch:       make(chan func(), 1024),
+		hbaseTimeOut: time.Duration(time.Millisecond * 200),
+	}
+	go d.cacheproc()
+	return
+}
+
+// Stat get user stat play/fans/...
+func (d *Dao) Stat(c context.Context, ip string, mid int64) (st *data.Stat, err error) {
+	// try cache
+	if st, _ = d.statCache(c, mid); st != nil {
+		return
+	}
+	// from api
+	if st, err = d.stat(c, mid, ip); st != nil {
+		d.AddCache(func() {
+			d.addStatCache(context.TODO(), mid, st)
+		})
+	}
+	return
+}
+
+// UpStat get up stat from hbase
+func (d *Dao) UpStat(c context.Context, mid int64, dt string) (st *data.UpBaseStat, err error) {
+	// try cache
+	if d.statCacheOn {
+		if st, _ = d.upBaseStatCache(c, mid, dt); st != nil {
+			log.Info("upBaseStatCache cache found mid(%d)", mid)
+			return
+		}
+	}
+	// from hbase
+	if st, err = d.BaseUpStat(c, mid, dt); st != nil {
+		d.AddCache(func() {
+			d.addUpBaseStatCache(context.TODO(), mid, dt, st)
+		})
+	}
+	return
+}
+
+// Ping ping success.
+func (d *Dao) Ping(c context.Context) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: "ping", Value: []byte("pong"), Expiration: 0}); err != nil {
+		log.Error("mc.ping.Store error(%v)", err)
+	}
+	return
+}
+
+// Close mc close
+func (d *Dao) Close() (err error) {
+	if d.mc != nil {
+		d.mc.Close()
+	}
+	if d.hbase != nil {
+		d.hbase.Close()
+	}
+	return
+}
+
+// AddCache add to chan for cache
+func (d *Dao) AddCache(f func()) {
+	select {
+	case d.missch <- f:
+	default:
+		log.Warn("cacheproc chan full")
+	}
+}
+
+// cacheproc is a routine for execute closure.
+func (d *Dao) cacheproc() {
+	for {
+		f := <-d.missch
+		f()
+	}
+}

app/interface/main/creative/dao/data/dao_test.go

@@ -0,0 +1,105 @@
+package data
+
+import (
+	"context"
+	"flag"
+	"go-common/app/interface/main/creative/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+	gock "gopkg.in/h2non/gock.v1"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.archive.creative")
+		flag.Set("conf_token", "96b6a6c10bb311e894c14a552f48fef8")
+		flag.Set("tree_id", "2305")
+		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/creative.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}
+
+func httpMock(method, url string) *gock.Request {
+	r := gock.New(url)
+	r.Method = strings.ToUpper(method)
+	d.client.SetTransport(gock.DefaultTransport)
+	d.statClient.SetTransport(gock.DefaultTransport)
+	return r
+}
+func TestStat(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		ip  = "127.0.0.1"
+		dt  = "iamdt"
+	)
+	convey.Convey("TestStat1", t, func(ctx convey.C) {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrNotFound)
+		})
+		defer connGuard.Unpatch()
+		_, err := d.Stat(c, ip, mid)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("TestStat2", t, func(ctx convey.C) {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrNotFound)
+		})
+		defer connGuard.Unpatch()
+		_, err := d.UpStat(c, mid, dt)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrNotFound)
+		})
+		defer connGuard.Unpatch()
+		err := d.Ping(c)
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("Close", t, func(ctx convey.C) {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Close", func(_ *memcache.Pool) error {
+			return nil
+		})
+		defer connGuard.Unpatch()
+		err := d.Close()
+		ctx.Convey("Then err should be nil.stat should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("AddCache", t, func(ctx convey.C) {
+		d.AddCache(func() {
+			log.Error("d.AddCache")
+		})
+	})
+}

app/interface/main/creative/dao/data/fan.go

@@ -0,0 +1,236 @@
+package data
+
+import (
+	"context"
+	"encoding/binary"
+
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/interface/main/creative/model/data"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/tsuna/gohbase/hrpc"
+)
+
+// 粉丝管理 - up_fans_analysis
+// mid倒置补0 （补满共10位）+0 +yyyyMMdd          – 累计数据
+// mid倒置补0 （补满共10位）+1 +yyyyMMdd          – 7日数据
+// mid倒置补0 （补满共10位）+2 +yyyyMMdd        – 30日数据
+// mid倒置补0 （补满共10位）+3 +yyyyMMdd        – 90日数据
+func fansRowKey(id int64, ty int) string {
+	idStr := strconv.FormatInt(id, 10)
+	s := reverseString(idStr)
+	s = s + strconv.Itoa(ty) + time.Now().AddDate(0, 0, -1).Add(-12*time.Hour).Format("20060102")
+	return s
+}
+
+// up主粉丝勋章 - up_fans_medal
+// mid倒置补0（补满共10位）+1 +yyyyMMdd
+func upFansMedalRowKey(id int64, ty int) string {
+	idStr := strconv.FormatInt(id, 10)
+	s := reverseString(idStr)
+	s = s + strconv.Itoa(ty) + time.Now().AddDate(0, 0, -1).Add(-12*time.Hour).Format("20060102")
+	return s
+}
+
+func byteToInt32(b []byte) int32 {
+	return int32(b[3]) | int32(b[2])<<8 | int32(b[1])<<16 | int32(b[0])<<24
+}
+
+// UpFansAnalysisForApp for  app fans analysis.
+func (d *Dao) UpFansAnalysisForApp(c context.Context, mid int64, ty int) (res *data.AppFan, err error) {
+	var (
+		result       *hrpc.Result
+		ctx, cancel  = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName    = HBaseUpFansAnalysis
+		rowkey       = fansRowKey(mid, ty)
+		summary      = make(map[string]int64)            //total & classify proportion
+		rankDr       = make(map[string]int32)            //播放时长 mid list
+		rankVideoAct = make(map[string]int32)            //视频互动 mid list
+		rankMap      = make(map[string]map[string]int32) //top 10 rank list
+	)
+	defer cancel()
+	log.Info("UpFansAnalysisForApp mid(%d)|rowkey(%s)", mid, rowkey)
+	if result, err = d.hbase.GetStr(ctx, tableName, rowkey); err != nil {
+		log.Error("d.hbase.GetStr tableName(%s)|mid(%d)|rowkey(%v)|error(%v)", tableName, mid, rowkey, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("UpFansAnalysisForApp no data tableName(%s)|mid(%d)|", tableName, mid)
+		return
+	}
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if string(c.Family) == "f" {
+			if len(c.Value) != 4 {
+				log.Error("UpFansAnalysisForApp family[f] get dirty value tableName(%s)|mid(%d)|rowkey(%s)|value(%+v)", tableName, mid, rowkey, c.Value)
+				continue
+			}
+			v := int64(byteToInt32(c.Value))
+			switch string(c.Qualifier[:]) {
+			case "all": //总粉丝
+				summary["total"] = v
+			case "inc": //新增粉丝
+				summary["inc"] = v
+			case "act": //活跃粉丝
+				summary["active"] = v
+			case "v":
+				summary["play"] = v
+			case "dm":
+				summary["dm"] = v
+			case "r":
+				summary["reply"] = v
+			case "c":
+				summary["coin"] = v
+			case "inter": //互动活跃度*10000
+				summary["inter"] = v
+			case "vv": //观看活跃度*10000
+				summary["vv"] = v
+			case "da": //弹幕粉丝占比*10000
+				summary["da"] = v
+			case "re": //评论粉丝占比*10000
+				summary["re"] = v
+			case "co": //投币粉丝占比*10000
+				summary["co"] = v
+			case "fv": //收藏粉丝占比*10000
+				summary["fv"] = v
+			case "sh": //分享粉丝占比*10000
+				summary["sh"] = v
+			case "lk": //点赞粉丝占比*10000
+				summary["lk"] = v
+			}
+			log.Info("UpFansAnalysisForApp family[f] value tableName(%s)|mid(%d)|rowkey(%s)|key(%s)|value(%+v|Uint32[%+v]|int32[%+v])", tableName, mid, rowkey, string(c.Qualifier[:]), c.Value, binary.BigEndian.Uint32(c.Value), v)
+		}
+		if string(c.Family) == "t" {
+			var v int32
+			if len(c.Value) == 4 {
+				v = int32(binary.BigEndian.Uint32(c.Value))
+			} else {
+				log.Error("UpFansAnalysisForApp family t get dirty tableName(%s)|mid(%d)|rowkey(%s)|value(%+v)", tableName, mid, fansRowKey(mid, ty), c.Value)
+			}
+			if strings.Contains(string(c.Qualifier[:]), "dr") {
+				rankDr[string(c.Qualifier[:])] = v
+			}
+			if strings.Contains(string(c.Qualifier[:]), "act") {
+				rankVideoAct[string(c.Qualifier[:])] = v
+			}
+		}
+	}
+	rankMap[data.PlayDuration] = rankDr
+	rankMap[data.VideoAct] = rankVideoAct
+	log.Info("UpFansAnalysisForApp mid(%d)|rowkey(%s)|summary(%+v)|rankMap(%+v)", mid, rowkey, summary, rankMap)
+	res = &data.AppFan{
+		Summary: summary,
+		RankMap: rankMap,
+	}
+	return
+}
+
+// UpFansAnalysisForWeb for web fans analysis.
+func (d *Dao) UpFansAnalysisForWeb(c context.Context, mid int64, ty int) (res *data.WebFan, err error) {
+	var (
+		result       *hrpc.Result
+		ctx, cancel  = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName    = HBaseUpFansAnalysis
+		summary      = make(map[string]int32)            //total & classify proportion
+		rankDr       = make(map[string]int32)            //播放时长 mid list
+		rankVideoAct = make(map[string]int32)            //视频互动 mid list
+		rankDyAct    = make(map[string]int32)            //动态互动 mid list
+		rankMap      = make(map[string]map[string]int32) //top 10 rank list
+		source       = make(map[string]int32)            //source  proportion
+		rowkey       = fansRowKey(mid, ty)
+	)
+	defer cancel()
+	log.Info("UpFansAnalysisForWeb mid(%d)|rowkey(%s)", mid, rowkey)
+	if result, err = d.hbase.GetStr(ctx, tableName, rowkey); err != nil {
+		log.Error("d.hbase.GetStr tableName(%s)|mid(%d)|rowkey(%v)|error(%v)", tableName, mid, rowkey, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("UpFansAnalysisForWeb no data tableName(%s)|mid(%d)|rowkey(%v)", tableName, mid, rowkey)
+		return
+	}
+	var cells data.FansAnalysis
+	err = parser.Parse(result.Cells, &cells)
+	for k, v := range cells.F {
+		if k == "all" { //总粉丝
+			summary["total"] = v
+		} else if k == "act" { //活跃粉丝
+			summary["active"] = v
+		} else if k == "mdl" { //领取勋章粉丝
+			summary["medal"] = v
+		} else {
+			summary[k] = v
+		}
+	}
+	for k, v := range cells.T {
+		if strings.Contains(k, "dr") {
+			rankDr[k] = v
+		} else if strings.Contains(k, "act") {
+			rankVideoAct[k] = v
+		} else if strings.Contains(k, "dy") {
+			rankDyAct[k] = v
+		}
+	}
+	for k, v := range cells.S {
+		if strings.Contains(k, "pf") {
+			if pk, ok := fanSource[k]; ok {
+				source[pk] = v
+			}
+		}
+	}
+	for _, k := range fanSource { //粉丝来源页面占比如果数据平台未返回,则设置对应的key
+		if _, ok := source[k]; !ok {
+			source[k] = 0
+		}
+	}
+	rankMap[data.PlayDuration] = rankDr
+	rankMap[data.VideoAct] = rankVideoAct
+	rankMap[data.DynamicAct] = rankDyAct
+	log.Info("UpFansAnalysisForWebRankMap mid(%d)|rowkey(%s)|summary(%+v)|rankMap(%+v)|source(%+v)", mid, rowkey, summary, rankMap, source)
+	res = &data.WebFan{
+		Summary: summary,
+		RankMap: rankMap,
+		Source:  source,
+	}
+	return
+}
+
+// UpFansMedal get 领取勋章数+佩戴勋章数.
+func (d *Dao) UpFansMedal(c context.Context, mid int64) (res *data.UpFansMedal, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpFansMedalQuery
+		rowkey      = upFansMedalRowKey(mid, 1)
+	)
+	defer cancel()
+	log.Info("UpFansMedal aid(%d)|rowkey(%s)", mid, rowkey)
+	if result, err = d.hbase.GetStr(ctx, tableName, rowkey); err != nil {
+		log.Error("d.hbase.GetStr tableName(%s)|mid(%d)|rowkey(%+v)|error(%v)", tableName, mid, rowkey, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("UpFansMedal no data tableName(%s)|mid(%d)|rowkey(%+v)", tableName, mid, rowkey)
+		return
+	}
+	var cells data.UpFansMedal
+	err = parser.Parse(result.Cells, &cells)
+	if err != nil {
+		log.Error("parser.Parse tableName(%s)|mid(%d)|rowkey(%+v)|error(%v)", tableName, mid, rowkey, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	res = &cells
+	log.Info("UpFansMedal mid(%d)|rowkey(%s)|res(%+v)", mid, rowkey, *res)
+	return
+}

app/interface/main/creative/dao/data/fan_test.go

@@ -0,0 +1,161 @@
+package data
+
+import (
+	"context"
+	"encoding/binary"
+	"go-common/app/interface/main/creative/model/data"
+	"go-common/library/ecode"
+	"reflect"
+	"testing"
+
+	hbase "go-common/library/database/hbase.v2"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+	"github.com/tsuna/gohbase/hrpc"
+)
+
+func TestDataUpFansAnalysisForApp(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		ty  = int(0)
+		err error
+		res *data.AppFan
+	)
+	convey.Convey("1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		res, err = d.UpFansAnalysisForApp(c, mid, ty)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldEqual, ecode.CreativeDataErr)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		res, err = d.UpFansAnalysisForApp(c, mid, ty)
+		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.ShouldBeNil)
+		})
+	})
+	convey.Convey("3", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("f"),
+				Qualifier: []byte("all"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		res, err = d.UpFansAnalysisForApp(c, mid, ty)
+		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)
+		})
+	})
+	convey.Convey("4", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("t"),
+				Qualifier: []byte("dr"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		res, err = d.UpFansAnalysisForApp(c, mid, ty)
+		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 TestDataViewerArea(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		dt  = "dt"
+		err error
+	)
+	convey.Convey("1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerArea(c, mid, dt)
+		ctx.Convey("1", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerArea(c, mid, dt)
+		ctx.Convey("2", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("3", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("f"),
+				Qualifier: []byte("male"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerArea(c, mid, dt)
+		ctx.Convey("3", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("4", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("g"),
+				Qualifier: []byte("male"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerArea(c, mid, dt)
+		ctx.Convey("4", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/data/memcache.go

@@ -0,0 +1,105 @@
+package data
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/creative/model/data"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_prefix       = "s_"
+	_upBasePrefix = "sup_"
+)
+
+func keyStat(mid int64) string {
+	return _prefix + strconv.FormatInt(mid, 10)
+}
+
+func keyUpStat(mid int64, date string) string {
+	return _upBasePrefix + date + strconv.FormatInt(mid, 10)
+}
+
+// statCache get stat cache.
+func (d *Dao) statCache(c context.Context, mid int64) (st *data.Stat, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	r, err = conn.Get(keyStat(mid))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Get2(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &st); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", r.Value, err)
+		st = nil
+	}
+	return
+}
+
+// addStatCache add stat cache.
+func (d *Dao) addStatCache(c context.Context, mid int64, st *data.Stat) (err error) {
+	var (
+		key = keyStat(mid)
+	)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: st, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}
+
+// upBaseStatCache get stat cache.
+func (d *Dao) upBaseStatCache(c context.Context, mid int64, dt string) (st *data.UpBaseStat, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	r, err = conn.Get(keyUpStat(mid, dt))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			log.Error("upBaseStatCache conn.Get2(%d) key not found", mid)
+			err = nil
+		} else {
+			log.Error("upBaseStatCache conn.Get2(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &st); err != nil {
+		log.Error("upBaseStatCache json.Unmarshal(%s) error(%v)", r.Value, err)
+		st = nil
+	}
+	return
+}
+
+// addUpBaseStatCache add stat cache.
+func (d *Dao) addUpBaseStatCache(c context.Context, mid int64, dt string, st *data.UpBaseStat) (err error) {
+	key := keyUpStat(mid, dt)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: st, Flags: memcache.FlagJSON, Expiration: d.mcIdxExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}
+
+// DelUpBaseStatCache fn
+func (d *Dao) DelUpBaseStatCache(c context.Context, mid int64, dt string) (err error) {
+	key := keyUpStat(mid, dt)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		log.Error("memcache.del(%v) error(%v)", key, err)
+	}
+	return
+}

app/interface/main/creative/dao/data/memcache_test.go

@@ -0,0 +1,104 @@
+package data
+
+import (
+	"context"
+	"go-common/app/interface/main/creative/model/data"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDatakeyStat(t *testing.T) {
+	var (
+		mid = int64(1)
+	)
+	convey.Convey("keyStat", t, func(ctx convey.C) {
+		p1 := keyStat(mid)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldEqual, "s_1")
+		})
+	})
+}
+
+func TestDatakeyUpStat(t *testing.T) {
+	var (
+		mid  = int64(1)
+		date = ""
+	)
+	convey.Convey("keyUpStat", t, func(ctx convey.C) {
+		p1 := keyUpStat(mid, date)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldEqual, "sup_1")
+		})
+	})
+}
+
+func TestDatastatCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("statCache", t, func(ctx convey.C) {
+		_, err := d.statCache(c, mid)
+		ctx.Convey("Then err should be nil.st should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataaddStatCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		st  = &data.Stat{}
+	)
+	convey.Convey("addStatCache", t, func(ctx convey.C) {
+		err := d.addStatCache(c, mid, st)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataupBaseStatCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+	)
+	convey.Convey("upBaseStatCache", t, func(ctx convey.C) {
+		_, err := d.upBaseStatCache(c, mid, dt)
+		ctx.Convey("Then err should be nil.st should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataaddUpBaseStatCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+		st  = &data.UpBaseStat{}
+	)
+	convey.Convey("addUpBaseStatCache", t, func(ctx convey.C) {
+		err := d.addUpBaseStatCache(c, mid, dt, st)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataDelUpBaseStatCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+	)
+	convey.Convey("DelUpBaseStatCache", t, func(ctx convey.C) {
+		err := d.DelUpBaseStatCache(c, mid, dt)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/data/overview.go

@@ -0,0 +1,603 @@
+package data
+
+import (
+	"bytes"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/creative/model/data"
+	"go-common/library/ecode"
+	"go-common/library/log"
+
+	"github.com/tsuna/gohbase/hrpc"
+	"golang.org/x/net/context"
+)
+
+// ViewerBase visitor data analysis.
+func (d *Dao) ViewerBase(c context.Context, mid int64, dt string) (res map[string]*data.ViewerBase, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpViewerBase + dt
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("ViewerBase d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("ViewerBase no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+
+	res = make(map[string]*data.ViewerBase)
+	families := make(map[string]string, 2)
+	families["f"] = ""
+	families["g"] = ""
+	fb := &data.ViewerBase{}
+	gb := &data.ViewerBase{}
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if _, ok := families[string(c.Family)]; ok {
+			if string(c.Family) == "f" {
+				v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+				switch {
+				case bytes.Equal(c.Qualifier, []byte("male")):
+					fb.Male = v
+				case bytes.Equal(c.Qualifier, []byte("female")):
+					fb.Female = v
+				case bytes.Equal(c.Qualifier, []byte("age1")):
+					fb.AgeOne = v
+				case bytes.Equal(c.Qualifier, []byte("age2")):
+					fb.AgeTwo = v
+				case bytes.Equal(c.Qualifier, []byte("age3")):
+					fb.AgeThree = v
+				case bytes.Equal(c.Qualifier, []byte("age4")):
+					fb.AgeFour = v
+				case bytes.Equal(c.Qualifier, []byte("plat0")):
+					fb.PlatPC = v
+				case bytes.Equal(c.Qualifier, []byte("plat1")):
+					fb.PlatH5 = v
+				case bytes.Equal(c.Qualifier, []byte("plat2")):
+					fb.PlatOut = v
+				case bytes.Equal(c.Qualifier, []byte("plat3")):
+					fb.PlatIOS = v
+				case bytes.Equal(c.Qualifier, []byte("plat4")):
+					fb.PlatAndroid = v
+				case bytes.Equal(c.Qualifier, []byte("else")):
+					fb.PlatOtherApp = v
+				}
+			} else if string(c.Family) == "g" {
+				v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+				switch {
+				case bytes.Equal(c.Qualifier, []byte("male")):
+					gb.Male = v
+				case bytes.Equal(c.Qualifier, []byte("female")):
+					gb.Female = v
+				case bytes.Equal(c.Qualifier, []byte("age1")):
+					gb.AgeOne = v
+				case bytes.Equal(c.Qualifier, []byte("age2")):
+					gb.AgeTwo = v
+				case bytes.Equal(c.Qualifier, []byte("age3")):
+					gb.AgeThree = v
+				case bytes.Equal(c.Qualifier, []byte("age4")):
+					gb.AgeFour = v
+				case bytes.Equal(c.Qualifier, []byte("plat0")):
+					gb.PlatPC = v
+				case bytes.Equal(c.Qualifier, []byte("plat1")):
+					gb.PlatH5 = v
+				case bytes.Equal(c.Qualifier, []byte("plat2")):
+					gb.PlatOut = v
+				case bytes.Equal(c.Qualifier, []byte("plat3")):
+					gb.PlatIOS = v
+				case bytes.Equal(c.Qualifier, []byte("plat4")):
+					gb.PlatAndroid = v
+				case bytes.Equal(c.Qualifier, []byte("else")):
+					gb.PlatOtherApp = v
+				}
+			}
+		}
+	}
+	res["fan"] = fb
+	res["not_fan"] = gb
+	return
+}
+
+// ViewerArea visitor area data analysis.
+func (d *Dao) ViewerArea(c context.Context, mid int64, dt string) (res map[string]map[string]int64, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpViewerArea + dt
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("ViewerArea d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("ViewerArea no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+	res = make(map[string]map[string]int64)
+	fa := make(map[string]int64)
+	ga := make(map[string]int64)
+	families := make(map[string]string, 2)
+	families["f"] = ""
+	families["g"] = ""
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if _, ok := families[string(c.Family)]; ok {
+			a := string(c.Qualifier[:])
+			if string(c.Family) == "f" {
+				v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+				fa[a] = v
+			} else if string(c.Family) == "g" {
+				v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+				ga[a] = v
+			}
+		}
+	}
+	res["fan"] = fa
+	res["not_fan"] = ga
+	return
+}
+
+// ViewerTrend visitor trend data analysis.
+func (d *Dao) ViewerTrend(c context.Context, mid int64, dt string) (res map[string]*data.Trend, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpViewerTrend + dt
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("ViewerTrend d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("ViewerTrend no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+	families := make(map[string]string, 4)
+	families["fs"] = ""
+	families["ft"] = ""
+	families["gs"] = ""
+	families["gt"] = ""
+	res = make(map[string]*data.Trend)
+	ftd := &data.Trend{}
+	gtd := &data.Trend{}
+	ty := make(map[int]int64)
+	tg := make(map[int]int64)
+	nty := make(map[int]int64)
+	ntg := make(map[int]int64)
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if _, ok := families[string(c.Family)]; ok {
+			if string(c.Family) == "fs" {
+				tid, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+				ty[tid] = v
+				ftd.Ty = ty
+			} else if string(c.Family) == "gs" {
+				tid, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+				nty[tid] = v
+				gtd.Ty = nty
+			}
+			if string(c.Family) == "ft" {
+				o, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+				tg[o] = v
+				ftd.Tag = tg
+			} else if string(c.Family) == "gt" {
+				o, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+				ntg[o] = v
+				gtd.Tag = ntg
+			}
+		}
+	}
+	res["fan"] = ftd
+	res["not_fan"] = gtd
+	return
+}
+
+// RelationFansDay up relation 30 days analysis.
+func (d *Dao) RelationFansDay(c context.Context, mid int64) (res map[string]map[string]int, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpRelationFansDay
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("RelationFansDay d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("RelationFansDay no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+	res = make(map[string]map[string]int)
+	families := make(map[string]string, 2)
+	families["a"] = "" //某日新增关注量
+	families["u"] = "" //某日取关量
+	fd := make(map[string]int)
+	nfd := make(map[string]int)
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if _, ok := families[string(c.Family)]; ok {
+			if string(c.Family) == "a" {
+				k := string(c.Qualifier[:])
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				fd[k] = v
+			} else if string(c.Family) == "u" {
+				k := string(c.Qualifier[:])
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				nfd[k] = v
+			}
+		}
+	}
+	res["follow"] = fd
+	res["unfollow"] = nfd
+	return
+}
+
+// RelationFansHistory up relation history.
+func (d *Dao) RelationFansHistory(c context.Context, mid int64, month string) (res map[string]map[string]int, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpRelationFansHistory
+		key         = string(hbaseMd5Key(mid)) + "_" + month
+	)
+	defer cancel()
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("RelationFansHistory d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("RelationFansHistory no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+	res = make(map[string]map[string]int)
+	families := make(map[string]string, 2)
+	families["a"] = "" //某日新增关注量
+	families["u"] = "" //某日取关量
+	fd := make(map[string]int)
+	nfd := make(map[string]int)
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if _, ok := families[string(c.Family)]; ok {
+			if string(c.Family) == "a" {
+				k := string(c.Qualifier[:])
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				fd[k] = v
+			} else if string(c.Family) == "u" {
+				k := string(c.Qualifier[:])
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				nfd[k] = v
+			}
+		}
+	}
+	res["follow"] = fd
+	res["unfollow"] = nfd
+	return
+}
+
+// RelationFansMonth up relation 400 days analysis.
+func (d *Dao) RelationFansMonth(c context.Context, mid int64) (res map[string]map[string]int, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpRelationFansMonth
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("RelationFansMonth d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("RelationFansMonth no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+	res = make(map[string]map[string]int)
+	families := make(map[string]string, 2)
+	families["a"] = "" //某日新增关注量
+	families["u"] = "" //某日取关量
+	fd := make(map[string]int)
+	nfd := make(map[string]int)
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if _, ok := families[string(c.Family)]; ok {
+			if string(c.Family) == "a" {
+				k := string(c.Qualifier[:])
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				fd[k] = v
+			} else if string(c.Family) == "u" {
+				k := string(c.Qualifier[:])
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				nfd[k] = v
+			}
+		}
+	}
+	res["follow"] = fd
+	res["unfollow"] = nfd
+	return
+}
+
+// ViewerActionHour visitor action hour analysis.
+func (d *Dao) ViewerActionHour(c context.Context, mid int64, dt string) (res map[string]*data.ViewerActionHour, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   = HBaseUpViewerActionHour + dt
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("ViewerActionHour d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("ViewerActionHour no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+	families := make(map[string]string, 4)
+	families["fp"] = "" //播放数
+	families["fr"] = "" //评论数
+	families["fd"] = "" //弹幕数
+	families["fe"] = "" //充电数
+	families["fs"] = "" //承包数
+	res = make(map[string]*data.ViewerActionHour)
+	view := make(map[int]int)
+	reply := make(map[int]int)
+	danmu := make(map[int]int)
+	elec := make(map[int]int)
+	con := make(map[int]int)
+	fah := &data.ViewerActionHour{}
+	gah := &data.ViewerActionHour{}
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if _, ok := families[string(c.Family)]; ok {
+			if string(c.Family) == "fp" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				view[k] = v
+				fah.View = view
+			} else if string(c.Family) == "gp" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				view[k] = v
+				gah.View = view
+			}
+			if string(c.Family) == "fr" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				reply[k] = v
+				fah.Reply = reply
+			} else if string(c.Family) == "gr" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				reply[k] = v
+				gah.Reply = reply
+			}
+			if string(c.Family) == "fd" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				danmu[k] = v
+				fah.Dm = danmu
+			} else if string(c.Family) == "gd" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				danmu[k] = v
+				gah.Dm = danmu
+			}
+			if string(c.Family) == "fe" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				elec[k] = v
+				fah.Elec = elec
+			} else if string(c.Family) == "ge" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				elec[k] = v
+				gah.Elec = elec
+			}
+			if string(c.Family) == "fs" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				con[k] = v
+				fah.Contract = con
+			} else if string(c.Family) == "gs" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				con[k] = v
+				gah.Contract = con
+			}
+		}
+	}
+	res["fan"] = fah
+	res["not_fan"] = gah
+	return
+}
+
+// UpIncr for Play/Dm/Reply/Fav/Share/Elec/Coin incr.
+func (d *Dao) UpIncr(c context.Context, mid int64, ty int8, now string) (res *data.UpDataIncrMeta, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, d.hbaseTimeOut)
+		tableName   string
+		IncrKey     string
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+	switch {
+	case ty == data.Play:
+		tableName = HBaseUpPlayInc + now
+	case ty == data.Dm:
+		tableName = HBaseUpDmInc + now
+	case ty == data.Reply:
+		tableName = HBaseUpReplyInc + now
+	case ty == data.Share:
+		tableName = HBaseUpShareInc + now
+	case ty == data.Coin:
+		tableName = HBaseUpCoinInc + now
+	case ty == data.Fav:
+		tableName = HBaseUpFavInc + now
+	case ty == data.Elec:
+		tableName = HBaseUpElecInc + now
+	}
+	IncrKey, _ = data.IncrTy(ty)
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("UpIncr d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("UpIncr no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+	families := make(map[string]string, 4)
+	families["u"] = ""  //单日播放增量 u:play ...
+	families["av"] = "" //播放top稿件 av:1
+	families["v"] = ""  //top稿件播放增量 v:1
+	families["rk"] = "" //up主播放量排名 rk: [tid]
+	aids := make(map[int]int64)
+	incs := make(map[int]int)
+	rk := make(map[int]int)
+	var incr int
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		if _, ok := families[string(c.Family)]; ok {
+			if string(c.Family) == "av" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.ParseInt(string(c.Value[:]), 10, 64)
+				aids[k] = v
+			} else if string(c.Family) == "v" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				incs[k] = v
+			} else if string(c.Family) == "rk" {
+				k, _ := strconv.Atoi(string(c.Qualifier[:]))
+				v, _ := strconv.Atoi(string(c.Value[:]))
+				rk[k] = v
+			} else if string(c.Family) == "u" {
+				if bytes.Equal(c.Qualifier, []byte(IncrKey)) {
+					v, _ := strconv.Atoi(string(c.Value[:]))
+					if v < 0 {
+						v = 0
+					}
+					incr = v
+				}
+			}
+		}
+	}
+	res = &data.UpDataIncrMeta{}
+	res.Incr = incr
+	res.TopAIDList = aids
+	res.TopIncrList = incs
+	res.Rank = rk
+	return
+}
+
+// ThirtyDayArchive for Play/Dm/Reply/Fav/Share/Elec/Coin for archive 30 days.
+func (d *Dao) ThirtyDayArchive(c context.Context, mid int64, ty int8) (res []*data.ThirtyDay, err error) {
+	var (
+		result      *hrpc.Result
+		ctx, cancel = context.WithTimeout(c, time.Duration(d.c.HBase.ReadTimeout))
+		tableName   string
+		key         = hbaseMd5Key(mid)
+	)
+	defer cancel()
+	switch {
+	case ty == data.Play:
+		tableName = HBasePlayArc
+	case ty == data.Dm:
+		tableName = HBaseDmArc
+	case ty == data.Reply:
+		tableName = HBaseReplyArc
+	case ty == data.Share:
+		tableName = HBaseShareArc
+	case ty == data.Coin:
+		tableName = HBaseCoinArc
+	case ty == data.Fav:
+		tableName = HBaseFavArc
+	case ty == data.Elec:
+		tableName = HBaseElecArc
+	case ty == data.Like:
+		tableName = HBaseLikeArc
+	}
+	if result, err = d.hbase.GetStr(ctx, tableName, key); err != nil {
+		log.Error("ThirtyDayArchive d.hbase.GetStr tableName(%s)|mid(%d)|key(%v)|error(%v)", tableName, mid, key, err)
+		err = ecode.CreativeDataErr
+		return
+	}
+	if result == nil || len(result.Cells) == 0 {
+		log.Warn("ThirtyDay no data tableName(%s)|mid(%d)|key(%v)", tableName, mid, key)
+		return
+	}
+	res = make([]*data.ThirtyDay, 0, len(result.Cells))
+	for _, c := range result.Cells {
+		if c == nil {
+			continue
+		}
+		qual := string(c.Qualifier[:])
+		val := string(c.Value[:])
+		if string(c.Family) == "u" {
+			t, v, err := parseKeyValue(qual, val)
+			if err != nil {
+				break
+			}
+			td := &data.ThirtyDay{}
+			td.DateKey = t
+			td.TotalIncr = v
+			res = append(res, td)
+		}
+	}
+	log.Info("ThirtyDayArchive mid(%d) type(%d) return data(%+v)", mid, ty, res)
+	return
+}
+
+func parseKeyValue(k string, v string) (timestamp, value int64, err error) {
+	tm, err := time.Parse("20060102", k)
+	if err != nil {
+		log.Error("time.Parse error(%v)", err)
+		return
+	}
+	timestamp = tm.Unix()
+	value, err = strconv.ParseInt(v, 10, 64)
+	if err != nil {
+		log.Error("strconv.ParseInt error(%v)", err)
+	}
+	return
+}

app/interface/main/creative/dao/data/overview_mc.go

@@ -0,0 +1,372 @@
+package data
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/creative/model/data"
+	artmdl "go-common/app/interface/openplatform/article/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_basePrefix         = "bse_"
+	_areaPrefix         = "are_"
+	_trendPrefix        = "tre_"
+	_rfdPrefix          = "rfd_"
+	_rfmPrefix          = "rfm_"
+	_actPrefix          = "act_"
+	_incrPrefix         = "incr_"
+	_thirtyDayArcPrefix = "30arc_"
+	_thirtyDayArtPrefix = "30art_"
+)
+
+func keyBase(mid int64, date string) string {
+	return _basePrefix + date + "_" + strconv.FormatInt(mid, 10)
+}
+
+func keyArea(mid int64, date string) string {
+	return _areaPrefix + date + "_" + strconv.FormatInt(mid, 10)
+}
+
+func keyTrend(mid int64, date string) string {
+	return _trendPrefix + date + "_" + strconv.FormatInt(mid, 10)
+}
+
+func keyRfd(mid int64, date string) string {
+	return _rfdPrefix + date + "_" + strconv.FormatInt(mid, 10)
+}
+
+func keyRfm(mid int64, date string) string {
+	return _rfmPrefix + date + "_" + strconv.FormatInt(mid, 10)
+}
+
+func keyAct(mid int64, date string) string {
+	return _actPrefix + date + "_" + strconv.FormatInt(mid, 10)
+}
+
+func keyViewIncr(mid int64, ty, date string) string {
+	return _incrPrefix + ty + "_" + date + "_" + strconv.FormatInt(mid, 10)
+}
+
+func keyThirtyDayArchive(mid int64, ty string) string {
+	return _thirtyDayArcPrefix + ty + "_" + strconv.FormatInt(mid, 10)
+}
+
+func keyThirtyDayArticle(mid int64) string {
+	return _thirtyDayArtPrefix + "_" + strconv.FormatInt(mid, 10)
+}
+
+// ViewerBaseCache add ViewerBaseCache cache.
+func (d *Dao) ViewerBaseCache(c context.Context, mid int64, dt string) (res map[string]*data.ViewerBase, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	// get cache
+	r, err = conn.Get(keyBase(mid, dt))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Get(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", r.Value, err)
+		res = nil
+	}
+	return
+}
+
+// AddViewerBaseCache add ViewerBaseCache cache update data by week.
+func (d *Dao) AddViewerBaseCache(c context.Context, mid int64, dt string, res map[string]*data.ViewerBase) (err error) {
+	key := keyBase(mid, dt)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: res, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}
+
+// ViewerAreaCache add ViewerArea cache.
+func (d *Dao) ViewerAreaCache(c context.Context, mid int64, dt string) (res map[string]map[string]int64, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	// get cache
+	r, err = conn.Get(keyArea(mid, dt))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Get(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", r.Value, err)
+		res = nil
+	}
+	return
+}
+
+// AddViewerAreaCache add ViewerArea cache update data by week.
+func (d *Dao) AddViewerAreaCache(c context.Context, mid int64, dt string, res map[string]map[string]int64) (err error) {
+	key := keyArea(mid, dt)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: res, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}
+
+// TrendCache add trend cache.
+func (d *Dao) TrendCache(c context.Context, mid int64, dt string) (res map[string]*data.ViewerTrend, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	// get cache
+	r, err = conn.Get(keyTrend(mid, dt))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Get(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", r.Value, err)
+		res = nil
+	}
+	return
+}
+
+// AddTrendCache add trend cache update data by week.
+func (d *Dao) AddTrendCache(c context.Context, mid int64, dt string, res map[string]*data.ViewerTrend) (err error) {
+	key := keyTrend(mid, dt)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: res, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}
+
+// RelationFansDayCache add relation day cache.
+func (d *Dao) RelationFansDayCache(c context.Context, mid int64, dt string) (res map[string]map[string]int, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	// get cache
+	r, err = conn.Get(keyRfd(mid, dt))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Get(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", r.Value, err)
+		res = nil
+	}
+	return
+}
+
+// AddRelationFansDayCache add relation day cache update data by day.
+func (d *Dao) AddRelationFansDayCache(c context.Context, mid int64, dt string, res map[string]map[string]int) (err error) {
+	key := keyRfd(mid, dt)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: res, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}
+
+// RelationFansMonthCache add relation month cache.
+func (d *Dao) RelationFansMonthCache(c context.Context, mid int64, dt string) (res map[string]map[string]int, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	r, err = conn.Get(keyRfm(mid, dt))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Get(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", r.Value, err)
+		res = nil
+	}
+	return
+}
+
+// AddRelationFansMonthCache add relation month cache update data by day.
+func (d *Dao) AddRelationFansMonthCache(c context.Context, mid int64, dt string, res map[string]map[string]int) (err error) {
+	key := keyRfm(mid, dt)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: res, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}
+
+// ViewerActionHourCache add ActionHour cache.
+func (d *Dao) ViewerActionHourCache(c context.Context, mid int64, dt string) (res map[string]*data.ViewerActionHour, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	r, err = conn.Get(keyAct(mid, dt))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Get(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", r.Value, err)
+		res = nil
+	}
+	return
+}
+
+// AddViewerActionHourCache add ActionHour cache update data by week.
+func (d *Dao) AddViewerActionHourCache(c context.Context, mid int64, dt string, res map[string]*data.ViewerActionHour) (err error) {
+	key := keyAct(mid, dt)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: res, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}
+
+// ViewerIncrCache get ViewerIncr cache.
+func (d *Dao) ViewerIncrCache(c context.Context, mid int64, ty, dt string) (res *data.ViewerIncr, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	// get cache
+	r, err = conn.Get(keyViewIncr(mid, ty, dt))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Get(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", r.Value, err)
+		res = nil
+	}
+	return
+}
+
+// AddViewerIncrCache add ViewerIncr cache update data by day.
+func (d *Dao) AddViewerIncrCache(c context.Context, mid int64, ty, dt string, res *data.ViewerIncr) (err error) {
+	key := keyViewIncr(mid, ty, dt)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: res, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}
+
+// ThirtyDayArchiveCache get archive 30 days cache.
+func (d *Dao) ThirtyDayArchiveCache(c context.Context, mid int64, ty string) (res []*data.ThirtyDay, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	// get cache
+	r, err = conn.Get(keyThirtyDayArchive(mid, ty))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Get(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", r.Value, err)
+		res = nil
+	}
+	return
+}
+
+// AddThirtyDayArchiveCache add archive 30 days cache update data by day.
+func (d *Dao) AddThirtyDayArchiveCache(c context.Context, mid int64, ty string, res []*data.ThirtyDay) (err error) {
+	key := keyThirtyDayArchive(mid, ty)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: res, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}
+
+// ThirtyDayArticleCache get article 30 days cache.
+func (d *Dao) ThirtyDayArticleCache(c context.Context, mid int64) (res []*artmdl.ThirtyDayArticle, err error) {
+	var (
+		conn = d.mc.Get(c)
+		r    *memcache.Item
+	)
+	defer conn.Close()
+	// get cache
+	r, err = conn.Get(keyThirtyDayArticle(mid))
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Get(%d) error(%v)", mid, err)
+		}
+		return
+	}
+	if err = conn.Scan(r, &res); err != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", r.Value, err)
+		res = nil
+	}
+	return
+}
+
+// AddThirtyDayArticleCache add article 30 days cache update data by day.
+func (d *Dao) AddThirtyDayArticleCache(c context.Context, mid int64, res []*artmdl.ThirtyDayArticle) (err error) {
+	key := keyThirtyDayArticle(mid)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: key, Object: res, Flags: memcache.FlagJSON, Expiration: d.mcExpire}); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", key, err)
+	}
+	return
+}

app/interface/main/creative/dao/data/overview_mc_test.go

@@ -0,0 +1,420 @@
+package data
+
+import (
+	"context"
+	"go-common/app/interface/main/creative/model/data"
+	artmdl "go-common/app/interface/openplatform/article/model"
+	"go-common/library/cache/memcache"
+	"reflect"
+	"testing"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDatakeyBase(t *testing.T) {
+	var (
+		mid  = int64(1)
+		date = ""
+	)
+	convey.Convey("keyBase", t, func(ctx convey.C) {
+		p1 := keyBase(mid, date)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDatakeyArea(t *testing.T) {
+	var (
+		mid  = int64(0)
+		date = ""
+	)
+	convey.Convey("keyArea", t, func(ctx convey.C) {
+		p1 := keyArea(mid, date)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDatakeyTrend(t *testing.T) {
+	var (
+		mid  = int64(1)
+		date = ""
+	)
+	convey.Convey("keyTrend", t, func(ctx convey.C) {
+		p1 := keyTrend(mid, date)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDatakeyRfd(t *testing.T) {
+	var (
+		mid  = int64(1)
+		date = ""
+	)
+	convey.Convey("keyRfd", t, func(ctx convey.C) {
+		p1 := keyRfd(mid, date)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDatakeyRfm(t *testing.T) {
+	var (
+		mid  = int64(1)
+		date = ""
+	)
+	convey.Convey("keyRfm", t, func(ctx convey.C) {
+		p1 := keyRfm(mid, date)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDatakeyAct(t *testing.T) {
+	var (
+		mid  = int64(0)
+		date = ""
+	)
+	convey.Convey("keyAct", t, func(ctx convey.C) {
+		p1 := keyAct(mid, date)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDatakeyViewIncr(t *testing.T) {
+	var (
+		mid  = int64(1)
+		ty   = ""
+		date = ""
+	)
+	convey.Convey("keyViewIncr", t, func(ctx convey.C) {
+		p1 := keyViewIncr(mid, ty, date)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDatakeyThirtyDayArchive(t *testing.T) {
+	var (
+		mid = int64(1)
+		ty  = ""
+	)
+	convey.Convey("keyThirtyDayArchive", t, func(ctx convey.C) {
+		p1 := keyThirtyDayArchive(mid, ty)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDatakeyThirtyDayArticle(t *testing.T) {
+	var (
+		mid = int64(1)
+	)
+	convey.Convey("keyThirtyDayArticle", t, func(ctx convey.C) {
+		p1 := keyThirtyDayArticle(mid)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDataViewerBaseCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		dt  = "dt"
+		err error
+	)
+	convey.Convey("ViewerBaseCache1", t, func(ctx convey.C) {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrExists)
+		})
+		defer connGuard.Unpatch()
+		_, err = d.ViewerBaseCache(c, mid, dt)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("ViewerBaseCache2", t, func(ctx convey.C) {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrNotFound)
+		})
+		defer connGuard.Unpatch()
+		_, err = d.ViewerBaseCache(c, mid, dt)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataAddViewerBaseCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		dt  = ""
+		res map[string]*data.ViewerBase
+	)
+	convey.Convey("AddViewerBaseCache", t, func(ctx convey.C) {
+		err := d.AddViewerBaseCache(c, mid, dt, res)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataViewerAreaCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		dt  = "dt"
+	)
+	convey.Convey("ViewerAreaCache1", t, func(ctx convey.C) {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrExists)
+		})
+		defer connGuard.Unpatch()
+		_, err := d.ViewerAreaCache(c, mid, dt)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("ViewerAreaCache2", t, func(ctx convey.C) {
+		connGuard := monkey.PatchInstanceMethod(reflect.TypeOf(d.mc), "Get", func(_ *memcache.Pool, _ context.Context) memcache.Conn {
+			return memcache.MockWith(memcache.ErrNotFound)
+		})
+		defer connGuard.Unpatch()
+		_, err := d.ViewerAreaCache(c, mid, dt)
+		ctx.Convey("ShouldBeNil", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataAddViewerAreaCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+		res map[string]map[string]int64
+	)
+	convey.Convey("AddViewerAreaCache", t, func(ctx convey.C) {
+		err := d.AddViewerAreaCache(c, mid, dt, res)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataTrendCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+	)
+	convey.Convey("TrendCache", t, func(ctx convey.C) {
+		_, err := d.TrendCache(c, mid, dt)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataAddTrendCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+		res map[string]*data.ViewerTrend
+	)
+	convey.Convey("AddTrendCache", t, func(ctx convey.C) {
+		err := d.AddTrendCache(c, mid, dt, res)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataRelationFansDayCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+	)
+	convey.Convey("RelationFansDayCache", t, func(ctx convey.C) {
+		_, err := d.RelationFansDayCache(c, mid, dt)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataAddRelationFansDayCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+		res map[string]map[string]int
+	)
+	convey.Convey("AddRelationFansDayCache", t, func(ctx convey.C) {
+		err := d.AddRelationFansDayCache(c, mid, dt, res)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataRelationFansMonthCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+		dt  = ""
+	)
+	convey.Convey("RelationFansMonthCache", t, func(ctx convey.C) {
+		_, err := d.RelationFansMonthCache(c, mid, dt)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataAddRelationFansMonthCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+		res map[string]map[string]int
+	)
+	convey.Convey("AddRelationFansMonthCache", t, func(ctx convey.C) {
+		err := d.AddRelationFansMonthCache(c, mid, dt, res)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataViewerActionHourCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+	)
+	convey.Convey("ViewerActionHourCache", t, func(ctx convey.C) {
+		_, err := d.ViewerActionHourCache(c, mid, dt)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataAddViewerActionHourCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		dt  = ""
+		res map[string]*data.ViewerActionHour
+	)
+	convey.Convey("AddViewerActionHourCache", t, func(ctx convey.C) {
+		err := d.AddViewerActionHourCache(c, mid, dt, res)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataViewerIncrCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		ty  = ""
+		dt  = ""
+	)
+	convey.Convey("ViewerIncrCache", t, func(ctx convey.C) {
+		_, err := d.ViewerIncrCache(c, mid, ty, dt)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataAddViewerIncrCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		ty  = ""
+		dt  = ""
+		res = &data.ViewerIncr{}
+	)
+	convey.Convey("AddViewerIncrCache", t, func(ctx convey.C) {
+		err := d.AddViewerIncrCache(c, mid, ty, dt, res)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataThirtyDayArchiveCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		ty  = ""
+	)
+	convey.Convey("ThirtyDayArchiveCache", t, func(ctx convey.C) {
+		_, err := d.ThirtyDayArchiveCache(c, mid, ty)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataAddThirtyDayArchiveCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		ty  = ""
+		res = []*data.ThirtyDay{}
+	)
+	convey.Convey("AddThirtyDayArchiveCache", t, func(ctx convey.C) {
+		err := d.AddThirtyDayArchiveCache(c, mid, ty, res)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataThirtyDayArticleCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+	)
+	convey.Convey("ThirtyDayArticleCache", t, func(ctx convey.C) {
+		_, err := d.ThirtyDayArticleCache(c, mid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataAddThirtyDayArticleCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		res = []*artmdl.ThirtyDayArticle{}
+	)
+	convey.Convey("AddThirtyDayArticleCache", t, func(ctx convey.C) {
+		err := d.AddThirtyDayArticleCache(c, mid, res)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/data/overview_test.go

@@ -0,0 +1,395 @@
+package data
+
+import (
+	"context"
+	"encoding/binary"
+	"reflect"
+	"testing"
+
+	"go-common/library/ecode"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+	"github.com/tsuna/gohbase/hrpc"
+	hbase "go-common/library/database/hbase.v2"
+)
+
+func TestDataViewerBase(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		dt  = "dt"
+		err error
+	)
+	convey.Convey("1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerBase(c, mid, dt)
+		ctx.Convey("1", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerBase(c, mid, dt)
+		ctx.Convey("2", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("3", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("f"),
+				Qualifier: []byte("male"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerBase(c, mid, dt)
+		ctx.Convey("3", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("4", t, func(ctx convey.C) {
+		g1 := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("g"),
+				Qualifier: []byte("female"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer g1.Unpatch()
+		_, err = d.ViewerBase(c, mid, dt)
+		ctx.Convey("41", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+		g2 := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("g"),
+				Qualifier: []byte("male"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer g2.Unpatch()
+		_, err = d.ViewerBase(c, mid, dt)
+		ctx.Convey("42", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataViewerTrend(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		dt  = "dt"
+		err error
+	)
+	convey.Convey("1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerTrend(c, mid, dt)
+		ctx.Convey("1", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerTrend(c, mid, dt)
+		ctx.Convey("2", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("3", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("fs"),
+				Qualifier: []byte("male"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerTrend(c, mid, dt)
+		ctx.Convey("3", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("4", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("gs"),
+				Qualifier: []byte("male"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerTrend(c, mid, dt)
+		ctx.Convey("4", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataRelationFansDay(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+	)
+	convey.Convey("RelationFansDay", t, func(ctx convey.C) {
+		_, err := d.RelationFansDay(c, mid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDataRelationFansHistory(t *testing.T) {
+	var (
+		c     = context.TODO()
+		mid   = int64(0)
+		month = ""
+	)
+	convey.Convey("RelationFansHistory", t, func(ctx convey.C) {
+		_, err := d.RelationFansHistory(c, mid, month)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDataRelationFansMonth(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+	)
+	convey.Convey("RelationFansMonth", t, func(ctx convey.C) {
+		_, err := d.RelationFansMonth(c, mid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDataViewerActionHour(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(2089809)
+		dt  = "dt"
+		err error
+	)
+	convey.Convey("1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerActionHour(c, mid, dt)
+		ctx.Convey("1", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerActionHour(c, mid, dt)
+		ctx.Convey("2", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("3", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("fs"),
+				Qualifier: []byte("male"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerActionHour(c, mid, dt)
+		ctx.Convey("3", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("4", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("gs"),
+				Qualifier: []byte("male"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ViewerActionHour(c, mid, dt)
+		ctx.Convey("4", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataUpIncr(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		ty  = int8(2)
+		now = ""
+		err error
+	)
+	convey.Convey("1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err = d.UpIncr(c, mid, ty, now)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.UpIncr(c, mid, ty, now)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("3", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			bs := make([]byte, 4)
+			binary.LittleEndian.PutUint32(bs, 123)
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("u"),
+				Qualifier: []byte("male"),
+				Value:     bs,
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.UpIncr(c, mid, ty, now)
+		ctx.Convey("3", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataThirtyDayArchive(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+		ty  = int8(2)
+		err error
+	)
+	convey.Convey("1", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			return nil, ecode.CreativeDataErr
+		})
+		defer guard.Unpatch()
+		_, err = d.ThirtyDayArchive(c, mid, ty)
+		ctx.Convey("1", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+	convey.Convey("2", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{}
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ThirtyDayArchive(c, mid, ty)
+		ctx.Convey("2", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+	convey.Convey("3", t, func(ctx convey.C) {
+		guard := monkey.PatchInstanceMethod(reflect.TypeOf(d.hbase), "GetStr", func(_ *hbase.Client, _ context.Context, _, _ string, _ ...func(hrpc.Call) error) (*hrpc.Result, error) {
+			res := &hrpc.Result{
+				Cells: make([]*hrpc.Cell, 0),
+			}
+			res.Cells = append(res.Cells, &hrpc.Cell{
+				Family:    []byte("u"),
+				Qualifier: []byte("20181111"),
+				Value:     []byte("200"),
+			})
+			return res, nil
+		})
+		defer guard.Unpatch()
+		_, err = d.ThirtyDayArchive(c, mid, ty)
+		ctx.Convey("3", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDataparseKeyValue(t *testing.T) {
+	var (
+		k = ""
+		v = ""
+	)
+	convey.Convey("parseKeyValue", t, func(ctx convey.C) {
+		_, _, err := parseKeyValue(k, v)
+		ctx.Convey("Then err should be nil.timestamp,value should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+		})
+	})
+}

app/interface/main/creative/dao/data/table.go

@@ -0,0 +1,131 @@
+package data
+
+var (
+	//HBaseVideoTablePrefix 播放流失分布
+	HBaseVideoTablePrefix = "video_play_churn_"
+	//HBaseArchiveTablePrefix 分类分端播放
+	HBaseArchiveTablePrefix = "video_play_category_"
+	//HBaseAreaTablePrefix 地区播放
+	HBaseAreaTablePrefix = "video_play_area_"
+	//HBaseUpStatTablePrefix up主概况
+	HBaseUpStatTablePrefix = "up_stats_"
+	//HBaseUpViewerBase 观众数据,性别年龄分布 + 设备分布
+	HBaseUpViewerBase = "up_viewer_base_"
+	//HBaseUpViewerArea 地区分布
+	HBaseUpViewerArea = "up_viewer_area_"
+	//HBaseUpViewerTrend 内容倾向
+	HBaseUpViewerTrend = "up_viewer_trend_"
+	//HBaseUpViewerActionHour 行为时间分布
+	HBaseUpViewerActionHour = "up_viewer_action_hour_"
+	//HBaseUpRelationFansDay 日维度 最近30天 只保留31天
+	HBaseUpRelationFansDay = "up_relation_fans_day"
+	// HBaseUpRelationFansHistory 日维度 各月份每日数据,日更,永久保存
+	HBaseUpRelationFansHistory = "up_relation_fans_history"
+	//HBaseUpRelationFansMonth 年维度 2017.8月以后的数据永久保存
+	HBaseUpRelationFansMonth = "up_relation_fans_month"
+	//HBaseUpPlayInc 我的概况 播放相关
+	HBaseUpPlayInc = "up_play_inc_"
+	//HBaseUpDmInc 弹幕相关
+	HBaseUpDmInc = "up_dm_inc_"
+	//HBaseUpReplyInc 评论相关
+	HBaseUpReplyInc = "up_reply_inc_"
+	//HBaseUpShareInc 分享相关
+	HBaseUpShareInc = "up_share_inc_"
+	//HBaseUpCoinInc 投币相关
+	HBaseUpCoinInc = "up_coin_inc_"
+	//HBaseUpFavInc 收藏相关
+	HBaseUpFavInc = "up_fav_inc_"
+	//HBaseUpElecInc 充电相关
+	HBaseUpElecInc = "up_elec_inc_"
+	//HBaseUpFansAnalysis  粉丝管理
+	HBaseUpFansAnalysis = "up_fans_analysis"
+	//HBaseUpPlaySourceAnalysis  播放来源
+	HBaseUpPlaySourceAnalysis = "up_play_analysis"
+	//HBaseUpArcPlayAnalysis  平均观看时长、播放用户数、留存率
+	HBaseUpArcPlayAnalysis = "up_archive_play_analysis"
+	//HBaseUpArcQuery  稿件索引表
+	HBaseUpArcQuery = "up_archive_query"
+	//HBaseUpFansMedalQuery  up主粉丝勋章
+	HBaseUpFansMedalQuery = "up_fans_medal"
+	//HBaseupArchiveStatQuery  up主稿件指标表
+	HBaseupArchiveStatQuery = "creation:up_archive_stat_"
+
+	//HBasePlayArc 播放相关 archive for 30 days
+	HBasePlayArc = "up_play_trend"
+	//HBaseDmArc 弹幕相关
+	HBaseDmArc = "up_dm_trend"
+	//HBaseReplyArc 评论相关
+	HBaseReplyArc = "up_reply_trend"
+	//HBaseShareArc 分享相关
+	HBaseShareArc = "up_share_trend"
+	//HBaseCoinArc 投币相关
+	HBaseCoinArc = "up_coin_trend"
+	//HBaseFavArc 收藏相关
+	HBaseFavArc = "up_fav_trend"
+	//HBaseElecArc 充电相关
+	HBaseElecArc = "up_elec_trend"
+	//HBaseLikeArc 点赞相关
+	HBaseLikeArc = "up_like_trend"
+
+	//HBaseFamilyPlat  family
+	HBaseFamilyPlat = []byte("v")
+	//HBaseColumnAid aid
+	HBaseColumnAid = []byte("avid")
+	//HBaseColumnWebPC pc
+	HBaseColumnWebPC = []byte("plat0")
+	//HBaseColumnWebH5 h5
+	HBaseColumnWebH5 = []byte("plat1")
+	//HBaseColumnOutsite out
+	HBaseColumnOutsite = []byte("plat2")
+	//HBaseColumnIOS ios
+	HBaseColumnIOS = []byte("plat3")
+	//HBaseColumnAndroid android
+	HBaseColumnAndroid = []byte("plat4")
+	//HBaseColumnElse else
+	HBaseColumnElse = []byte("else")
+	//HBaseColumnFans fans
+	HBaseColumnFans = []byte("fans")
+	//HBaseColumnGuest guest
+	HBaseColumnGuest = []byte("guest")
+	//HBaseColumnAll all
+	HBaseColumnAll = []byte("all")
+	//HBaseColumnCoin coin
+	HBaseColumnCoin = []byte("coin")
+	//HBaseColumnElec elec
+	HBaseColumnElec = []byte("elec")
+	//HBaseColumnFav fav
+	HBaseColumnFav = []byte("fav")
+	//HBaseColumnShare share
+	HBaseColumnShare = []byte("share")
+)
+
+const (
+	//ArtViewTBL 专栏增量数据趋势-阅读
+	ArtViewTBL = "creation:read_up_view_trend"
+	//ArtReplyTBL 评论
+	ArtReplyTBL = "creation:read_up_reply_trend"
+	//ArtShareTBL  分享
+	ArtShareTBL = "creation:read_up_share_trend"
+	//ArtCoinTBL  硬币
+	ArtCoinTBL = "creation:read_up_coin_trend"
+	//ArtFavTBL 收藏
+	ArtFavTBL = "creation:read_up_fav_trend"
+	//ArtLikeTBL 喜欢
+	ArtLikeTBL = "creation:read_up_like_trend"
+
+	//ArtViewIncTBL 来源稿件-阅读
+	ArtViewIncTBL = "creation:read_up_view_inc_"
+	//ArtReplyIncTBL 评论
+	ArtReplyIncTBL = "creation:read_up_reply_inc_"
+	//ArtShareIncTBL  分享
+	ArtShareIncTBL = "creation:read_up_share_inc_"
+	//ArtCoinIncTBL  硬币
+	ArtCoinIncTBL = "creation:read_up_coin_inc_"
+	//ArtFavIncTBL 收藏
+	ArtFavIncTBL = "creation:read_up_fav_inc_"
+	//ArtLikeIncTBL 喜欢
+	ArtLikeIncTBL = "creation:read_up_like_inc_"
+
+	//ArtReadAnalysisTBL 阅读来源分析
+	ArtReadAnalysisTBL = "creation:read_up_play_analysis"
+)