Create & Init Project...

app/interface/main/dm2/dao/BUILD

@@ -0,0 +1,118 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "advert_test.go",
+        "archive_test.go",
+        "bfs_test.go",
+        "bigdata_test.go",
+        "broadcast_test.go",
+        "dao_test.go",
+        "databus_test.go",
+        "mask_test.go",
+        "mc_filter_test.go",
+        "mc_limiter_test.go",
+        "mc_seg_test.go",
+        "mc_subtitle_test.go",
+        "mc_test.go",
+        "mc_wave_form_test.go",
+        "mysql_advance_test.go",
+        "mysql_filter_test.go",
+        "mysql_subtitle_test.go",
+        "mysql_test.go",
+        "notify_test.go",
+        "redis_rct_test.go",
+        "redis_seg_test.go",
+        "redis_test.go",
+        "search_test.go",
+        "upos_test.go",
+        "user_log_test.go",
+        "workflow_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/dm2/conf:go_default_library",
+        "//app/interface/main/dm2/model:go_default_library",
+        "//library/log:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "advert.go",
+        "archive.go",
+        "bfs.go",
+        "bigdata.go",
+        "broadcast.go",
+        "dao.go",
+        "databus.go",
+        "mask.go",
+        "mc.go",
+        "mc_filter.go",
+        "mc_limiter.go",
+        "mc_seg.go",
+        "mc_subtitle.go",
+        "mc_wave_form.go",
+        "mysql.go",
+        "mysql_advance.go",
+        "mysql_filter.go",
+        "mysql_subtitle.go",
+        "notify.go",
+        "redis.go",
+        "redis_rct.go",
+        "redis_seg.go",
+        "search.go",
+        "upos.go",
+        "user_log.go",
+        "workflow.go",
+    ],
+    importpath = "go-common/app/interface/main/dm2/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/dm2/conf:go_default_library",
+        "//app/interface/main/dm2/model:go_default_library",
+        "//app/interface/main/videoup/model/archive:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/bfs:go_default_library",
+        "//library/database/elastic:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//library/queue/databus/report:go_default_library",
+        "//library/stat/prom:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//library/time:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/dm2/dao/advert.go

@@ -0,0 +1,53 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/ecode"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_adURL = "/bce/api/bce/wise"
+)
+
+func (d *Dao) adURI() string {
+	return d.conf.Host.Advert + _adURL
+}
+
+// DMAdvert dm advert.
+func (d *Dao) DMAdvert(c context.Context, aid, cid, mid, build int64, buvid, mobiApp, adExtra string) (data *model.AD, err error) {
+	var (
+		res *struct {
+			Code int       `json:"code"`
+			Data *model.AD `json:"data"`
+		}
+	)
+	ip := metadata.String(c, metadata.RemoteIP)
+	params := url.Values{}
+	params.Set("aid", fmt.Sprint(aid))
+	params.Set("cid", fmt.Sprint(cid))
+	params.Set("buvid", buvid)
+	params.Set("resource", model.Resource(mobiApp))
+	params.Set("mobi_app", mobiApp)
+	params.Set("build", fmt.Sprint(build))
+	params.Set("ip", ip)
+	params.Set("ad_extra", adExtra)
+	if mid != 0 {
+		params.Set("mid", fmt.Sprint(mid))
+	}
+	if err = d.httpCli.Get(c, d.adURI(), ip, params, &res); err != nil {
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = errors.Wrap(ecode.Int(res.Code), d.adURI()+"?"+params.Encode())
+		return
+	}
+	data = res.Data
+	return
+}

app/interface/main/dm2/dao/advert_test.go

@@ -0,0 +1,24 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestDMAdvert(t *testing.T) {
+	Convey("dm advert", t, func() {
+		var (
+			c             = context.TODO()
+			aid     int64 = 10100572
+			cid     int64 = 10115256
+			mid     int64 = 12345881
+			build   int64 = 8111
+			adExtra       = ""
+			buvid         = "5400000"
+			mobiApp       = "android"
+		)
+		testDao.DMAdvert(c, aid, cid, mid, build, buvid, mobiApp, adExtra)
+	})
+}

app/interface/main/dm2/dao/archive.go

@@ -0,0 +1,43 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/videoup/model/archive"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_typesURL = "/videoup/types"
+)
+
+func (d *Dao) typesURI() string {
+	return d.conf.Host.Archive + _typesURL
+}
+
+// TypeMapping is second types opposite first types.
+func (d *Dao) TypeMapping(c context.Context) (rmap map[int16]int16, err error) {
+	var res struct {
+		Code    int                     `json:"code"`
+		Message string                  `json:"message"`
+		Data    map[int16]*archive.Type `json:"data"`
+	}
+	if err = d.httpCli.Get(c, d.typesURI(), "", nil, &res); err != nil {
+		log.Error("d.httpCli.Get() error(%v) typesURI(%s)", err, d.typesURI())
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = fmt.Errorf("bangumi seasons api failed(%d)", res.Code)
+		log.Error("url(%s) res code(%d)", d.typesURI(), res.Code)
+		return
+	}
+	rmap = make(map[int16]int16, len(res.Data))
+	for _, v := range res.Data {
+		if v.PID != 0 {
+			rmap[v.ID] = v.PID
+		}
+	}
+	return
+}

app/interface/main/dm2/dao/archive_test.go

@@ -0,0 +1,34 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaotypesURI(t *testing.T) {
+	convey.Convey("typesURI", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.typesURI()
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoTypeMapping(t *testing.T) {
+	convey.Convey("TypeMapping", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			rmap, err := testDao.TypeMapping(c)
+			ctx.Convey("Then err should be nil.rmap should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(rmap, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/interface/main/dm2/dao/bfs.go

@@ -0,0 +1,22 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/library/database/bfs"
+	"go-common/library/log"
+)
+
+// UploadBfs .
+func (d *Dao) UploadBfs(c context.Context, fileName string, bs []byte) (location string, err error) {
+	if location, err = d.bfsCli.Upload(c, &bfs.Request{
+		Bucket:      d.conf.Bfs.BucketSubtitle,
+		Filename:    fileName,
+		ContentType: "application/json",
+		File:        bs,
+	}); err != nil {
+		log.Error("bfs.BfsDmUpload error(%v)", err)
+		return
+	}
+	return
+}

app/interface/main/dm2/dao/bfs_test.go

@@ -0,0 +1,21 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoUploadBfs(t *testing.T) {
+	convey.Convey("UploadBfs", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			fileName = ""
+			bs       = []byte("123")
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UploadBfs(c, fileName, bs)
+		})
+	})
+}

app/interface/main/dm2/dao/bigdata.go

@@ -0,0 +1,53 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strconv"
+
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+)
+
+const (
+	_uri = "/danmaku/%d/rec"
+)
+
+func (d *Dao) danmakuURI(oid int64) string {
+	return d.conf.Host.AI + fmt.Sprintf(_uri, oid%4)
+}
+
+// RecFlag get recommend flags from bigdata.
+func (d *Dao) RecFlag(c context.Context, mid, aid, oid, limit, ps, pe int64, plat int32) (data []byte, err error) {
+	var res struct {
+		Code int64           `json:"code"`
+		Msg  string          `json:"message"`
+		Data json.RawMessage `json:"data"`
+	}
+	uri := d.danmakuURI(oid)
+	params := url.Values{}
+	realIP := metadata.String(c, metadata.RemoteIP)
+	params.Set("mid", strconv.FormatInt(mid, 10))
+	params.Set("aid", strconv.FormatInt(aid, 10))
+	params.Set("oid", strconv.FormatInt(oid, 10))
+	params.Set("limit", strconv.FormatInt(limit, 10))
+	params.Set("ps", strconv.FormatInt(ps, 10))
+	params.Set("pe", strconv.FormatInt(pe, 10))
+	params.Set("plat", strconv.FormatInt(int64(plat), 10))
+	params.Set("ip", realIP)
+	if err = d.httpCli.Get(c, uri, realIP, params, &res); err != nil {
+		PromError(uri)
+		log.Error("d.httpCli.Get(%s?%s) error(%v)", uri, params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		PromError(uri)
+		log.Error("d.httpCli.Get(%s?%s) code:%d msg:%s", uri, params.Encode(), res.Code, res.Msg)
+		err = fmt.Errorf("bigdata response code(%d) error", res.Code)
+		return
+	}
+	data = res.Data
+	return
+}

app/interface/main/dm2/dao/bigdata_test.go

@@ -0,0 +1,40 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaodanmakuURI(t *testing.T) {
+	convey.Convey("danmakuURI", t, func(ctx convey.C) {
+		var (
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.danmakuURI(oid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRecFlag(t *testing.T) {
+	convey.Convey("RecFlag", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			mid   = int64(0)
+			aid   = int64(0)
+			oid   = int64(0)
+			limit = int64(0)
+			ps    = int64(0)
+			pe    = int64(0)
+			plat  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.RecFlag(c, mid, aid, oid, limit, ps, pe, plat)
+		})
+	})
+}

app/interface/main/dm2/dao/broadcast.go

@@ -0,0 +1,85 @@
+package dao
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+)
+
+const (
+	_goimChatURI = "/x/internal/chat/push/room"
+
+	_broadcastURI = "/x/internal/broadcast/push/room"
+
+	_broadcastDmOperation = 1000
+	_broadcastDmRoomFmt   = "video://%d/%d" //video://{aid}/{cid}
+)
+
+func (d *Dao) goimChatURI() string {
+	return d.conf.Host.API + _goimChatURI
+}
+
+func (d *Dao) broadcastURI() string {
+	return d.conf.Host.API + _broadcastURI
+}
+
+// BroadcastInGoim send dm msg in realtime.
+func (d *Dao) BroadcastInGoim(c context.Context, cid, aid int64, info json.RawMessage) (err error) {
+	var (
+		res struct {
+			Code int64 `json:"code"`
+		}
+		data = map[string]interface{}{
+			"cmd":  "DM",
+			"info": info,
+		}
+	)
+	v, err := json.Marshal(data)
+	if err != nil {
+		log.Error("json.Marshal(%s) error(%v)", info, err)
+		return
+	}
+	url := fmt.Sprintf("%s?cids=%d&aid=%d", d.goimChatURI(), cid, aid)
+	req, err := http.NewRequest("POST", url, bytes.NewReader(v))
+	if err != nil {
+		log.Error("broadcast http.NewRequest() error(%v)", err)
+		return
+	}
+	if err = d.httpCli.Do(c, req, &res); err != nil {
+		log.Error("httpCli.Do(%s) error(%v)", url, err)
+		return
+	}
+	if res.Code != 0 {
+		err = fmt.Errorf("broadcast api failed(%d)", res.Code)
+		log.Error("broadcast(%s) res code(%d)", url, res.Code)
+	}
+	return
+}
+
+// Broadcast send dm msg in realtime.
+func (d *Dao) Broadcast(c context.Context, cid, aid int64, msg string) (err error) {
+	var (
+		res struct {
+			Code int64 `json:"code"`
+		}
+	)
+	params := url.Values{}
+	params.Set("operation", fmt.Sprint(_broadcastDmOperation))
+	params.Set("room", fmt.Sprintf(_broadcastDmRoomFmt, aid, cid))
+	params.Set("message", msg)
+	if err = d.httpCli.Post(c, d.broadcastURI(), metadata.String(c, metadata.RemoteIP), params, &res); err != nil {
+		log.Error("httpCli.Do(%s) error(%v)", d.broadcastURI(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = fmt.Errorf("broadcast api failed(%d)", res.Code)
+		log.Error("broadcast(%s) res code(%d)", d.broadcastURI(), res.Code)
+	}
+	return
+}

app/interface/main/dm2/dao/broadcast_test.go

@@ -0,0 +1,19 @@
+package dao
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestBroadcast(t *testing.T) {
+	Convey("err should be nil", t, func() {
+		var err error
+		info := []byte(fmt.Sprintf(`["%.2f,%d,%d,%d,%d,%d,%d,%s,%d","%s"]`, 1.01, 0, 25, 0xFF, 1123, 23, 0, "abc", 1, `德玛西亚万岁\\(≧▽≦)/`))
+		if err = testDao.BroadcastInGoim(c, 123, 456, info); err != nil {
+			t.Logf("testDao.Broadcast(%s) error(%v)", info, err)
+		}
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/dm2/dao/dao.go

@@ -0,0 +1,195 @@
+package dao
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/dm2/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	"go-common/library/database/bfs"
+	"go-common/library/database/elastic"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/queue/databus"
+	"go-common/library/stat/prom"
+)
+
+var (
+	errorsCount = prom.BusinessErrCount
+	missedCount = prom.CacheMiss
+	cachedCount = prom.CacheHit
+)
+
+// Dao dm dao.
+type Dao struct {
+	conf *conf.Config
+	// mysql
+	dmWriter *sql.DB
+	dmReader *sql.DB
+	dbDM     *sql.DB
+	// redis
+	dmRds       *redis.Pool
+	dmRdsExpire int32
+	// recent dm redis
+	dmRctRds    *redis.Pool
+	dmRctExpire int32
+	// segment dm redis
+	dmSegRds    *redis.Pool
+	dmSegExpire int32
+	// memcache
+	dmMC              *memcache.Pool
+	dmExpire          int32
+	subjectExpire     int32
+	historyExpire     int32
+	ajaxExpire        int32
+	dmMaskExpire      int32
+	filterMC          *memcache.Pool
+	filterMCExpire    int32
+	dmSegMC           *memcache.Pool
+	dmSegMCExpire     int32
+	dmLimiterMCExpire int32
+	// http
+	httpCli *bm.Client
+	// databus
+	databus   *databus.Databus
+	actionPub *databus.Databus
+	// elastic
+	elastic *elastic.Elastic
+	// bfsCli
+	bfsCli *bfs.BFS
+	// subtitle mc
+	subtitleMc       *memcache.Pool
+	subtitleMcExpire int32
+	subtitleCheckPub *databus.Databus
+}
+
+// New new a dao and return.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		conf: c,
+		// mysql
+		dmWriter: sql.NewMySQL(c.DB.DMWriter),
+		dmReader: sql.NewMySQL(c.DB.DMReader),
+		dbDM:     sql.NewMySQL(c.DB.DM),
+		// redis
+		dmRds:       redis.NewPool(c.Redis.DM.Config),
+		dmRdsExpire: int32(time.Duration(c.Redis.DM.Expire) / time.Second),
+		// recent dm redis
+		dmRctRds:    redis.NewPool(c.Redis.DMRct.Config),
+		dmRctExpire: int32(time.Duration(c.Redis.DMRct.Expire) / time.Second),
+		// segment dm redis
+		dmSegRds:    redis.NewPool(c.Redis.DMSeg.Config),
+		dmSegExpire: int32(time.Duration(c.Redis.DMSeg.Expire) / time.Second),
+		// memcache
+		dmMC:              memcache.NewPool(c.Memcache.DM.Config),
+		dmExpire:          int32(time.Duration(c.Memcache.DM.DMExpire) / time.Second),
+		subjectExpire:     int32(time.Duration(c.Memcache.DM.SubjectExpire) / time.Second),
+		historyExpire:     int32(time.Duration(c.Memcache.DM.HistoryExpire) / time.Second),
+		ajaxExpire:        int32(time.Duration(c.Memcache.DM.AjaxExpire) / time.Second),
+		dmMaskExpire:      int32(time.Duration(c.Memcache.DM.DMMaskExpire) / time.Second),
+		filterMC:          memcache.NewPool(c.Memcache.Filter.Config),
+		filterMCExpire:    int32(time.Duration(c.Memcache.Filter.Expire) / time.Second),
+		dmSegMC:           memcache.NewPool(c.Memcache.DMSeg.Config),
+		dmSegMCExpire:     int32(time.Duration(c.Memcache.DMSeg.DMExpire) / time.Second),
+		dmLimiterMCExpire: int32(time.Duration(c.Memcache.DMSeg.DMLimiterExpire) / time.Second),
+		// http
+		httpCli: bm.NewClient(c.HTTPCli),
+		// databus
+		databus:   databus.New(c.Databus),
+		actionPub: databus.New(c.ActionPub),
+		// elastic
+		elastic: elastic.NewElastic(c.Elastic),
+		// bfscli
+		bfsCli: bfs.New(c.Bfs.Client),
+		// subtitle MC
+		subtitleMc:       memcache.NewPool(c.Memcache.Subtitle.Config),
+		subtitleMcExpire: int32(time.Duration(c.Memcache.Subtitle.Expire) / time.Second),
+		subtitleCheckPub: databus.New(c.SubtitleCheckPub),
+	}
+	return
+}
+
+func (d *Dao) hitSubject(oid int64) int64 {
+	return oid % _subjectSharding
+}
+
+func (d *Dao) hitIndex(oid int64) int64 {
+	return oid % _indexSharding
+}
+
+func (d *Dao) hitContent(dmid int64) int64 {
+	return dmid % _contentSharding
+}
+
+// BeginBiliDMTrans begin db transaction.
+func (d *Dao) BeginBiliDMTrans(c context.Context) (*sql.Tx, error) {
+	return d.dbDM.Begin(c)
+}
+
+// Ping ping success.
+func (d *Dao) Ping(c context.Context) (err error) {
+	if err = d.dmReader.Ping(c); err != nil {
+		log.Error("d.dmReader error(%v)", err)
+		return
+	}
+	if err = d.dmWriter.Ping(c); err != nil {
+		log.Error("d.dmWriter error(%v)", err)
+		return
+	}
+	// mc
+	dmMC := d.dmMC.Get(c)
+	defer dmMC.Close()
+	if err = dmMC.Set(&memcache.Item{Key: "ping", Value: []byte("pong"), Expiration: 0}); err != nil {
+		log.Error("dmMC.Set error(%v)", err)
+		return
+	}
+	filterMC := d.filterMC.Get(c)
+	defer filterMC.Close()
+	if err = filterMC.Set(&memcache.Item{Key: "ping", Value: []byte("pong"), Expiration: 0}); err != nil {
+		log.Error("filterMC.Set error(%v)", err)
+		return
+	}
+	dmSegMC := d.dmSegMC.Get(c)
+	defer dmSegMC.Close()
+	if err = dmSegMC.Set(&memcache.Item{Key: "ping", Value: []byte("pong"), Expiration: 0}); err != nil {
+		log.Error("dmSegMC.Set error(%v)", err)
+		return
+	}
+	// dm redis
+	dmConn := d.dmRds.Get(c)
+	defer dmConn.Close()
+	if _, err = dmConn.Do("SET", "ping", "pong"); err != nil {
+		log.Error("dmConn.Do(SET) error(%v)", err)
+		return
+	}
+	rctRdsConn := d.dmRctRds.Get(c)
+	defer rctRdsConn.Close()
+	if _, err = rctRdsConn.Do("SET", "ping", "pong"); err != nil {
+		log.Error("rctRdsConn.Do(SET) error(%v)", err)
+		return
+	}
+	// segment dm redis
+	segRdsConn := d.dmSegRds.Get(c)
+	defer segRdsConn.Close()
+	if _, err = segRdsConn.Do("SET", "ping", "pong"); err != nil {
+		log.Error("segRdsConn.Do(SET) error(%v)", err)
+	}
+	return
+}
+
+// PromError prom error
+func PromError(name string) {
+	errorsCount.Incr(name)
+}
+
+// PromCacheHit prom cache hit
+func PromCacheHit(name string, v int64) {
+	cachedCount.Add(name, v)
+}
+
+// PromCacheMiss prom cache hit
+func PromCacheMiss(name string, v int64) {
+	missedCount.Add(name, v)
+}

app/interface/main/dm2/dao/dao_test.go

@@ -0,0 +1,36 @@
+package dao
+
+import (
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/dm2/conf"
+	"go-common/library/log"
+)
+
+var (
+	testDao *Dao
+	c       = context.TODO()
+)
+
+func TestMain(m *testing.M) {
+	flag.Set("app_id", "main.community.dm2")
+	flag.Set("conf_token", "41bebe87fc9df75601583db2672f7c34")
+	flag.Set("tree_id", "2291")
+	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")
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	log.Init(conf.Conf.Xlog)
+	defer log.Close()
+	testDao = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/interface/main/dm2/dao/databus.go

@@ -0,0 +1,55 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+
+	"go-common/app/interface/main/dm2/model"
+
+	"go-common/library/log"
+)
+
+// PubDatabus pub cache update message to databus.
+func (d *Dao) PubDatabus(c context.Context, tp int32, pid, oid, cnt, n, duration int64) (err error) {
+	var (
+		jobParams = &model.JobParam{
+			Type:     tp,
+			Oid:      oid,
+			Pid:      pid,
+			Cnt:      cnt,
+			Num:      n,
+			Duration: duration,
+		}
+	)
+	value, err := json.Marshal(jobParams)
+	if err != nil {
+		log.Error("json.Marshal(%v) error(%v)", jobParams, err)
+		return
+	}
+	msg := model.Action{Action: model.ActionIdx, Data: value}
+	if err = d.databus.Send(c, strconv.FormatInt(oid, 10), msg); err != nil {
+		log.Error("databus.Send(%v) error(%v)", msg, err)
+	}
+	return
+}
+
+// SendAction send action to job.
+func (d *Dao) SendAction(c context.Context, k string, act *model.Action) (err error) {
+	if err = d.actionPub.Send(c, k, act); err != nil {
+		log.Error("actionPub.Send(action:%s,data:%s) error(%v)", act.Action, act.Data, err)
+	} else {
+		log.Info("actionPub.Send(action:%s,data:%s) success", act.Action, act.Data)
+	}
+	return
+}
+
+// SendSubtitleCheck .
+func (d *Dao) SendSubtitleCheck(c context.Context, key string, msg *model.SubtitleCheckMsg) (err error) {
+	if err = d.subtitleCheckPub.Send(c, key, msg); err != nil {
+		log.Error("actionPub.Send(key:%s,msg:%+v) error(%v)", key, msg, err)
+	} else {
+		log.Error("actionPub.Send(key:%s,msg:%+v) success", key, msg)
+	}
+	return
+}

app/interface/main/dm2/dao/databus_test.go

@@ -0,0 +1,42 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"go-common/app/interface/main/dm2/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestPubDatabus(t *testing.T) {
+	var (
+		tp       int32 = 1
+		aid      int64 = 10097265
+		oid      int64 = 1508
+		cnt      int64 = 26
+		num      int64 = 1
+		duration int64 = 9031000
+		c              = context.TODO()
+	)
+	Convey("flush segment dm xml", t, func() {
+		err := testDao.PubDatabus(c, tp, aid, oid, cnt, num, duration)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestSendAction(t *testing.T) {
+	var (
+		c     = context.TODO()
+		flush = &model.Flush{Oid: 1221, Type: 1}
+	)
+	Convey("flush xml", t, func() {
+		data, err := json.Marshal(flush)
+		So(err, ShouldBeNil)
+		act := &model.Action{Action: model.ActionFlush, Data: data}
+		err = testDao.SendAction(c, fmt.Sprint(flush.Oid), act)
+		So(err, ShouldBeNil)
+	})
+}

app/interface/main/dm2/dao/mask.go

@@ -0,0 +1,44 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_updateMask = "REPLACE INTO dm_masking(cid,plat,fps,time,list) VALUES (?,?,?,?,?)"
+	_selectMask = "SELECT cid,plat,fps,time,list FROM dm_masking WHERE cid=? AND plat=?"
+)
+
+// UpdateMask replace dm_masking table for web
+func (d *Dao) UpdateMask(c context.Context, cid, maskTime int64, fps int32, plat int8, list string) (err error) {
+	if _, err = d.dbDM.Exec(c, _updateMask, cid, plat, fps, maskTime, list); err != nil {
+		log.Error("biliDM.Exec(%v, %v %v %v %v %v) error(%v)", _updateMask, cid, plat, fps, maskTime, list, err)
+	}
+	return
+}
+
+// MaskList get mask linfo
+func (d *Dao) MaskList(c context.Context, cid int64, plat int8) (m *model.Mask, err error) {
+	m = &model.Mask{}
+	var tmp string
+	row := d.dbDM.QueryRow(c, _selectMask, cid, plat)
+	if err = row.Scan(&m.Cid, &m.Plat, &m.FPS, &m.Time, &tmp); err != nil {
+		if err == sql.ErrNoRows {
+			m = nil
+			err = nil
+		} else {
+			log.Error("MaskList.rows.Scan(cid:%d plat:%d) error(%v)", cid, plat, err)
+		}
+		return
+	}
+	if tmp == "" {
+		m = nil
+		return
+	}
+	m.MaskURL = d.conf.Host.MaskCloud + tmp
+	return
+}

app/interface/main/dm2/dao/mask_test.go

@@ -0,0 +1,37 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/dm2/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestUpdateMask(t *testing.T) {
+	var (
+		c              = context.TODO()
+		cid      int64 = 2386051
+		maskTime int64 = 60
+		fps      int32 = 25
+		list           = "26777486_s0_0_1499,26777486_s1_1500_2999,26777486_s2_3000_4499,26777486_s3_4500_5999,26777486_s4_6000_7499,26777486_s5_7500_7897"
+	)
+	Convey("test update mask", t, func() {
+		err := testDao.UpdateMask(c, cid, maskTime, fps, model.MaskPlatMbl, list)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestMaskList(t *testing.T) {
+	var (
+		c         = context.TODO()
+		cid int64 = 1352
+	)
+	Convey("test mobile mask list", t, func() {
+		res, err := testDao.MaskList(c, cid, model.MaskPlatMbl)
+		t.Logf("==============%+v", res)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	})
+}

app/interface/main/dm2/dao/mc.go

@@ -0,0 +1,642 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"hash/crc32"
+	"strconv"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+var (
+	_lockvalue = []byte("1")
+)
+
+const (
+	_prefixPubLock     = "dm_pub_"
+	_prefixCharPubLock = "dm_pub_char_"
+	_prefixXML         = "dm_xml_"
+	_prefixSub         = "s_"
+	_prefixAjax        = "dm_ajax_"
+	_prefixDMJudge     = "dm_judge_%d_%d_%d"
+	_prefixDMLimit     = "dm_limit_"
+	_prefixAdvanceCmt  = "cache:AdvanceComment:%d@%d.%s"
+	_prefixAdvLock     = "adv_lock_"
+	_prefixAdvance     = "cache:AdvanceComment:"
+	_prefixHis         = "dm_his_%d_%d_%d"
+	_prefixHisIdx      = "dm_his_idx_%d_%d_%s"
+	_prefixDMMask      = "dm_mask_%d_%d_%d"
+)
+
+func keyMsgPubLock(mid, color, rnd int64, mode, fontsize int32, ip, msg string) string {
+	crcStr := fmt.Sprintf("%d_%s_%s_%d_%d_%d_%d", mid, msg, ip, fontsize, color, mode, rnd)
+	return _prefixPubLock + fmt.Sprint(crc32.ChecksumIEEE([]byte(crcStr)))
+}
+
+func keyOidPubLock(mid, oid int64, ip string) string {
+	crcStr := fmt.Sprintf("%d_%s_%d", mid, ip, oid)
+	return _prefixPubLock + fmt.Sprint(crc32.ChecksumIEEE([]byte(crcStr)))
+}
+
+func keyPubCntLock(mid, color int64, mode, fontsize int32, ip, msg string) string {
+	crcStr := fmt.Sprintf("%d_%s_%s_%d_%d_%d", mid, msg, ip, fontsize, color, mode)
+	return _prefixPubLock + fmt.Sprint(crc32.ChecksumIEEE([]byte(crcStr)))
+}
+
+func keyCharPubLock(mid, oid int64) string {
+	return _prefixCharPubLock + fmt.Sprintf("%d_%d", mid, oid)
+}
+
+func keyXML(oid int64) string {
+	return _prefixXML + strconv.FormatInt(oid, 10)
+}
+
+func keySubject(tp int32, oid int64) string {
+	return _prefixSub + fmt.Sprintf("%d_%d", tp, oid)
+}
+
+func keyAjax(oid int64) string {
+	return _prefixAjax + strconv.FormatInt(oid, 10)
+}
+
+func keyJudge(tp int8, oid, dmid int64) string {
+	return fmt.Sprintf(_prefixDMJudge, tp, oid, dmid)
+}
+
+func keyDMLimitMid(mid int64) string {
+	return _prefixDMLimit + strconv.FormatInt(mid, 10)
+}
+
+func keyAdvanceCmt(mid, oid int64, mode string) string {
+	return fmt.Sprintf(_prefixAdvanceCmt, mid, oid, mode)
+}
+
+func keyAdvLock(mid, cid int64) string {
+	return _prefixAdvLock + strconv.FormatInt(mid, 10) + "_" + strconv.FormatInt(cid, 10)
+}
+
+func keyHistory(tp int32, oid, timestamp int64) string {
+	return fmt.Sprintf(_prefixHis, tp, oid, timestamp)
+}
+
+func keyHistoryIdx(tp int32, oid int64, month string) string {
+	return fmt.Sprintf(_prefixHisIdx, tp, oid, month)
+}
+
+func keyDMMask(tp int32, oid int64, plat int8) string {
+	return fmt.Sprintf(_prefixDMMask, tp, oid, plat)
+}
+
+// SubjectCache get subject from memcache.
+func (d *Dao) SubjectCache(c context.Context, tp int32, oid int64) (sub *model.Subject, err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keySubject(tp, oid)
+		rp   *memcache.Item
+	)
+	defer conn.Close()
+	if rp, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			PromCacheMiss("dm_subject", 1)
+			sub = nil
+			err = nil
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	sub = &model.Subject{}
+	PromCacheHit("dm_subject", 1)
+	if err = conn.Scan(rp, &sub); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// SubjectsCache multi get subject from memcache.
+func (d *Dao) SubjectsCache(c context.Context, tp int32, oids []int64) (cached map[int64]*model.Subject, missed []int64, err error) {
+	var (
+		conn   = d.dmMC.Get(c)
+		keys   []string
+		oidMap = make(map[string]int64)
+	)
+	cached = make(map[int64]*model.Subject)
+	defer conn.Close()
+	for _, oid := range oids {
+		k := keySubject(tp, oid)
+		if _, ok := oidMap[k]; !ok {
+			keys = append(keys, k)
+			oidMap[k] = oid
+		}
+	}
+	rs, err := conn.GetMulti(keys)
+	if err != nil {
+		log.Error("conn.GetMulti(%v) error(%v)", keys, err)
+		return
+	}
+	for k, r := range rs {
+		sub := &model.Subject{}
+		if err = conn.Scan(r, sub); err != nil {
+			log.Error("conn.Scan(%s) error(%v)", r.Value, err)
+			err = nil
+			continue
+		}
+		cached[oidMap[k]] = sub
+		// delete hit key
+		delete(oidMap, k)
+	}
+	// missed key
+	missed = make([]int64, 0, len(oidMap))
+	for _, oid := range oidMap {
+		missed = append(missed, oid)
+	}
+	PromCacheHit("dm_subjects", int64(len(cached)))
+	PromCacheMiss("dm_subjects", int64(len(missed)))
+	return
+}
+
+// AddSubjectCache add subject cache.
+func (d *Dao) AddSubjectCache(c context.Context, sub *model.Subject) (err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keySubject(sub.Type, sub.Oid)
+	)
+	defer conn.Close()
+	item := &memcache.Item{
+		Key:        key,
+		Object:     sub,
+		Flags:      memcache.FlagJSON,
+		Expiration: d.subjectExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// DelXMLCache delete xml content.
+func (d *Dao) DelXMLCache(c context.Context, oid int64) (err error) {
+	conn := d.dmMC.Get(c)
+	if err = conn.Delete(keyXML(oid)); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Delete(%s) error(%v)", keyXML(oid), err)
+		}
+	}
+	conn.Close()
+	return
+}
+
+// AddXMLCache add xml content to memcache.
+func (d *Dao) AddXMLCache(c context.Context, oid int64, value []byte) (err error) {
+	conn := d.dmMC.Get(c)
+	defer conn.Close()
+	item := &memcache.Item{
+		Key:        keyXML(oid),
+		Value:      value,
+		Expiration: d.dmExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%s) error(%v)", keyXML(oid), err)
+	}
+	return
+}
+
+// XMLCache get xml content.
+func (d *Dao) XMLCache(c context.Context, oid int64) (data []byte, err error) {
+	key := keyXML(oid)
+	conn := d.dmMC.Get(c)
+	defer conn.Close()
+	item, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			PromCacheMiss("dm_xml", 1)
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("dm_xml", 1)
+	data = item.Value
+	return
+}
+
+// AjaxDMCache get ajax dm from memcache.
+func (d *Dao) AjaxDMCache(c context.Context, oid int64) (msgs []string, err error) {
+	conn := d.dmMC.Get(c)
+	defer conn.Close()
+	key := keyAjax(oid)
+	msgs = make([]string, 0)
+	item, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			PromCacheMiss("dm_ajax", 1)
+		} else {
+			log.Error("conn.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("dm_ajax", 1)
+	if err = conn.Scan(item, &msgs); err != nil {
+		log.Error("conn.Scan(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// AddAjaxDMCache set ajax dm to memcache.
+func (d *Dao) AddAjaxDMCache(c context.Context, oid int64, msgs []string) (err error) {
+	conn := d.dmMC.Get(c)
+	defer conn.Close()
+	key := keyAjax(oid)
+	item := &memcache.Item{Key: key, Object: msgs, Flags: memcache.FlagJSON, Expiration: d.ajaxExpire}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// SetDMJudgeCache dm fengjiwei list
+func (d *Dao) SetDMJudgeCache(c context.Context, tp int8, oid, dmid int64, l *model.JudgeDMList) (err error) {
+	key := keyJudge(tp, oid, dmid)
+	conn := d.dmMC.Get(c)
+	defer conn.Close()
+	item := memcache.Item{
+		Key:        key,
+		Object:     l,
+		Expiration: 86400 * 30,
+		Flags:      memcache.FlagJSON,
+	}
+	if err = conn.Set(&item); err != nil {
+		log.Error("DMJudge:mc.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// DMJudgeCache memcache cache of dm judge list.
+func (d *Dao) DMJudgeCache(c context.Context, tp int8, oid, dmid int64) (l *model.JudgeDMList, err error) {
+	key := keyJudge(tp, oid, dmid)
+	conn := d.dmMC.Get(c)
+	defer conn.Close()
+	item, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			l = nil
+			PromCacheMiss("dm_judge", 1)
+		} else {
+			log.Error("mc.Get(key:%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("dm_judge", 1)
+	if err = conn.Scan(item, &l); err != nil {
+		log.Error("conn.Scan(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// AddMsgPubLock set publock into memcache
+func (d *Dao) AddMsgPubLock(c context.Context, mid, color, rnd int64, mode, fontsize int32, ip, msg string) (err error) {
+	conn := d.dmMC.Get(c)
+	item := memcache.Item{
+		Key:        keyMsgPubLock(mid, color, rnd, mode, fontsize, ip, msg),
+		Value:      _lockvalue,
+		Expiration: 300,
+		Flags:      memcache.FlagRAW,
+	}
+	if err = conn.Set(&item); err != nil {
+		log.Error("mc.Set(%v) error(%v)", item, err)
+	}
+	conn.Close()
+	return
+}
+
+// MsgPublock get publock
+func (d *Dao) MsgPublock(c context.Context, mid, color, rnd int64, mode, fontsize int32, ip, msg string) (cached bool, err error) {
+	conn := d.dmMC.Get(c)
+	defer conn.Close()
+	key := keyMsgPubLock(mid, color, rnd, mode, fontsize, ip, msg)
+	if _, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			cached = false
+			err = nil
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	cached = true
+	return
+}
+
+// AddOidPubLock set publock into memcache
+func (d *Dao) AddOidPubLock(c context.Context, mid, oid int64, ip string) (err error) {
+	conn := d.dmMC.Get(c)
+	item := memcache.Item{
+		Key:        keyOidPubLock(mid, oid, ip),
+		Value:      _lockvalue,
+		Expiration: 4,
+		Flags:      memcache.FlagRAW,
+	}
+	if err = conn.Set(&item); err != nil {
+		log.Error("mc.Set(%v) error(%v)", item, err)
+	}
+	conn.Close()
+	return
+}
+
+// OidPubLock get publock
+func (d *Dao) OidPubLock(c context.Context, mid, oid int64, ip string) (cached bool, err error) {
+	conn := d.dmMC.Get(c)
+	defer conn.Close()
+	key := keyOidPubLock(mid, oid, ip)
+	if _, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			cached = false
+			err = nil
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	cached = true
+	return
+}
+
+// AddDMLimitCache add Dmlimit in cache
+func (d *Dao) AddDMLimitCache(c context.Context, mid int64, limiter *model.Limiter) (err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keyDMLimitMid(mid)
+	)
+	defer conn.Close()
+	item := &memcache.Item{
+		Key:        key,
+		Object:     limiter,
+		Flags:      memcache.FlagJSON,
+		Expiration: 600,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// DMLimitCache get dm limit from memcache.
+func (d *Dao) DMLimitCache(c context.Context, mid int64) (limiter *model.Limiter, err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keyDMLimitMid(mid)
+		rp   *memcache.Item
+	)
+	limiter = &model.Limiter{}
+	defer conn.Close()
+	if rp, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			limiter = nil
+			err = nil
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	if err = conn.Scan(rp, &limiter); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// AddAdvanceCmtCache return
+func (d *Dao) AddAdvanceCmtCache(c context.Context, oid, mid int64, mode string, adv *model.AdvanceCmt) (err error) {
+	var (
+		conn = d.filterMC.Get(c)
+		key  = keyAdvanceCmt(mid, oid, mode)
+	)
+	defer conn.Close()
+	item := &memcache.Item{
+		Key:        key,
+		Object:     adv,
+		Flags:      memcache.FlagJSON,
+		Expiration: d.filterMCExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// AdvanceCmtCache return advance comment from memcache.
+func (d *Dao) AdvanceCmtCache(c context.Context, oid, mid int64, mode string) (adv *model.AdvanceCmt, err error) {
+	var (
+		conn = d.filterMC.Get(c)
+		key  = keyAdvanceCmt(mid, oid, mode)
+		rp   *memcache.Item
+	)
+	defer conn.Close()
+	adv = &model.AdvanceCmt{}
+	if rp, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			adv = nil
+			err = nil
+			PromCacheMiss("dm_advance", 1)
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("dm_advance", 1)
+	if err = conn.Scan(rp, &adv); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// AddAdvanceLock 购买高级弹幕锁
+func (d *Dao) AddAdvanceLock(c context.Context, mid, cid int64) (succeed bool) {
+	var (
+		key  = keyAdvLock(mid, cid)
+		conn = d.filterMC.Get(c)
+	)
+	defer conn.Close()
+	item := &memcache.Item{
+		Key:        key,
+		Value:      []byte("3"),
+		Expiration: 60,
+	}
+	if err := conn.Add(item); err != nil {
+		succeed = false
+		log.Error("conn.Add(%s) error(%v)", key, err)
+	} else {
+		succeed = true
+	}
+	return
+}
+
+// DelAdvanceLock 删除购买高级弹幕锁
+func (d *Dao) DelAdvanceLock(c context.Context, mid, cid int64) (err error) {
+	var (
+		key  = keyAdvLock(mid, cid)
+		conn = d.filterMC.Get(c)
+	)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("conn.Delete(%s) error(%v)", key, err)
+		}
+	}
+	conn.Close()
+	return
+}
+
+// DelAdvCache delete from cache.
+func (d *Dao) DelAdvCache(c context.Context, mid, cid int64, mode string) (err error) {
+	var (
+		key = _prefixAdvance + strconv.FormatInt(mid, 10) + "@" + strconv.FormatInt(cid, 10) + "." + mode
+	)
+	conn := d.filterMC.Get(c)
+	err = conn.Delete(key)
+	conn.Close()
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Delete(%s) error(%v)", key, err)
+		}
+	}
+	return
+}
+
+// AddHistoryCache add dm history to memcache.
+func (d *Dao) AddHistoryCache(c context.Context, tp int32, oid, timestamp int64, value []byte) (err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keyHistory(tp, oid, timestamp)
+	)
+	defer conn.Close()
+	item := &memcache.Item{
+		Key:        key,
+		Value:      value,
+		Expiration: d.historyExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%s) error(%v)", key, err)
+	}
+	return
+}
+
+// HistoryCache history cache.
+func (d *Dao) HistoryCache(c context.Context, tp int32, oid, timestamp int64) (data []byte, err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keyHistory(tp, oid, timestamp)
+	)
+	defer conn.Close()
+	item, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			PromCacheMiss("dm_history", 1)
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("dm_history", 1)
+	data = item.Value
+	return
+}
+
+// AddHisIdxCache add dm history date index to memcache.
+func (d *Dao) AddHisIdxCache(c context.Context, tp int32, oid int64, month string, dates []string) (err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keyHistoryIdx(tp, oid, month)
+	)
+	defer conn.Close()
+	item := &memcache.Item{
+		Key:        key,
+		Object:     dates,
+		Flags:      memcache.FlagJSON,
+		Expiration: d.historyExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%s) error(%v)", key, err)
+	}
+	return
+}
+
+// HistoryIdxCache get history date index.
+func (d *Dao) HistoryIdxCache(c context.Context, tp int32, oid int64, month string) (dates []string, err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keyHistoryIdx(tp, oid, month)
+	)
+	defer conn.Close()
+	item, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			PromCacheMiss("dm_history_index", 1)
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("dm_history_index", 1)
+	if err = conn.Scan(item, &dates); err != nil {
+		log.Error("conn.Scan(%+v) error(%v)", item, err)
+	}
+	return
+}
+
+// DMMaskCache get dm mask cache
+func (d *Dao) DMMaskCache(c context.Context, tp int32, oid int64, plat int8) (mask *model.Mask, err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keyDMMask(tp, oid, plat)
+		item *memcache.Item
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			mask = nil
+			PromCacheMiss("dm_mask", 1)
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	mask = &model.Mask{}
+	PromCacheHit("dm_mask", 1)
+	if err = conn.Scan(item, &mask); err != nil {
+		log.Error("conn.Scan(%+v) error(%v)", item, err)
+	}
+	return
+}
+
+// AddMaskCache add dm mask cache
+func (d *Dao) AddMaskCache(c context.Context, tp int32, mask *model.Mask) (err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keyDMMask(tp, mask.Cid, mask.Plat)
+	)
+	defer conn.Close()
+	item := &memcache.Item{
+		Key:        key,
+		Object:     mask,
+		Flags:      memcache.FlagJSON,
+		Expiration: d.dmMaskExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%+v) error(%v)", item, err)
+	}
+	return
+}

app/interface/main/dm2/dao/mc_filter.go

@@ -0,0 +1,217 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_prefixUpFilter     = "filter_up_"
+	_prefixUserFilter   = "filter_user_"
+	_prefixGlobalFilter = "filter_global"
+)
+
+func keyUserFilter(mid int64) string {
+	return _prefixUserFilter + strconv.FormatInt(mid, 10)
+}
+
+func keyUpFilter(mid int64) string {
+	return _prefixUpFilter + strconv.FormatInt(mid, 10)
+}
+
+func keyGlobalFilter() string {
+	return _prefixGlobalFilter
+}
+
+// AddUserFilterCache set user filters into cache.
+func (d *Dao) AddUserFilterCache(c context.Context, mid int64, data []*model.UserFilter) (err error) {
+	bs, err := json.Marshal(data)
+	if err != nil {
+		log.Error("json.Marshal() error(%v)", err)
+		return
+	}
+	key := keyUserFilter(mid)
+	conn := d.filterMC.Get(c)
+	item := &memcache.Item{
+		Key:        key,
+		Value:      bs,
+		Expiration: d.filterMCExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", item, err)
+	}
+	conn.Close()
+	return
+}
+
+// DelUserFilterCache delete user filters from cache.
+func (d *Dao) DelUserFilterCache(c context.Context, mid int64) (err error) {
+	var (
+		key  = keyUserFilter(mid)
+		conn = d.filterMC.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Delete(%s) error(%v)", key, err)
+		}
+	}
+	return
+}
+
+// UserFilterCache get user filters from cache.
+func (d *Dao) UserFilterCache(c context.Context, mid int64) (data []*model.UserFilter, err error) {
+	var (
+		key  = keyUserFilter(mid)
+		conn = d.filterMC.Get(c)
+		item *memcache.Item
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			data = nil
+			PromCacheMiss("user_filter", 1)
+		} else {
+			log.Error("memcache.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("user_filter", 1)
+	if e := json.Unmarshal(item.Value, &data); e != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", item.Value, e)
+	}
+	return
+}
+
+// AddUpFilterCache add upper filter cache.
+func (d *Dao) AddUpFilterCache(c context.Context, mid int64, data []*model.UpFilter) (err error) {
+	var (
+		conn = d.filterMC.Get(c)
+		key  = keyUpFilter(mid)
+	)
+	defer conn.Close()
+	item := &memcache.Item{
+		Key:        key,
+		Object:     data,
+		Flags:      memcache.FlagJSON | memcache.FlagGzip,
+		Expiration: d.filterMCExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// DelUpFilterCache delete up filters from cache.
+func (d *Dao) DelUpFilterCache(c context.Context, mid int64) (err error) {
+	key := keyUpFilter(mid)
+	conn := d.filterMC.Get(c)
+	err = conn.Delete(key)
+	conn.Close()
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Delete(%s) error(%v)", key, err)
+		}
+	}
+	return
+}
+
+// UpFilterCache get user filter from memcache.
+func (d *Dao) UpFilterCache(c context.Context, mid int64) (data []*model.UpFilter, err error) {
+	var (
+		conn = d.filterMC.Get(c)
+		key  = keyUpFilter(mid)
+		rp   *memcache.Item
+	)
+	defer conn.Close()
+	data = make([]*model.UpFilter, 0)
+	if rp, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			PromCacheMiss("upper_filter", 1)
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("upper_filter", 1)
+	if err = conn.Scan(rp, &data); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// AddGlobalFilterCache set global rules into cache.
+func (d *Dao) AddGlobalFilterCache(c context.Context, data []*model.GlobalFilter) (err error) {
+	var (
+		value []byte
+		key   = keyGlobalFilter()
+		conn  = d.filterMC.Get(c)
+	)
+	defer conn.Close()
+	if value, err = json.Marshal(data); err != nil {
+		log.Error("json.Marshal(%v) error(%v)", data, err)
+		return
+	}
+	item := &memcache.Item{
+		Key:        key,
+		Value:      value,
+		Expiration: d.filterMCExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("memcache.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// DelGlobalFilterCache delete global rules from cache.
+func (d *Dao) DelGlobalFilterCache(c context.Context) (err error) {
+	var (
+		key  = keyGlobalFilter()
+		conn = d.filterMC.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Delete(%s) error(%v)", key, err)
+		}
+	}
+	return
+}
+
+// GlobalFilterCache get up filters from cache.
+func (d *Dao) GlobalFilterCache(c context.Context) (data []*model.GlobalFilter, err error) {
+	var (
+		key  = keyGlobalFilter()
+		conn = d.filterMC.Get(c)
+		item *memcache.Item
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			data = nil
+			PromCacheMiss("global_filter", 1)
+		} else {
+			log.Error("memcache.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("global_filter", 1)
+	if e := json.Unmarshal(item.Value, &data); e != nil {
+		log.Error("json.Unmarshal(%s) error(%v)", item.Value, e)
+	}
+	return
+}

app/interface/main/dm2/dao/mc_filter_test.go

@@ -0,0 +1,178 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/interface/main/dm2/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaokeyUserFilter(t *testing.T) {
+	convey.Convey("keyUserFilter", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyUserFilter(mid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyUpFilter(t *testing.T) {
+	convey.Convey("keyUpFilter", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyUpFilter(mid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyGlobalFilter(t *testing.T) {
+	convey.Convey("keyGlobalFilter", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyGlobalFilter()
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddUserFilterCache(t *testing.T) {
+	convey.Convey("AddUserFilterCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mid  = int64(0)
+			data = []*model.UserFilter{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddUserFilterCache(c, mid, data)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelUserFilterCache(t *testing.T) {
+	convey.Convey("DelUserFilterCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelUserFilterCache(c, mid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUserFilterCache(t *testing.T) {
+	convey.Convey("UserFilterCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UserFilterCache(c, mid)
+		})
+	})
+}
+
+func TestDaoAddUpFilterCache(t *testing.T) {
+	convey.Convey("AddUpFilterCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mid  = int64(0)
+			data = []*model.UpFilter{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddUpFilterCache(c, mid, data)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelUpFilterCache(t *testing.T) {
+	convey.Convey("DelUpFilterCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelUpFilterCache(c, mid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpFilterCache(t *testing.T) {
+	convey.Convey("UpFilterCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			data, err := testDao.UpFilterCache(c, mid)
+			ctx.Convey("Then err should be nil.data should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(data, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddGlobalFilterCache(t *testing.T) {
+	convey.Convey("AddGlobalFilterCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			data = []*model.GlobalFilter{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddGlobalFilterCache(c, data)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelGlobalFilterCache(t *testing.T) {
+	convey.Convey("DelGlobalFilterCache", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelGlobalFilterCache(c)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGlobalFilterCache(t *testing.T) {
+	convey.Convey("GlobalFilterCache", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.GlobalFilterCache(c)
+		})
+	})
+}

app/interface/main/dm2/dao/mc_limiter.go

@@ -0,0 +1,61 @@
+package dao
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_prefixDmDailyLimit = "dm_daily_limit_"
+)
+
+func keyDmDailyLimit(mid int64) string {
+	return _prefixDmDailyLimit + strconv.FormatInt(mid, 10)
+}
+
+// SetDmDailyLimitCache .
+func (d *Dao) SetDmDailyLimitCache(c context.Context, mid int64, limiter *model.DailyLimiter) (err error) {
+	var (
+		conn = d.dmSegMC.Get(c)
+		key  = keyDmDailyLimit(mid)
+	)
+	defer conn.Close()
+	item := &memcache.Item{
+		Key:        key,
+		Object:     limiter,
+		Flags:      memcache.FlagJSON,
+		Expiration: d.dmLimiterMCExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// GetDmDailyLimitCache .
+func (d *Dao) GetDmDailyLimitCache(c context.Context, mid int64) (limiter *model.DailyLimiter, err error) {
+	var (
+		conn = d.dmSegMC.Get(c)
+		key  = keyDmDailyLimit(mid)
+		rp   *memcache.Item
+	)
+	defer conn.Close()
+	if rp, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			limiter = nil
+			err = nil
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	limiter = &model.DailyLimiter{}
+	if err = conn.Scan(rp, &limiter); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}

app/interface/main/dm2/dao/mc_limiter_test.go

@@ -0,0 +1,55 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/interface/main/dm2/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaokeyDmDailyLimit(t *testing.T) {
+	convey.Convey("keyDmDailyLimit", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyDmDailyLimit(mid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSetDmDailyLimitCache(t *testing.T) {
+	convey.Convey("SetDmDailyLimitCache", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			mid     = int64(0)
+			limiter = &model.DailyLimiter{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.SetDmDailyLimitCache(c, mid, limiter)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGetDmDailyLimitCache(t *testing.T) {
+	convey.Convey("GetDmDailyLimitCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			limiter, err := testDao.GetDmDailyLimitCache(c, mid)
+			ctx.Convey("Then err should be nil.limiter should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(limiter, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/interface/main/dm2/dao/mc_seg.go

@@ -0,0 +1,153 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_keyDuration = "d_" // video duration
+	_keySegMC    = "sg_%d_%d_%d_%d"
+)
+
+func keyXMLSeg(tp int32, oid, cnt, num int64) string {
+	return fmt.Sprintf("%d_%d_%d_%d", tp, oid, cnt, num)
+}
+
+func keySegMC(tp int32, oid, total, num int64) string {
+	return fmt.Sprintf(_keySegMC, tp, oid, total, num)
+}
+
+// keyDuration return video duration key.
+func keyDuration(oid int64) string {
+	return _keyDuration + strconv.FormatInt(oid, 10)
+}
+
+// XMLSegCache get dm segment xml content from memcache.
+func (d *Dao) XMLSegCache(c context.Context, tp int32, oid, cnt, num int64) (res []byte, err error) {
+	var (
+		conn = d.dmMC.Get(c)
+		key  = keyXMLSeg(tp, oid, cnt, num)
+		rp   *memcache.Item
+	)
+	defer conn.Close()
+	if rp, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			PromCacheMiss("dm_xml_seg", 1)
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("dm_xml_seg", 1)
+	if err = conn.Scan(rp, &res); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// SetXMLSegCache set dm xml content into memcache.
+func (d *Dao) SetXMLSegCache(c context.Context, tp int32, oid, cnt, num int64, value []byte) (err error) {
+	key := keyXMLSeg(tp, oid, cnt, num)
+	conn := d.dmMC.Get(c)
+	item := memcache.Item{
+		Key:        key,
+		Value:      value,
+		Expiration: d.dmExpire,
+		Flags:      memcache.FlagRAW,
+	}
+	if err = conn.Set(&item); err != nil {
+		log.Error("mc.Set(%v) error(%v)", item, err)
+	}
+	conn.Close()
+	return
+}
+
+// DurationCache return duration of video.
+func (d *Dao) DurationCache(c context.Context, oid int64) (duration int64, err error) {
+	var (
+		key  = keyDuration(oid)
+		conn = d.dmMC.Get(c)
+		item *memcache.Item
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			duration = model.NotFound
+			err = nil
+			PromCacheMiss("video_duration", 1)
+		} else {
+			log.Error("conn.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	PromCacheHit("video_duration", 1)
+	if duration, err = strconv.ParseInt(string(item.Value), 10, 64); err != nil {
+		log.Error("strconv.ParseInt(%s) error(%v)", item.Value, err)
+	}
+	return
+}
+
+// SetDurationCache set video duration to redis.
+func (d *Dao) SetDurationCache(c context.Context, oid, duration int64) (err error) {
+	key := keyDuration(oid)
+	conn := d.dmMC.Get(c)
+	item := memcache.Item{
+		Key:        key,
+		Value:      []byte(fmt.Sprint(duration)),
+		Expiration: d.dmExpire,
+		Flags:      memcache.FlagRAW,
+	}
+	if err = conn.Set(&item); err != nil {
+		log.Error("mc.Set(%v) error(%v)", item, err)
+	}
+	conn.Close()
+	return
+}
+
+// SetDMSegCache set segment dm to cache.
+func (d *Dao) SetDMSegCache(c context.Context, tp int32, oid, total, num int64, dmSeg *model.DMSeg) (err error) {
+	key := keySegMC(tp, oid, total, num)
+	conn := d.dmSegMC.Get(c)
+	item := memcache.Item{
+		Key:        key,
+		Object:     dmSeg,
+		Expiration: d.dmSegMCExpire,
+		Flags:      memcache.FlagProtobuf | memcache.FlagGzip,
+	}
+	if err = conn.Set(&item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	conn.Close()
+	return
+}
+
+// DMSegCache dm segment pb cache.
+func (d *Dao) DMSegCache(c context.Context, tp int32, oid, total, num int64) (dmSeg *model.DMSeg, err error) {
+	var (
+		key  = keySegMC(tp, oid, total, num)
+		conn = d.dmSegMC.Get(c)
+		item *memcache.Item
+	)
+	dmSeg = new(model.DMSeg)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			dmSeg = nil
+		} else {
+			log.Error("mc.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	if err = conn.Scan(item, dmSeg); err != nil {
+		log.Error("conn.Scan() error(%v)", err)
+	}
+	return
+}

app/interface/main/dm2/dao/mc_seg_test.go

@@ -0,0 +1,66 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/dm2/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestSetXMLSegCache(t *testing.T) {
+	Convey("", t, func() {
+		err := testDao.SetXMLSegCache(context.TODO(), model.SubTypeVideo, 1221, 1, 1, []byte("test"))
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestXMLSegCache(t *testing.T) {
+	Convey("", t, func() {
+		_, err := testDao.XMLSegCache(context.TODO(), model.SubTypeVideo, 1221, 1, 1)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDurationCache(t *testing.T) {
+	var (
+		oid int64 = 1508
+		c         = context.TODO()
+	)
+	Convey("", t, func() {
+		_, err := testDao.DurationCache(c, oid)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestSetDurationCache(t *testing.T) {
+	var (
+		oid      int64 = 1508
+		duration int64 = 9031 * 1000
+		c              = context.TODO()
+	)
+	Convey("", t, func() {
+		err := testDao.SetDurationCache(c, oid, duration)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestSetDMSegCache(t *testing.T) {
+	Convey("set dm segment cache, error should be nil", t, func() {
+		dmseg := new(model.DMSeg)
+		dmseg.Elems = append(dmseg.Elems, &model.Elem{Content: "dm msg"})
+		err := testDao.SetDMSegCache(c, 1, 1221, 1, 1, dmseg)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestDMSegCache(t *testing.T) {
+	Convey("get dm segment cache", t, func() {
+		dmseg, err := testDao.DMSegCache(c, 1, 1221, 1, 1)
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("%+v", dmseg)
+	})
+}

app/interface/main/dm2/dao/mc_subtitle.go

@@ -0,0 +1,361 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_fmtSubtitle          = "s_subtitle_%d_%d"
+	_fmtVideoSubtitle     = "s_video_%d_%d"
+	_fmtSubtitleDraft     = "s_draft_%v_%v_%v_%v"
+	_fmtSubtitleSubject   = "s_subtitle_allow_%d"
+	_fmtSubtitleReportTag = "s_subtitle_report_%d_%d" // s_subtitle_report_bid_rid
+
+)
+
+func (d *Dao) subtitleKey(oid int64, subtitleID int64) string {
+	return fmt.Sprintf(_fmtSubtitle, oid, subtitleID)
+}
+
+func (d *Dao) subtitleVideoKey(oid int64, tp int32) string {
+	return fmt.Sprintf(_fmtVideoSubtitle, oid, tp)
+}
+
+func (d *Dao) subtitleDraftKey(oid int64, tp int32, mid int64, lan uint8) string {
+	return fmt.Sprintf(_fmtSubtitleDraft, oid, tp, mid, lan)
+}
+
+func (d *Dao) subtitleSubjectKey(aid int64) string {
+	return fmt.Sprintf(_fmtSubtitleSubject, aid)
+}
+
+func (d *Dao) subtitleReportTagKey(bid, rid int64) string {
+	return fmt.Sprintf(_fmtSubtitleReportTag, bid, rid)
+}
+
+// SetVideoSubtitleCache .
+func (d *Dao) SetVideoSubtitleCache(c context.Context, oid int64, tp int32, res *model.VideoSubtitleCache) (err error) {
+	var (
+		item *memcache.Item
+		conn = d.subtitleMc.Get(c)
+		key  = d.subtitleVideoKey(oid, tp)
+	)
+	defer conn.Close()
+	item = &memcache.Item{
+		Key:        key,
+		Object:     res,
+		Flags:      memcache.FlagJSON | memcache.FlagGzip,
+		Expiration: d.subtitleMcExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// VideoSubtitleCache .
+func (d *Dao) VideoSubtitleCache(c context.Context, oid int64, tp int32) (res *model.VideoSubtitleCache, err error) {
+	var (
+		item *memcache.Item
+		conn = d.subtitleMc.Get(c)
+		key  = d.subtitleVideoKey(oid, tp)
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			res = nil
+			return
+		}
+		log.Error("memcache.Get(%s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Scan(item, &res); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// DelVideoSubtitleCache .
+func (d *Dao) DelVideoSubtitleCache(c context.Context, oid int64, tp int32) (err error) {
+	var (
+		key  = d.subtitleVideoKey(oid, tp)
+		conn = d.subtitleMc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Delete(%s) error(%v)", key, err)
+		}
+	}
+	return
+}
+
+// SubtitleDraftCache .
+func (d *Dao) SubtitleDraftCache(c context.Context, oid int64, tp int32, mid int64, lan uint8) (subtitle *model.Subtitle, err error) {
+	var (
+		item *memcache.Item
+		conn = d.subtitleMc.Get(c)
+		key  = d.subtitleDraftKey(oid, tp, mid, lan)
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	if err = conn.Scan(item, &subtitle); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// SetSubtitleDraftCache .
+func (d *Dao) SetSubtitleDraftCache(c context.Context, subtitle *model.Subtitle) (err error) {
+	var (
+		item *memcache.Item
+		conn = d.subtitleMc.Get(c)
+		key  = d.subtitleDraftKey(subtitle.Oid, subtitle.Type, subtitle.Mid, subtitle.Lan)
+	)
+	defer conn.Close()
+	item = &memcache.Item{
+		Key:        key,
+		Object:     subtitle,
+		Flags:      memcache.FlagJSON | memcache.FlagGzip,
+		Expiration: d.subtitleMcExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// DelSubtitleDraftCache .
+func (d *Dao) DelSubtitleDraftCache(c context.Context, oid int64, tp int32, mid int64, lan uint8) (err error) {
+	var (
+		key  = d.subtitleDraftKey(oid, tp, mid, lan)
+		conn = d.subtitleMc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Delete(%s) error(%v)", key, err)
+		}
+	}
+	return
+}
+
+// SubtitlesCache .
+func (d *Dao) SubtitlesCache(c context.Context, oid int64, subtitleIds []int64) (res map[int64]*model.Subtitle, missed []int64, err error) {
+	var (
+		conn          = d.subtitleMc.Get(c)
+		keys          []string
+		subtitleIDMap = make(map[string]int64)
+	)
+	res = make(map[int64]*model.Subtitle)
+	defer conn.Close()
+	for _, subtitleID := range subtitleIds {
+		k := d.subtitleKey(oid, subtitleID)
+		if _, ok := subtitleIDMap[k]; !ok {
+			keys = append(keys, k)
+			subtitleIDMap[k] = subtitleID
+		}
+	}
+	rs, err := conn.GetMulti(keys)
+	if err != nil {
+		log.Error("conn.GetMulti(%v) error(%v)", keys, err)
+		return
+	}
+	for k, r := range rs {
+		st := &model.Subtitle{}
+		if err = conn.Scan(r, st); err != nil {
+			log.Error("conn.Scan(%s) error(%v)", r.Value, err)
+			err = nil
+			continue
+		}
+		res[subtitleIDMap[k]] = st
+		// delete hit key
+		delete(subtitleIDMap, k)
+	}
+	// missed key
+	missed = make([]int64, 0, len(subtitleIDMap))
+	for _, subtitleID := range subtitleIDMap {
+		missed = append(missed, subtitleID)
+	}
+	return
+}
+
+// SubtitleCache .
+func (d *Dao) SubtitleCache(c context.Context, oid int64, subtitleID int64) (subtitle *model.Subtitle, err error) {
+	var (
+		item *memcache.Item
+		conn = d.subtitleMc.Get(c)
+		key  = d.subtitleKey(oid, subtitleID)
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	if err = conn.Scan(item, &subtitle); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// SetSubtitleCache .
+func (d *Dao) SetSubtitleCache(c context.Context, subtitle *model.Subtitle) (err error) {
+	var (
+		item *memcache.Item
+		conn = d.subtitleMc.Get(c)
+		key  = d.subtitleKey(subtitle.Oid, subtitle.ID)
+	)
+	defer conn.Close()
+	item = &memcache.Item{
+		Key:        key,
+		Object:     subtitle,
+		Flags:      memcache.FlagJSON | memcache.FlagGzip,
+		Expiration: d.subtitleMcExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// DelSubtitleCache .
+func (d *Dao) DelSubtitleCache(c context.Context, oid int64, subtitleID int64) (err error) {
+	var (
+		key  = d.subtitleKey(oid, subtitleID)
+		conn = d.subtitleMc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Delete(%s) error(%v)", key, err)
+		}
+	}
+	return
+}
+
+// SetSubtitleSubjectCache .
+func (d *Dao) SetSubtitleSubjectCache(c context.Context, subtitleSubject *model.SubtitleSubject) (err error) {
+	var (
+		key  = d.subtitleSubjectKey(subtitleSubject.Aid)
+		conn = d.subtitleMc.Get(c)
+		item *memcache.Item
+	)
+	defer conn.Close()
+	item = &memcache.Item{
+		Key:        key,
+		Object:     subtitleSubject,
+		Flags:      memcache.FlagJSON | memcache.FlagGzip,
+		Expiration: d.subtitleMcExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// SubtitleSubjectCache .
+func (d *Dao) SubtitleSubjectCache(c context.Context, aid int64) (subtitleSubject *model.SubtitleSubject, err error) {
+	var (
+		item *memcache.Item
+		conn = d.subtitleMc.Get(c)
+		key  = d.subtitleSubjectKey(aid)
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	if err = conn.Scan(item, &subtitleSubject); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// DelSubtitleSubjectCache .
+func (d *Dao) DelSubtitleSubjectCache(c context.Context, aid int64) (err error) {
+	var (
+		key  = d.subtitleSubjectKey(aid)
+		conn = d.subtitleMc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Delete(%s) error(%v)", key, err)
+		}
+	}
+	return
+}
+
+// SubtitleWorlFlowTagCache .
+func (d *Dao) SubtitleWorlFlowTagCache(c context.Context, bid, rid int64) (data []*model.WorkFlowTag, err error) {
+	var (
+		item *memcache.Item
+		key  = d.subtitleReportTagKey(bid, rid)
+		conn = d.subtitleMc.Get(c)
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	if err = conn.Scan(item, &data); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// SetSubtitleWorlFlowTagCache .
+func (d *Dao) SetSubtitleWorlFlowTagCache(c context.Context, bid, rid int64, data []*model.WorkFlowTag) (err error) {
+	var (
+		key  = d.subtitleReportTagKey(bid, rid)
+		conn = d.subtitleMc.Get(c)
+		item *memcache.Item
+	)
+	defer conn.Close()
+	if len(data) == 0 {
+		return
+	}
+	item = &memcache.Item{
+		Key:        key,
+		Object:     data,
+		Flags:      memcache.FlagJSON | memcache.FlagGzip,
+		Expiration: d.subtitleMcExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}

app/interface/main/dm2/dao/mc_subtitle_test.go

@@ -0,0 +1,321 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/interface/main/dm2/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaosubtitleKey(t *testing.T) {
+	convey.Convey("subtitleKey", t, func(ctx convey.C) {
+		var (
+			oid        = int64(0)
+			subtitleID = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.subtitleKey(oid, subtitleID)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaosubtitleVideoKey(t *testing.T) {
+	convey.Convey("subtitleVideoKey", t, func(ctx convey.C) {
+		var (
+			oid = int64(0)
+			tp  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.subtitleVideoKey(oid, tp)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaosubtitleDraftKey(t *testing.T) {
+	convey.Convey("subtitleDraftKey", t, func(ctx convey.C) {
+		var (
+			oid = int64(0)
+			tp  = int32(0)
+			mid = int64(0)
+			lan = uint8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.subtitleDraftKey(oid, tp, mid, lan)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaosubtitleSubjectKey(t *testing.T) {
+	convey.Convey("subtitleSubjectKey", t, func(ctx convey.C) {
+		var (
+			aid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.subtitleSubjectKey(aid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaosubtitleReportTagKey(t *testing.T) {
+	convey.Convey("subtitleReportTagKey", t, func(ctx convey.C) {
+		var (
+			bid = int64(0)
+			rid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.subtitleReportTagKey(bid, rid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSetVideoSubtitleCache(t *testing.T) {
+	convey.Convey("SetVideoSubtitleCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+			tp  = int32(0)
+			res = &model.VideoSubtitleCache{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.SetVideoSubtitleCache(c, oid, tp, res)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoVideoSubtitleCache(t *testing.T) {
+	convey.Convey("VideoSubtitleCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+			tp  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := testDao.VideoSubtitleCache(c, oid, tp)
+			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 TestDaoDelVideoSubtitleCache(t *testing.T) {
+	convey.Convey("DelVideoSubtitleCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+			tp  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelVideoSubtitleCache(c, oid, tp)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSubtitleDraftCache(t *testing.T) {
+	convey.Convey("SubtitleDraftCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+			tp  = int32(0)
+			mid = int64(0)
+			lan = uint8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.SubtitleDraftCache(c, oid, tp, mid, lan)
+		})
+	})
+}
+
+func TestDaoSetSubtitleDraftCache(t *testing.T) {
+	convey.Convey("SetSubtitleDraftCache", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			subtitle = &model.Subtitle{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.SetSubtitleDraftCache(c, subtitle)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelSubtitleDraftCache(t *testing.T) {
+	convey.Convey("DelSubtitleDraftCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+			tp  = int32(0)
+			mid = int64(0)
+			lan = uint8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelSubtitleDraftCache(c, oid, tp, mid, lan)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSubtitlesCache(t *testing.T) {
+	convey.Convey("SubtitlesCache", t, func(ctx convey.C) {
+		var (
+			c           = context.Background()
+			oid         = int64(0)
+			subtitleIds = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, missed, err := testDao.SubtitlesCache(c, oid, subtitleIds)
+			ctx.Convey("Then err should be nil.res,missed should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(missed, convey.ShouldNotBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSubtitleCache(t *testing.T) {
+	convey.Convey("SubtitleCache", t, func(ctx convey.C) {
+		var (
+			c          = context.Background()
+			oid        = int64(0)
+			subtitleID = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.SubtitleCache(c, oid, subtitleID)
+		})
+	})
+}
+
+func TestDaoSetSubtitleCache(t *testing.T) {
+	convey.Convey("SetSubtitleCache", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			subtitle = &model.Subtitle{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.SetSubtitleCache(c, subtitle)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelSubtitleCache(t *testing.T) {
+	convey.Convey("DelSubtitleCache", t, func(ctx convey.C) {
+		var (
+			c          = context.Background()
+			oid        = int64(0)
+			subtitleID = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelSubtitleCache(c, oid, subtitleID)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSetSubtitleSubjectCache(t *testing.T) {
+	convey.Convey("SetSubtitleSubjectCache", t, func(ctx convey.C) {
+		var (
+			c               = context.Background()
+			subtitleSubject = &model.SubtitleSubject{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.SetSubtitleSubjectCache(c, subtitleSubject)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSubtitleSubjectCache(t *testing.T) {
+	convey.Convey("SubtitleSubjectCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			aid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			subtitleSubject, err := testDao.SubtitleSubjectCache(c, aid)
+			ctx.Convey("Then err should be nil.subtitleSubject should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(subtitleSubject, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelSubtitleSubjectCache(t *testing.T) {
+	convey.Convey("DelSubtitleSubjectCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			aid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelSubtitleSubjectCache(c, aid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSubtitleWorlFlowTagCache(t *testing.T) {
+	convey.Convey("SubtitleWorlFlowTagCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			bid = int64(0)
+			rid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.SubtitleWorlFlowTagCache(c, bid, rid)
+		})
+	})
+}
+
+func TestDaoSetSubtitleWorlFlowTagCache(t *testing.T) {
+	convey.Convey("SetSubtitleWorlFlowTagCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			bid  = int64(0)
+			rid  = int64(0)
+			data = []*model.WorkFlowTag{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.SetSubtitleWorlFlowTagCache(c, bid, rid, data)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/interface/main/dm2/dao/mc_test.go

@@ -0,0 +1,689 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/interface/main/dm2/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaokeyMsgPubLock(t *testing.T) {
+	convey.Convey("keyMsgPubLock", t, func(ctx convey.C) {
+		var (
+			mid      = int64(0)
+			color    = int64(0)
+			rnd      = int64(0)
+			mode     = int32(0)
+			fontsize = int32(0)
+			ip       = ""
+			msg      = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyMsgPubLock(mid, color, rnd, mode, fontsize, ip, msg)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyOidPubLock(t *testing.T) {
+	convey.Convey("keyOidPubLock", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+			oid = int64(0)
+			ip  = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyOidPubLock(mid, oid, ip)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyPubCntLock(t *testing.T) {
+	convey.Convey("keyPubCntLock", t, func(ctx convey.C) {
+		var (
+			mid      = int64(0)
+			color    = int64(0)
+			mode     = int32(0)
+			fontsize = int32(0)
+			ip       = ""
+			msg      = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyPubCntLock(mid, color, mode, fontsize, ip, msg)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyCharPubLock(t *testing.T) {
+	convey.Convey("keyCharPubLock", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyCharPubLock(mid, oid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyXML(t *testing.T) {
+	convey.Convey("keyXML", t, func(ctx convey.C) {
+		var (
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyXML(oid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeySubject(t *testing.T) {
+	convey.Convey("keySubject", t, func(ctx convey.C) {
+		var (
+			tp  = int32(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keySubject(tp, oid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyAjax(t *testing.T) {
+	convey.Convey("keyAjax", t, func(ctx convey.C) {
+		var (
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyAjax(oid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyJudge(t *testing.T) {
+	convey.Convey("keyJudge", t, func(ctx convey.C) {
+		var (
+			tp   = int8(0)
+			oid  = int64(0)
+			dmid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyJudge(tp, oid, dmid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyDMLimitMid(t *testing.T) {
+	convey.Convey("keyDMLimitMid", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyDMLimitMid(mid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyAdvanceCmt(t *testing.T) {
+	convey.Convey("keyAdvanceCmt", t, func(ctx convey.C) {
+		var (
+			mid  = int64(0)
+			oid  = int64(0)
+			mode = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyAdvanceCmt(mid, oid, mode)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyAdvLock(t *testing.T) {
+	convey.Convey("keyAdvLock", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+			cid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyAdvLock(mid, cid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyHistory(t *testing.T) {
+	convey.Convey("keyHistory", t, func(ctx convey.C) {
+		var (
+			tp        = int32(0)
+			oid       = int64(0)
+			timestamp = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyHistory(tp, oid, timestamp)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyHistoryIdx(t *testing.T) {
+	convey.Convey("keyHistoryIdx", t, func(ctx convey.C) {
+		var (
+			tp    = int32(0)
+			oid   = int64(0)
+			month = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyHistoryIdx(tp, oid, month)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyDMMask(t *testing.T) {
+	convey.Convey("keyDMMask", t, func(ctx convey.C) {
+		var (
+			tp   = int32(0)
+			oid  = int64(0)
+			plat = int8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyDMMask(tp, oid, plat)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSubjectCache(t *testing.T) {
+	convey.Convey("SubjectCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			tp  = int32(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.SubjectCache(c, tp, oid)
+		})
+	})
+}
+
+func TestDaoSubjectsCache(t *testing.T) {
+	convey.Convey("SubjectsCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			tp   = int32(0)
+			oids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			cached, missed, err := testDao.SubjectsCache(c, tp, oids)
+			ctx.Convey("Then err should be nil.cached,missed should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(missed, convey.ShouldNotBeNil)
+				ctx.So(cached, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddSubjectCache(t *testing.T) {
+	convey.Convey("AddSubjectCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			sub = &model.Subject{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddSubjectCache(c, sub)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelXMLCache(t *testing.T) {
+	convey.Convey("DelXMLCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelXMLCache(c, oid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddXMLCache(t *testing.T) {
+	convey.Convey("AddXMLCache", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			oid   = int64(0)
+			value = []byte("")
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddXMLCache(c, oid, value)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoXMLCache(t *testing.T) {
+	convey.Convey("XMLCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			data, err := testDao.XMLCache(c, oid)
+			ctx.Convey("Then err should be nil.data should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(data, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAjaxDMCache(t *testing.T) {
+	convey.Convey("AjaxDMCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			msgs, err := testDao.AjaxDMCache(c, oid)
+			ctx.Convey("Then err should be nil.msgs should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(msgs, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddAjaxDMCache(t *testing.T) {
+	convey.Convey("AddAjaxDMCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			oid  = int64(0)
+			msgs = []string{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddAjaxDMCache(c, oid, msgs)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSetDMJudgeCache(t *testing.T) {
+	convey.Convey("SetDMJudgeCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			tp   = int8(0)
+			oid  = int64(0)
+			dmid = int64(0)
+			l    = &model.JudgeDMList{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.SetDMJudgeCache(c, tp, oid, dmid, l)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDMJudgeCache(t *testing.T) {
+	convey.Convey("DMJudgeCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			tp   = int8(0)
+			oid  = int64(0)
+			dmid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			l, err := testDao.DMJudgeCache(c, tp, oid, dmid)
+			ctx.Convey("Then err should be nil.l should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(l, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddMsgPubLock(t *testing.T) {
+	convey.Convey("AddMsgPubLock", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(0)
+			color    = int64(0)
+			rnd      = int64(0)
+			mode     = int32(0)
+			fontsize = int32(0)
+			ip       = ""
+			msg      = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddMsgPubLock(c, mid, color, rnd, mode, fontsize, ip, msg)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoMsgPublock(t *testing.T) {
+	convey.Convey("MsgPublock", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(0)
+			color    = int64(0)
+			rnd      = int64(0)
+			mode     = int32(0)
+			fontsize = int32(0)
+			ip       = ""
+			msg      = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			cached, err := testDao.MsgPublock(c, mid, color, rnd, mode, fontsize, ip, msg)
+			ctx.Convey("Then err should be nil.cached should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(cached, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddOidPubLock(t *testing.T) {
+	convey.Convey("AddOidPubLock", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			oid = int64(0)
+			ip  = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddOidPubLock(c, mid, oid, ip)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoOidPubLock(t *testing.T) {
+	convey.Convey("OidPubLock", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			oid = int64(0)
+			ip  = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			cached, err := testDao.OidPubLock(c, mid, oid, ip)
+			ctx.Convey("Then err should be nil.cached should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(cached, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddDMLimitCache(t *testing.T) {
+	convey.Convey("AddDMLimitCache", t, func(ctx convey.C) {
+		var (
+			c       = context.Background()
+			mid     = int64(0)
+			limiter = &model.Limiter{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddDMLimitCache(c, mid, limiter)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDMLimitCache(t *testing.T) {
+	convey.Convey("DMLimitCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			limiter, err := testDao.DMLimitCache(c, mid)
+			ctx.Convey("Then err should be nil.limiter should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(limiter, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddAdvanceCmtCache(t *testing.T) {
+	convey.Convey("AddAdvanceCmtCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			oid  = int64(0)
+			mid  = int64(0)
+			mode = ""
+			adv  = &model.AdvanceCmt{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddAdvanceCmtCache(c, oid, mid, mode, adv)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAdvanceCmtCache(t *testing.T) {
+	convey.Convey("AdvanceCmtCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			oid  = int64(0)
+			mid  = int64(0)
+			mode = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			adv, err := testDao.AdvanceCmtCache(c, oid, mid, mode)
+			ctx.Convey("Then err should be nil.adv should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(adv, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddAdvanceLock(t *testing.T) {
+	convey.Convey("AddAdvanceLock", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			cid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			succeed := testDao.AddAdvanceLock(c, mid, cid)
+			ctx.Convey("Then succeed should not be nil.", func(ctx convey.C) {
+				ctx.So(succeed, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelAdvanceLock(t *testing.T) {
+	convey.Convey("DelAdvanceLock", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			cid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelAdvanceLock(c, mid, cid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelAdvCache(t *testing.T) {
+	convey.Convey("DelAdvCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			mid  = int64(0)
+			cid  = int64(0)
+			mode = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelAdvCache(c, mid, cid, mode)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddHistoryCache(t *testing.T) {
+	convey.Convey("AddHistoryCache", t, func(ctx convey.C) {
+		var (
+			c         = context.Background()
+			tp        = int32(0)
+			oid       = int64(0)
+			timestamp = int64(0)
+			value     = []byte("")
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddHistoryCache(c, tp, oid, timestamp, value)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoHistoryCache(t *testing.T) {
+	convey.Convey("HistoryCache", t, func(ctx convey.C) {
+		var (
+			c         = context.Background()
+			tp        = int32(0)
+			oid       = int64(0)
+			timestamp = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			data, err := testDao.HistoryCache(c, tp, oid, timestamp)
+			ctx.Convey("Then err should be nil.data should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(data, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddHisIdxCache(t *testing.T) {
+	convey.Convey("AddHisIdxCache", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tp    = int32(0)
+			oid   = int64(0)
+			month = ""
+			dates = []string{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddHisIdxCache(c, tp, oid, month, dates)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoHistoryIdxCache(t *testing.T) {
+	convey.Convey("HistoryIdxCache", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tp    = int32(0)
+			oid   = int64(0)
+			month = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			dates, err := testDao.HistoryIdxCache(c, tp, oid, month)
+			ctx.Convey("Then err should be nil.dates should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(dates, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDMMaskCache(t *testing.T) {
+	convey.Convey("DMMaskCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			tp   = int32(0)
+			oid  = int64(0)
+			plat = int8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.DMMaskCache(c, tp, oid, plat)
+		})
+	})
+}
+
+func TestDaoAddMaskCache(t *testing.T) {
+	convey.Convey("AddMaskCache", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			tp   = int32(0)
+			mask = &model.Mask{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddMaskCache(c, tp, mask)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/interface/main/dm2/dao/mc_wave_form.go

@@ -0,0 +1,77 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_waveFormFmt = "wf_%d_%d"
+)
+
+func (d *Dao) waveFormKey(oid int64, tp int32) string {
+	return fmt.Sprintf(_waveFormFmt, oid, tp)
+}
+
+// SetWaveFormCache .
+func (d *Dao) SetWaveFormCache(c context.Context, waveForm *model.WaveForm) (err error) {
+	var (
+		key  = d.waveFormKey(waveForm.Oid, waveForm.Type)
+		conn = d.subtitleMc.Get(c)
+		item *memcache.Item
+	)
+	defer conn.Close()
+	item = &memcache.Item{
+		Key:        key,
+		Object:     waveForm,
+		Flags:      memcache.FlagJSON | memcache.FlagGzip,
+		Expiration: d.subtitleMcExpire,
+	}
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// WaveFormCache .
+func (d *Dao) WaveFormCache(c context.Context, oid int64, tp int32) (waveForm *model.WaveForm, err error) {
+	var (
+		item *memcache.Item
+		conn = d.subtitleMc.Get(c)
+		key  = d.waveFormKey(oid, tp)
+	)
+	defer conn.Close()
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Get(%s) error(%v)", key, err)
+		}
+		return
+	}
+	if err = conn.Scan(item, &waveForm); err != nil {
+		log.Error("mc.Scan() error(%v)", err)
+	}
+	return
+}
+
+// DelWaveFormCache .
+func (d *Dao) DelWaveFormCache(c context.Context, oid int64, tp int32) (err error) {
+	var (
+		key  = d.waveFormKey(oid, tp)
+		conn = d.subtitleMc.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+		} else {
+			log.Error("memcache.Delete(%s) error(%v)", key, err)
+		}
+	}
+	return
+}

app/interface/main/dm2/dao/mc_wave_form_test.go

@@ -0,0 +1,72 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/interface/main/dm2/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaowaveFormKey(t *testing.T) {
+	convey.Convey("waveFormKey", t, func(ctx convey.C) {
+		var (
+			oid = int64(0)
+			tp  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.waveFormKey(oid, tp)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSetWaveFormCache(t *testing.T) {
+	convey.Convey("SetWaveFormCache", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			waveForm = &model.WaveForm{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.SetWaveFormCache(c, waveForm)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoWaveFormCache(t *testing.T) {
+	convey.Convey("WaveFormCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+			tp  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			waveForm, err := testDao.WaveFormCache(c, oid, tp)
+			ctx.Convey("Then err should be nil.waveForm should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(waveForm, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelWaveFormCache(t *testing.T) {
+	convey.Convey("DelWaveFormCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+			tp  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelWaveFormCache(c, oid, tp)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/interface/main/dm2/dao/mysql.go

@@ -0,0 +1,482 @@
+package dao
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+	"go-common/library/time"
+	"go-common/library/xstr"
+)
+
+const (
+	_pageSize             = 1000
+	_subjectSharding      = 100
+	_indexSharding        = 1000
+	_contentSharding      = 1000
+	_subSQL               = "SELECT id,type,oid,pid,mid,state,attr,acount,count,mcount,move_count,maxlimit,childpool,ctime,mtime FROM dm_subject_%02d WHERE type=? AND oid=?"
+	_getSubjectsSQL       = "SELECT id,type,oid,pid,mid,state,attr,acount,count,mcount,move_count,maxlimit,childpool,ctime,mtime FROM dm_subject_%02d WHERE type=? AND oid IN(%s)"
+	_updateSubAttr        = "UPDATE dm_subject_%02d SET attr=? WHERE type=? AND oid=?"
+	_idxByidSQL           = "SELECT id,type,oid,mid,progress,state,pool,attr,ctime,mtime FROM dm_index_%03d WHERE type=? AND id=?"
+	_idxsByidSQL          = "SELECT id,type,oid,mid,progress,state,pool,attr,ctime,mtime FROM dm_index_%03d WHERE type=? AND id IN(%s)"
+	_getIndexSQL          = "SELECT id,type,oid,mid,progress,state,pool,attr,ctime,mtime FROM dm_index_%03d WHERE type=? AND oid=? AND state IN(0,6)"
+	_getContentSQL        = "SELECT dmid,fontsize,color,mode,ip,plat,msg,ctime,mtime FROM dm_content_%03d WHERE dmid=?"
+	_contentsSQL          = "SELECT dmid,fontsize,color,mode,ip,plat,msg,ctime,mtime FROM dm_content_%03d WHERE dmid IN(%s)"
+	_contentsSpeSQL       = "SELECT dmid,msg,ctime,mtime FROM dm_special_content WHERE dmid IN(%s)"
+	_idxSegIDSQL          = "SELECT id FROM dm_index_%03d WHERE type=? AND oid=? AND progress>=? AND progress<? AND state IN(0,6) AND pool = ? limit ?"
+	_selectDMCount        = "SELECT count(*) from dm_index_%03d WHERE type=? AND oid=? AND state IN(%s)"
+	_updateIdxStatSQL     = "UPDATE dm_index_%03d SET state=? WHERE type=? AND oid=? AND id IN(%s)"
+	_updateUserIdxStatSQL = "UPDATE dm_index_%03d SET state=? WHERE type=? AND oid=? AND id IN(%s) and mid=?"
+	_updateIdxPoolSQL     = "UPDATE dm_index_%03d SET pool=? WHERE type=? AND oid=? AND id IN(%s)"
+	_updateIdxAttrSQL     = "UPDATE dm_index_%03d SET attr=? WHERE id=?"
+	_judgeIdxPageSQL      = "SELECT id,type,oid,mid,progress,state,pool,attr,ctime,mtime FROM dm_index_%03d WHERE type=? AND oid=? AND ctime >=? AND ctime <=? AND progress>=? AND progress<=?  AND state IN (0,1,2,6,8,9,10,11) limit 1000"
+	_updateSubPoolSQL     = "UPDATE dm_subject_%02d SET childpool=? WHERE type=? AND oid=?"
+	_incrSubMoveCntSQL    = "UPDATE dm_subject_%02d SET move_count=move_count+? WHERE type=? AND oid=?"
+	_updateSubMCountSQL   = "UPDATE dm_subject_%02d SET mcount=? WHERE type=? AND oid=?"
+	_incrSubCountSQL      = "UPDATE dm_subject_%02d SET count=count+? WHERE type=? AND oid=?"
+	_getSpecialLocation   = "SELECT id,type,oid,locations FROM dm_special_content_location WHERE oid=? AND type=?"
+	_getSpecialIdxSQL     = "SELECT id,type,oid,mid,progress,state,pool,attr,ctime,mtime FROM dm_index_%03d WHERE oid=? AND type=? AND state IN(0,6) AND pool=2"
+	// upper config
+	_addUpperCfgSQL = "REPLACE INTO dm_upper_config(mid,advance_permit) VALUES(?,?)"
+	_selUpperCfgSQL = "SELECT advance_permit FROM dm_upper_config WHERE mid=?"
+)
+
+// Subject get subject info from db.
+func (d *Dao) Subject(c context.Context, tp int32, oid int64) (s *model.Subject, err error) {
+	s = &model.Subject{}
+	row := d.dmReader.QueryRow(c, fmt.Sprintf(_subSQL, d.hitSubject(oid)), tp, oid)
+	if err = row.Scan(&s.ID, &s.Type, &s.Oid, &s.Pid, &s.Mid, &s.State, &s.Attr, &s.ACount, &s.Count, &s.MCount, &s.MoveCnt, &s.Maxlimit, &s.Childpool, &s.Ctime, &s.Mtime); err != nil {
+		if err == sql.ErrNoRows {
+			s = nil
+			err = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+	}
+	return
+}
+
+// Subjects multi get subjects.
+func (d *Dao) Subjects(c context.Context, tp int32, oids []int64) (res map[int64]*model.Subject, err error) {
+	var (
+		oidMap     = make(map[int64][]int64)
+		mutext     = &sync.Mutex{}
+		wg, errCtx = errgroup.WithContext(c)
+	)
+	if len(oids) == 0 {
+		return
+	}
+	res = make(map[int64]*model.Subject, len(oids))
+	for _, oid := range oids {
+		if _, ok := oidMap[d.hitSubject(oid)]; !ok {
+			oidMap[d.hitSubject(oid)] = make([]int64, 0)
+		}
+		oidMap[d.hitSubject(oid)] = append(oidMap[d.hitSubject(oid)], oid)
+	}
+	for key, value := range oidMap {
+		k := key
+		v := value
+		wg.Go(func() (err error) {
+			rows, err := d.dmReader.Query(errCtx, fmt.Sprintf(_getSubjectsSQL, k, xstr.JoinInts(v)), tp)
+			if err != nil {
+				log.Error("dmReader.Query() error(%v)", err)
+				return
+			}
+			defer rows.Close()
+			for rows.Next() {
+				s := &model.Subject{}
+				err = rows.Scan(&s.ID, &s.Type, &s.Oid, &s.Pid, &s.Mid, &s.State, &s.Attr, &s.ACount, &s.Count, &s.MCount, &s.MoveCnt, &s.Maxlimit, &s.Childpool, &s.Ctime, &s.Mtime)
+				if err != nil {
+					log.Error("rows.Scan() error(%v)", err)
+					return
+				}
+				mutext.Lock()
+				res[s.Oid] = s
+				mutext.Unlock()
+			}
+			err = rows.Err()
+			return
+		})
+	}
+	if err = wg.Wait(); err != nil {
+		log.Error("d.Subjects() error(%v)", err)
+		return
+	}
+	if len(res) == 0 {
+		res = nil
+	}
+	return
+}
+
+// UptSubAttr update subject attr
+func (d *Dao) UptSubAttr(c context.Context, tp int32, oid int64, attr int32) (affect int64, err error) {
+	res, err := d.dmWriter.Exec(c, fmt.Sprintf(_updateSubAttr, d.hitSubject(oid)), attr, tp, oid)
+	if err != nil {
+		log.Error("dmWriter.Exec(%s,%d,%d,%d) error(%v)", _updateSubAttr, attr, tp, oid, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// IncrSubMoveCount update move_count in dm_subject.
+func (d *Dao) IncrSubMoveCount(c context.Context, tp int32, oid, count int64) (affect int64, err error) {
+	res, err := d.dmWriter.Exec(c, fmt.Sprintf(_incrSubMoveCntSQL, d.hitSubject(oid)), count, tp, oid)
+	if err != nil {
+		log.Error("d.dmWriter.Exec(%s,%d,%d,%d) error(%v)", _incrSubMoveCntSQL, tp, oid, count, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UpSubjectMCount update monitor dm count.
+func (d *Dao) UpSubjectMCount(c context.Context, tp int32, oid, cnt int64) (affect int64, err error) {
+	res, err := d.dmWriter.Exec(c, fmt.Sprintf(_updateSubMCountSQL, d.hitSubject(oid)), cnt, tp, oid)
+	if err != nil {
+		log.Error("d.dmWriter.Exect(%s,%d,%d,%d) error(%v)", _updateSubMCountSQL, cnt, tp, oid, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UpSubjectPool update childpool in dm subject.
+func (d *Dao) UpSubjectPool(c context.Context, tp int32, oid int64, childpool int32) (affect int64, err error) {
+	res, err := d.dmWriter.Exec(c, fmt.Sprintf(_updateSubPoolSQL, d.hitSubject(oid)), childpool, tp, oid)
+	if err != nil {
+		log.Error("d.dmWriter.Exect(%s,%d,%d,%d) error(%v)", _updateSubPoolSQL, childpool, tp, oid, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// IncrSubjectCount update count.
+func (d *Dao) IncrSubjectCount(c context.Context, tp int32, oid, count int64) (affect int64, err error) {
+	res, err := d.dmWriter.Exec(c, fmt.Sprintf(_incrSubCountSQL, d.hitSubject(oid)), count, tp, oid)
+	if err != nil {
+		log.Error("dmWriter.Exec() error(%v)", err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// DMIDs normal dm ids
+func (d *Dao) DMIDs(c context.Context, tp int32, oid, ps, pe, limit int64, pool int32) (dmids []int64, err error) {
+	rows, err := d.dmReader.Query(c, fmt.Sprintf(_idxSegIDSQL, d.hitIndex(oid)), tp, oid, ps, pe, pool, limit)
+	if err != nil {
+		log.Error("db.Query() error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	var dmid int64
+	for rows.Next() {
+		if err = rows.Scan(&dmid); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		dmids = append(dmids, dmid)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// Indexs get dm index by oid.
+func (d *Dao) Indexs(c context.Context, tp int32, oid int64) (idxMap map[int64]*model.DM, dmids, special []int64, err error) {
+	rows, err := d.dmReader.Query(c, fmt.Sprintf(_getIndexSQL, d.hitIndex(oid)), tp, oid)
+	if err != nil {
+		log.Error("dmReader.Query() error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	idxMap = make(map[int64]*model.DM)
+	for rows.Next() {
+		idx := &model.DM{}
+		if err = rows.Scan(&idx.ID, &idx.Type, &idx.Oid, &idx.Mid, &idx.Progress, &idx.State, &idx.Pool, &idx.Attr, &idx.Ctime, &idx.Mtime); err != nil {
+			log.Error("row.Scan() error(%v)", err)
+			return
+		}
+		idxMap[idx.ID] = idx
+		dmids = append(dmids, idx.ID)
+		if idx.Pool == model.PoolSpecial {
+			special = append(special, idx.ID)
+		}
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// IndexByid get index by dmid.
+func (d *Dao) IndexByid(c context.Context, tp int8, oid, dmid int64) (idx *model.DM, err error) {
+	row := d.dmReader.QueryRow(c, fmt.Sprintf(_idxByidSQL, d.hitIndex(oid)), tp, dmid)
+	idx = &model.DM{}
+	err = row.Scan(&idx.ID, &idx.Type, &idx.Oid, &idx.Mid, &idx.Progress, &idx.State, &idx.Pool, &idx.Attr, &idx.Ctime, &idx.Mtime)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			idx = nil
+			err = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+	}
+	return
+}
+
+// IndexsByid get dm index by dmids.
+func (d *Dao) IndexsByid(c context.Context, tp int32, oid int64, dmids []int64) (idxMap map[int64]*model.DM, special []int64, err error) {
+	query := fmt.Sprintf(_idxsByidSQL, d.hitIndex(oid), xstr.JoinInts(dmids))
+	rows, err := d.dmReader.Query(c, query, tp)
+	if err != nil {
+		log.Error("db.Query() error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	idxMap = make(map[int64]*model.DM, len(dmids))
+	for rows.Next() {
+		idx := &model.DM{}
+		if err = rows.Scan(&idx.ID, &idx.Type, &idx.Oid, &idx.Mid, &idx.Progress, &idx.State, &idx.Pool, &idx.Attr, &idx.Ctime, &idx.Mtime); err != nil {
+			log.Error("row.Scan() error(%v)", err)
+			return
+		}
+		idxMap[idx.ID] = idx
+		if idx.Pool == model.PoolSpecial {
+			special = append(special, idx.ID)
+		}
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// JudgeIndex get judget index.
+func (d *Dao) JudgeIndex(c context.Context, tp int8, oid int64, ctime1, ctime2 time.Time, prog1, prog2 int32) (idxs []*model.DM, special []int64, err error) {
+	query := fmt.Sprintf(_judgeIdxPageSQL, d.hitIndex(oid))
+	rows, err := d.dmReader.Query(c, query, tp, oid, ctime1, ctime2, prog1, prog2)
+	if err != nil {
+		log.Error("db.Query() error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		idx := &model.DM{}
+		if err = rows.Scan(&idx.ID, &idx.Type, &idx.Oid, &idx.Mid, &idx.Progress, &idx.State, &idx.Pool, &idx.Attr, &idx.Ctime, &idx.Mtime); err != nil {
+			log.Error("row.Scan() error(%v)", err)
+			return
+		}
+		idxs = append(idxs, idx)
+		if idx.Pool == model.PoolSpecial {
+			special = append(special, idx.ID)
+		}
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// Content dm content by dmid
+func (d *Dao) Content(c context.Context, oid, dmid int64) (ct *model.Content, err error) {
+	ct = &model.Content{}
+	row := d.dmReader.QueryRow(c, fmt.Sprintf(_getContentSQL, d.hitContent(oid)), dmid)
+	if err = row.Scan(&ct.ID, &ct.FontSize, &ct.Color, &ct.Mode, &ct.IP, &ct.Plat, &ct.Msg, &ct.Ctime, &ct.Mtime); err != nil {
+		ct = nil
+		log.Error("row.Scan() error(%v)", err)
+	}
+	return
+}
+
+// Contents multi get dm content by dmids.
+func (d *Dao) Contents(c context.Context, oid int64, dmids []int64) (ctsMap map[int64]*model.Content, err error) {
+	var (
+		wg   errgroup.Group
+		lock sync.Mutex
+	)
+	ctsMap = make(map[int64]*model.Content)
+	pageNum := len(dmids) / _pageSize
+	if len(dmids)%_pageSize > 0 {
+		pageNum = pageNum + 1
+	}
+	for i := 0; i < pageNum; i++ {
+		start := i * _pageSize
+		end := (i + 1) * _pageSize
+		if end > len(dmids) {
+			end = len(dmids)
+		}
+		wg.Go(func() (err error) {
+			rows, err := d.dmReader.Query(c, fmt.Sprintf(_contentsSQL, d.hitContent(oid), xstr.JoinInts(dmids[start:end])))
+			if err != nil {
+				log.Error("db.Query(%s) error(%v)", fmt.Sprintf(_contentsSQL, d.hitContent(oid), xstr.JoinInts(dmids)), err)
+				return
+			}
+			defer rows.Close()
+			for rows.Next() {
+				ct := &model.Content{}
+				if err = rows.Scan(&ct.ID, &ct.FontSize, &ct.Color, &ct.Mode, &ct.IP, &ct.Plat, &ct.Msg, &ct.Ctime, &ct.Mtime); err != nil {
+					log.Error("rows.Scan() error(%v)", err)
+					return
+				}
+				lock.Lock()
+				ctsMap[ct.ID] = ct
+				lock.Unlock()
+			}
+			err = rows.Err()
+			return
+		})
+	}
+	if err = wg.Wait(); err != nil {
+		log.Error("wg.Wait() error(%v)", err)
+	}
+	return
+}
+
+// ContentsSpecial multi get special dm content by dmids.
+func (d *Dao) ContentsSpecial(c context.Context, dmids []int64) (res map[int64]*model.ContentSpecial, err error) {
+	res = make(map[int64]*model.ContentSpecial, len(dmids))
+	rows, err := d.dmReader.Query(c, fmt.Sprintf(_contentsSpeSQL, xstr.JoinInts(dmids)))
+	if err != nil {
+		log.Error("db.Query() error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		content := &model.ContentSpecial{}
+		if err = rows.Scan(&content.ID, &content.Msg, &content.Ctime, &content.Mtime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		res[content.ID] = content
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// UpdateDMStat edit dm state
+func (d *Dao) UpdateDMStat(c context.Context, tp int32, oid int64, state int32, dmids []int64) (affect int64, err error) {
+	res, err := d.dmWriter.Exec(c, fmt.Sprintf(_updateIdxStatSQL, d.hitIndex(oid), xstr.JoinInts(dmids)), state, tp, oid)
+	if err != nil {
+		log.Error("dmWriter.Exec(%s %d) error(%v)", _updateIdxStatSQL, oid, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UpdateUserDMStat edit user dm state
+func (d *Dao) UpdateUserDMStat(c context.Context, tp int32, oid, mid int64, state int32, dmids []int64) (affect int64, err error) {
+	if mid <= 0 || tp <= 0 || oid <= 0 || len(dmids) <= 0 {
+		affect = 0
+		err = errors.New("d.UpdateUserDMStat: invalid arguments")
+		return
+	}
+	res, err := d.dmWriter.Exec(c, fmt.Sprintf(_updateUserIdxStatSQL, d.hitIndex(oid), xstr.JoinInts(dmids)), state, tp, oid, mid)
+	if err != nil {
+		log.Error("dmWriter.Exec(%s %d) error(%v)", _updateIdxStatSQL, oid, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UpdateDMPool edit dm pool.
+func (d *Dao) UpdateDMPool(c context.Context, tp int32, oid int64, pool int32, dmids []int64) (affect int64, err error) {
+	res, err := d.dmWriter.Exec(c, fmt.Sprintf(_updateIdxPoolSQL, d.hitIndex(oid), xstr.JoinInts(dmids)), pool, tp, oid)
+	if err != nil {
+		log.Error("dmWriter.Exec(%s %d) error(%v)", _updateIdxPoolSQL, oid, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UpdateDMAttr update dm attr
+func (d *Dao) UpdateDMAttr(c context.Context, tp int32, oid, dmid int64, attr int32) (affect int64, err error) {
+	res, err := d.dmWriter.Exec(c, fmt.Sprintf(_updateIdxAttrSQL, d.hitIndex(oid)), attr, dmid)
+	if err != nil {
+		log.Error("dmWriter.Exec(%s oid:%d dmid:%d attr:%d) error(%v)", _updateIdxAttrSQL, oid, dmid, attr, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// DMCount statistics dm count by dm state.
+func (d *Dao) DMCount(c context.Context, typ int32, oid int64, states []int64) (count int64, err error) {
+	row := d.dmReader.QueryRow(c, fmt.Sprintf(_selectDMCount, d.hitIndex(oid), xstr.JoinInts(states)), typ, oid)
+	if err = row.Scan(&count); err != nil {
+		log.Error("row.Scan() error(%v)", err)
+	}
+	return
+}
+
+// SpecialDmLocation get special dm localtion url
+func (d *Dao) SpecialDmLocation(c context.Context, tp int32, oid int64) (ds *model.DmSpecial, err error) {
+	row := d.dmReader.QueryRow(c, _getSpecialLocation, oid, tp)
+	ds = &model.DmSpecial{}
+	if err = row.Scan(&ds.ID, &ds.Type, &ds.Oid, &ds.Locations); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			ds = nil
+		} else {
+			log.Error("SpecialDmLocation.Query(tp:%v,oid:%v) error(%v)", tp, oid, err)
+		}
+	}
+	return
+}
+
+// SpecalDMs .
+func (d *Dao) SpecalDMs(c context.Context, tp int32, oid int64) (dms map[int64]*model.DM, dmids []int64, err error) {
+	rows, err := d.dmReader.Query(c, fmt.Sprintf(_getSpecialIdxSQL, d.hitIndex(oid)), oid, tp)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("SpecalDMs.Query(tp:%v,oid:%v) error(%v)", tp, oid, err)
+		}
+		return
+	}
+	defer rows.Close()
+	dms = make(map[int64]*model.DM)
+	for rows.Next() {
+		dm := &model.DM{}
+		if err = rows.Scan(&dm.ID, &dm.Type, &dm.Oid, &dm.Mid, &dm.Progress, &dm.State, &dm.Pool, &dm.Attr, &dm.Ctime, &dm.Mtime); err != nil {
+			log.Error("row.Scan() error(%v)", err)
+			return
+		}
+		dms[dm.ID] = dm
+		dmids = append(dmids, dm.ID)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// AddUpperConfig add upper config.
+func (d *Dao) AddUpperConfig(c context.Context, mid int64, advPermit int8) (affect int64, err error) {
+	res, err := d.dbDM.Exec(c, _addUpperCfgSQL, mid, advPermit)
+	if err != nil {
+		log.Error("dbDM.Exec(%s,%d,%d) error(%v)", _addUpperCfgSQL, mid, advPermit, err)
+		return
+	}
+	affect, err = res.RowsAffected()
+	return
+}
+
+// UpperConfig get upper config.
+func (d *Dao) UpperConfig(c context.Context, mid int64) (advPermit int8, err error) {
+	row := d.dbDM.QueryRow(c, _selUpperCfgSQL, mid)
+	if err = row.Scan(&advPermit); err != nil {
+		if err == sql.ErrNoRows {
+			advPermit = model.AdvPermitAll
+			err = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+	}
+	return
+}

app/interface/main/dm2/dao/mysql_advance.go

@@ -0,0 +1,117 @@
+package dao
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	// advance comment
+	_addAdvSQL     = "INSERT INTO dm_advancecomment (dm_inid,owner,mid,type,timestamp,mode,refund) VALUES (?,?,?,?,?,?,?)"
+	_selAdvSQL     = "SELECT buy_id,owner,dm_inid,type,mode,mid,timestamp,refund FROM dm_advancecomment WHERE owner=? AND buy_id=?"
+	_selAdvsSQL    = "SELECT buy_id,owner,dm_inid,type,mode,mid,timestamp,refund FROM dm_advancecomment WHERE owner=? ORDER BY buy_id DESC limit 100"
+	_selAdvModeSQL = "SELECT type FROM dm_advancecomment WHERE dm_inid=? AND mid=? AND mode=?"
+	_upAdvTypeSQL  = "UPDATE dm_advancecomment SET type=? WHERE buy_id=?"
+	_delAdvSQL     = "DELETE FROM dm_advancecomment WHERE buy_id=?"
+	_selAdvanceCmt = "SELECT buy_id,owner,dm_inid,type,mode,mid,timestamp,refund FROM dm_advancecomment WHERE dm_inid=? AND mid=? AND mode=?"
+)
+
+// AdvanceType get advance type by cid,mid and mode.
+func (d *Dao) AdvanceType(c context.Context, cid int64, mid int64, mode string) (typ string, err error) {
+	row := d.dbDM.QueryRow(c, _selAdvModeSQL, cid, mid, mode)
+	if err = row.Scan(&typ); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("row.Scan error(%v)", err)
+		}
+	}
+	return
+}
+
+// Advance 获取购买高级弹幕功能状态
+func (d *Dao) Advance(c context.Context, mid, id int64) (adv *model.Advance, err error) {
+	row := d.dbDM.QueryRow(c, _selAdvSQL, mid, id)
+	adv = &model.Advance{}
+	if err = row.Scan(&adv.ID, &adv.Owner, &adv.Cid, &adv.Type, &adv.Mode, &adv.Mid, &adv.Timestamp, &adv.Refund); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			adv = nil
+		} else {
+			log.Error("row.Scan error(%v)", err)
+		}
+	}
+	return
+}
+
+// Advances 获取高级弹幕申请列表
+func (d *Dao) Advances(c context.Context, owner int64) (res []*model.Advance, err error) {
+	rows, err := d.dbDM.Query(c, _selAdvsSQL, owner)
+	if err != nil {
+		log.Error("d.dbDM.Query(%s,%d) error(%v)", _selAdvsSQL, owner, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		adv := &model.Advance{}
+		if err = rows.Scan(&adv.ID, &adv.Owner, &adv.Cid, &adv.Type, &adv.Mode, &adv.Mid, &adv.Timestamp, &adv.Refund); err != nil {
+			log.Error("rows.Scan error(%v)", err)
+			return
+		}
+		res = append(res, adv)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// BuyAdvance 购买高级弹幕功能
+func (d *Dao) BuyAdvance(c context.Context, mid, cid, owner, refund int64, typ, mode string) (id int64, err error) {
+	now := time.Now().Unix()
+	res, err := d.dbDM.Exec(c, _addAdvSQL, cid, owner, mid, typ, now, mode, refund)
+	if err != nil {
+		log.Error("d.dbDM.Exec(cid:%d,mid:%d,type:%s) error(%v)", cid, mid, typ, err)
+		return
+	}
+	return res.LastInsertId()
+}
+
+// UpdateAdvType 更新购买高级弹幕类型
+func (d *Dao) UpdateAdvType(c context.Context, id int64, typ string) (affect int64, err error) {
+	res, err := d.dbDM.Exec(c, _upAdvTypeSQL, typ, id)
+	if err != nil {
+		log.Error("d.dbDM.Exec(%s,%s,%d) error(%v)", _upAdvTypeSQL, typ, id, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// DelAdvance 删除购买高级弹幕记录
+func (d *Dao) DelAdvance(c context.Context, id int64) (affect int64, err error) {
+	res, err := d.dbDM.Exec(c, _delAdvSQL, id)
+	if err != nil {
+		log.Error("d.dbDM.Exec(%s,%d) error(%v)", _delAdvSQL, id, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// AdvanceCmt get advance comment.
+func (d *Dao) AdvanceCmt(c context.Context, oid, mid int64, mode string) (adv *model.AdvanceCmt, err error) {
+	adv = &model.AdvanceCmt{}
+	row := d.dbDM.QueryRow(c, _selAdvanceCmt, oid, mid, mode)
+	if err = row.Scan(&adv.ID, &adv.Owner, &adv.Oid, &adv.Type, &adv.Mode, &adv.Mid, &adv.Timestamp, &adv.Refund); err != nil {
+		if err == sql.ErrNoRows {
+			adv = nil
+			err = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+	}
+	return
+}

app/interface/main/dm2/dao/mysql_advance_test.go

@@ -0,0 +1,127 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoAdvanceType(t *testing.T) {
+	convey.Convey("AdvanceType", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			cid  = int64(0)
+			mid  = int64(0)
+			mode = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			typ, err := testDao.AdvanceType(c, cid, mid, mode)
+			ctx.Convey("Then err should be nil.typ should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(typ, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAdvance(t *testing.T) {
+	convey.Convey("Advance", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			id  = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.Advance(c, mid, id)
+		})
+	})
+}
+
+func TestDaoAdvances(t *testing.T) {
+	convey.Convey("Advances", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			owner = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := testDao.Advances(c, owner)
+			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 TestDaoBuyAdvance(t *testing.T) {
+	convey.Convey("BuyAdvance", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			mid    = int64(0)
+			cid    = int64(0)
+			owner  = int64(0)
+			refund = int64(0)
+			typ    = ""
+			mode   = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			id, err := testDao.BuyAdvance(c, mid, cid, owner, refund, typ, mode)
+			ctx.Convey("Then err should be nil.id should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(id, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpdateAdvType(t *testing.T) {
+	convey.Convey("UpdateAdvType", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(0)
+			typ = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			affect, err := testDao.UpdateAdvType(c, id, typ)
+			ctx.Convey("Then err should be nil.affect should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(affect, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelAdvance(t *testing.T) {
+	convey.Convey("DelAdvance", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			affect, err := testDao.DelAdvance(c, id)
+			ctx.Convey("Then err should be nil.affect should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(affect, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAdvanceCmt(t *testing.T) {
+	convey.Convey("AdvanceCmt", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			oid  = int64(0)
+			mid  = int64(0)
+			mode = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			adv, err := testDao.AdvanceCmt(c, oid, mid, mode)
+			ctx.Convey("Then err should be nil.adv should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(adv, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/interface/main/dm2/dao/mysql_filter.go

@@ -0,0 +1,357 @@
+package dao
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+const (
+	_upFilterSharding       = 10
+	_userFilterSharding     = 50
+	_userFltCntSharding     = 10
+	_addUserFilterSQL       = "INSERT INTO dm_filter_user_%02d(mid,type,filter,comment) VALUES(?,?,?,?)"
+	_getUserFilterSQL       = "SELECT id,mid,type,filter,comment,ctime,mtime FROM dm_filter_user_%02d WHERE mid=? AND type=?"
+	_getUserFiltersSQL      = "SELECT id,mid,type,filter,comment,ctime,mtime FROM dm_filter_user_%02d WHERE mid=?"
+	_getUserFiltersByIDSQL  = "SELECT id,mid,type,filter,comment,ctime,mtime FROM dm_filter_user_%02d WHERE mid=? AND id IN(%s)"
+	_delUserFilterSQL       = "DELETE FROM dm_filter_user_%02d WHERE mid=%d AND id IN(%s)"
+	_maddUpFilterSQL        = "INSERT INTO dm_filter_up_%02d(mid,type,filter,active,comment) VALUES %s"
+	_getUpFilterSQL         = "SELECT id,mid,type,filter,active,comment,ctime,mtime FROM dm_filter_up_%02d WHERE mid=? AND oid=0 AND type=? AND active=1"
+	_getUpFiltersSQL        = "SELECT id,mid,type,filter,active,comment,ctime,mtime FROM dm_filter_up_%02d WHERE mid=? AND oid=0 AND active=1"
+	_uptUpFilterSQL         = "UPDATE dm_filter_up_%02d SET active=? WHERE type=? AND mid=? AND filter IN(%s)"
+	_getGlbFilterSQL        = "SELECT id,type,filter,ctime,mtime FROM dm_filter_global WHERE type=? AND filter=?"
+	_getGlbFiltersSQL       = "SELECT id,type,filter,ctime,mtime FROM dm_filter_global WHERE id>=? ORDER BY id DESC LIMIT ?"
+	_addGlbFilterSQL        = "INSERT INTO dm_filter_global(type,filter) VALUES(?,?)"
+	_delGlbFilterSQL        = "DELETE FROM dm_filter_global WHERE id IN(%s)"
+	_getUserFilterCntSQL    = "SELECT count FROM dm_filter_user_count_%02d WHERE mid=? AND type=?"
+	_getUpFilterCntSQL      = "SELECT count FROM dm_filter_up_count WHERE mid=? AND type=?"
+	_addUserFilterCntSQL    = "INSERT INTO dm_filter_user_count_%02d(mid,type,count) VALUES(?,?,?)"
+	_updateUserFilterCntSQL = "UPDATE dm_filter_user_count_%02d SET count=count+? WHERE mid=? AND type=? AND count<?"
+	_addUpFilterCntSQL      = "INSERT INTO dm_filter_up_count(mid,type,count) VALUES(?,?,?)"
+	_updateUpFilterCntSQL   = "UPDATE dm_filter_up_count SET count=count+? WHERE mid=? AND type=? AND count<?"
+)
+
+func (d *Dao) hitUpFilter(mid int64) int64 {
+	return mid % _upFilterSharding
+}
+
+func (d *Dao) hitUserFilter(mid int64) int64 {
+	return mid % _userFilterSharding
+}
+
+func (d *Dao) hitUserFilterCnt(mid int64) int64 {
+	return mid % _userFltCntSharding
+}
+
+// addslashes 函数返回在预定义字符之前添加反斜杠的字符串。
+// 预定义字符是：单引号（'）或反斜杠（\）
+func addSlashes(str string) string {
+	var buf bytes.Buffer
+	for i := 0; i < len(str); i++ {
+		if str[i] == '\'' || str[i] == '\\' {
+			buf.WriteByte('\\')
+		}
+		buf.WriteByte(str[i])
+	}
+	return buf.String()
+}
+
+// AddUserFilter add filter rule
+func (d *Dao) AddUserFilter(tx *sql.Tx, mid int64, fType int8, filter, comment string) (lastID int64, err error) {
+	res, err := tx.Exec(fmt.Sprintf(_addUserFilterSQL, d.hitUserFilter(mid)), mid, fType, filter, comment)
+	if err != nil {
+		log.Error("d.AddUserFilter(%d,%d,%s) error(%v)", mid, fType, filter, err)
+		return
+	}
+	return res.LastInsertId()
+}
+
+// UserFilter select user filter by mid and type.
+func (d *Dao) UserFilter(c context.Context, mid int64, fType int8) (res []*model.UserFilter, err error) {
+	rows, err := d.dbDM.Query(c, fmt.Sprintf(_getUserFilterSQL, d.hitUserFilter(mid)), mid, fType)
+	if err != nil {
+		log.Error("dbDM.Query(mid:%d,type:%d) error(%v)", mid, fType, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		f := &model.UserFilter{}
+		if err = rows.Scan(&f.ID, &f.Mid, &f.Type, &f.Filter, &f.Comment, &f.Ctime, &f.Mtime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		res = append(res, f)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// UserFilters return all filter.
+func (d *Dao) UserFilters(c context.Context, mid int64) (res []*model.UserFilter, err error) {
+	rows, err := d.dbDM.Query(c, fmt.Sprintf(_getUserFiltersSQL, d.hitUserFilter(mid)), mid)
+	if err != nil {
+		log.Error("dbDM.Query(mid:%d) error(%v)", mid, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		f := &model.UserFilter{}
+		if err = rows.Scan(&f.ID, &f.Mid, &f.Type, &f.Filter, &f.Comment, &f.Ctime, &f.Mtime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		res = append(res, f)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// UserFiltersByID return all filters specified by ids
+func (d *Dao) UserFiltersByID(c context.Context, mid int64, ids []int64) (res []*model.UserFilter, err error) {
+	rows, err := d.dbDM.Query(c, fmt.Sprintf(_getUserFiltersByIDSQL, d.hitUserFilter(mid), xstr.JoinInts(ids)), mid)
+	if err != nil {
+		log.Error("dbDM.Quer(mid:%d, ids:%v) error(%v)", mid, ids, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		f := &model.UserFilter{}
+		if err = rows.Scan(&f.ID, &f.Mid, &f.Type, &f.Filter, &f.Comment, &f.Ctime, &f.Mtime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		res = append(res, f)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// DelUserFilter batch delete filter rules by mid
+func (d *Dao) DelUserFilter(tx *sql.Tx, mid int64, ids []int64) (affect int64, err error) {
+	res, err := tx.Exec(fmt.Sprintf(_delUserFilterSQL, d.hitUserFilter(mid), mid, xstr.JoinInts(ids)))
+	if err != nil {
+		log.Error("tx.Exec(mid:%d, ids:%v) error(%v)", mid, ids, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// MultiAddUpFilter add filter rule,the key of fltMap is filter content,value is comment.
+// TODO add comment field in table:dm_filter_up_xx and insert comment
+func (d *Dao) MultiAddUpFilter(tx *sql.Tx, mid int64, fType int8, fltMap map[string]string) (affect int64, err error) {
+	var buf bytes.Buffer
+	for filter, comment := range fltMap {
+		buf.WriteString(fmt.Sprintf(`(%d,%d,'%s',%d,'%s'),`, mid, fType, addSlashes(filter), model.FilterActive, addSlashes(comment)))
+	}
+	buf.Truncate(buf.Len() - 1)
+	res, err := tx.Exec(fmt.Sprintf(_maddUpFilterSQL, d.hitUpFilter(mid), buf.String()))
+	if err != nil {
+		log.Error("d.AddUpFilter(mid:%d,type:%d,filters:%v) error(%v)", mid, fType, fltMap, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UpFilter return filter rules by mid and filter type.
+func (d *Dao) UpFilter(c context.Context, mid int64, fType int8) (res []*model.UpFilter, err error) {
+	res = make([]*model.UpFilter, 0)
+	rows, err := d.dbDM.Query(c, fmt.Sprintf(_getUpFilterSQL, d.hitUpFilter(mid)), mid, fType)
+	if err != nil {
+		log.Error("dbDM.Query(mid:%d,type:%d) error(%v)", mid, fType, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		f := &model.UpFilter{}
+		if err = rows.Scan(&f.ID, &f.Mid, &f.Type, &f.Filter, &f.Active, &f.Comment, &f.Ctime, &f.Mtime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		res = append(res, f)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// UpFilters return all filter rules
+func (d *Dao) UpFilters(c context.Context, mid int64) (res []*model.UpFilter, err error) {
+	rows, err := d.dbDM.Query(c, fmt.Sprintf(_getUpFiltersSQL, d.hitUpFilter(mid)), mid)
+	if err != nil {
+		log.Error("dbDM.Query(mid:%d) error(%v)", mid, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		f := &model.UpFilter{}
+		if err = rows.Scan(&f.ID, &f.Mid, &f.Type, &f.Filter, &f.Active, &f.Comment, &f.Ctime, &f.Mtime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		res = append(res, f)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// UpdateUpFilter batch edit filter.
+func (d *Dao) UpdateUpFilter(tx *sql.Tx, mid int64, fType, active int8, filters []string) (affect int64, err error) {
+	sli := make([]string, len(filters))
+	for i, ss := range filters {
+		sli[i] = "'" + addSlashes(ss) + "'"
+	}
+	filter := strings.Join(sli, ",")
+	res, err := tx.Exec(fmt.Sprintf(_uptUpFilterSQL, d.hitUpFilter(mid), filter), active, fType, mid)
+	if err != nil {
+		log.Error("tx.Exec(mid:%d,filters:%v) error(%v)", mid, filters, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// AddGlobalFilter add filter rule
+func (d *Dao) AddGlobalFilter(c context.Context, fType int8, filter string) (lastID int64, err error) {
+	res, err := d.dbDM.Exec(c, _addGlbFilterSQL, fType, filter)
+	if err != nil {
+		log.Error("dbDM.Exec(%d,%s) error(%v)", fType, filter, err)
+		return
+	}
+	return res.LastInsertId()
+}
+
+// GlobalFilter select global filters by type and filter.
+func (d *Dao) GlobalFilter(c context.Context, fType int8, filter string) (res []*model.GlobalFilter, err error) {
+	rows, err := d.dbDM.Query(c, _getGlbFilterSQL, fType, filter)
+	if err != nil {
+		log.Error("d.dbDM(type:%d, filter:%s) error(%v)", fType, filter, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		f := &model.GlobalFilter{}
+		if err = rows.Scan(&f.ID, &f.Type, &f.Filter, &f.Ctime, &f.Mtime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		res = append(res, f)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// GlobalFilters return all filter rules
+func (d *Dao) GlobalFilters(c context.Context, sid, limit int64) (res []*model.GlobalFilter, err error) {
+	var rows *sql.Rows
+	if rows, err = d.dbDM.Query(c, _getGlbFiltersSQL, sid, limit); err != nil {
+		log.Error("dbDM.Query(start id:%d, limit:%d) error(%v)", sid, limit, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := &model.GlobalFilter{}
+		if err = rows.Scan(&r.ID, &r.Type, &r.Filter, &r.Ctime, &r.Mtime); err != nil {
+			log.Error("rows.Scan() error(%v)", err)
+			return
+		}
+		res = append(res, r)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("rows.Err() error(%v)", err)
+	}
+	return
+}
+
+// DelGlobalFilters batch delete filter rules
+func (d *Dao) DelGlobalFilters(c context.Context, ids []int64) (affect int64, err error) {
+	res, err := d.dbDM.Exec(c, fmt.Sprintf(_delGlbFilterSQL, xstr.JoinInts(ids)))
+	if err != nil {
+		log.Error("dbDM.Exec(ids:%v) error(%v)", ids, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UserFilterCnt get count by mid and type
+func (d *Dao) UserFilterCnt(c context.Context, tx *sql.Tx, mid int64, tp int8) (count int, err error) {
+	row := tx.QueryRow(fmt.Sprintf(_getUserFilterCntSQL, d.hitUserFilterCnt(mid)), mid, tp)
+	if err = row.Scan(&count); err != nil {
+		if err == sql.ErrNoRows {
+			count = model.FilterNotExist
+			err = nil
+		} else {
+			log.Error("rows.Scan() error(%v)", err)
+		}
+	}
+	return
+}
+
+// InsertUserFilterCnt add a new row
+func (d *Dao) InsertUserFilterCnt(c context.Context, tx *sql.Tx, mid int64, tp int8, count int) (id int64, err error) {
+	res, err := tx.Exec(fmt.Sprintf(_addUserFilterCntSQL, d.hitUserFilterCnt(mid)), mid, tp, count)
+	if err != nil {
+		log.Error("d.InsertUserFilterCnt(mid:%d, type:%d, count:%d) error(%v)", mid, tp, count, err)
+		return
+	}
+	return res.LastInsertId()
+}
+
+// UpdateUserFilterCnt set count
+func (d *Dao) UpdateUserFilterCnt(c context.Context, tx *sql.Tx, mid int64, tp int8, count, limit int64) (affect int64, err error) {
+	res, err := tx.Exec(fmt.Sprintf(_updateUserFilterCntSQL, d.hitUserFilterCnt(mid)), count, mid, tp, limit)
+	if err != nil {
+		log.Error("d.UpdateUserFilterCnt(mid:%d, type:%d, count:%d) error(%v)", mid, tp, count, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UpFilterCnt get count by mid and type
+func (d *Dao) UpFilterCnt(c context.Context, tx *sql.Tx, mid int64, tp int8) (count int, err error) {
+	row := tx.QueryRow(_getUpFilterCntSQL, mid, tp)
+	if err = row.Scan(&count); err != nil {
+		if err == sql.ErrNoRows {
+			count = model.FilterNotExist
+			err = nil
+		} else {
+			log.Error("row.Scan error(%v)", err)
+		}
+	}
+	return
+}
+
+// InsertUpFilterCnt insert up rule count.
+func (d *Dao) InsertUpFilterCnt(c context.Context, tx *sql.Tx, mid int64, tp int8, count int) (id int64, err error) {
+	res, err := tx.Exec(_addUpFilterCntSQL, mid, tp, count)
+	if err != nil {
+		log.Error("d.InsertUpFilterCnt(mid:%d, type:%d, count:%d) error(%v)", mid, tp, count, err)
+		return
+	}
+	return res.LastInsertId()
+}
+
+// UpdateUpFilterCnt set count
+func (d *Dao) UpdateUpFilterCnt(c context.Context, tx *sql.Tx, mid int64, tp int8, count, limit int) (affect int64, err error) {
+	res, err := tx.Exec(_updateUpFilterCntSQL, count, mid, tp, limit)
+	if err != nil {
+		log.Error("d.UpdateUpFilterCnt(mid:%d, type:%d, count:%d) error(%v)", mid, tp, count, err)
+		return
+	}
+	return res.RowsAffected()
+}

app/interface/main/dm2/dao/mysql_filter_test.go

@@ -0,0 +1,363 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaohitUpFilter(t *testing.T) {
+	convey.Convey("hitUpFilter", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.hitUpFilter(mid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaohitUserFilter(t *testing.T) {
+	convey.Convey("hitUserFilter", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.hitUserFilter(mid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaohitUserFilterCnt(t *testing.T) {
+	convey.Convey("hitUserFilterCnt", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.hitUserFilterCnt(mid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoaddSlashes(t *testing.T) {
+	convey.Convey("addSlashes", t, func(ctx convey.C) {
+		var (
+			str = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := addSlashes(str)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddUserFilter(t *testing.T) {
+	convey.Convey("AddUserFilter", t, func(ctx convey.C) {
+		var (
+			tx, _   = testDao.BeginBiliDMTrans(c)
+			mid     = int64(0)
+			fType   = int8(0)
+			filter  = ""
+			comment = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.AddUserFilter(tx, mid, fType, filter, comment)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoUserFilter(t *testing.T) {
+	convey.Convey("UserFilter", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			mid   = int64(0)
+			fType = int8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UserFilter(c, mid, fType)
+		})
+	})
+}
+
+func TestDaoUserFilters(t *testing.T) {
+	convey.Convey("UserFilters", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := testDao.UserFilters(c, mid)
+			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 TestDaoUserFiltersByID(t *testing.T) {
+	convey.Convey("UserFiltersByID", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			ids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UserFiltersByID(c, mid, ids)
+		})
+	})
+}
+
+func TestDaoDelUserFilter(t *testing.T) {
+	convey.Convey("DelUserFilter", t, func(ctx convey.C) {
+		var (
+			tx, _ = testDao.BeginBiliDMTrans(c)
+			mid   = int64(0)
+			ids   = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.DelUserFilter(tx, mid, ids)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoMultiAddUpFilter(t *testing.T) {
+	convey.Convey("MultiAddUpFilter", t, func(ctx convey.C) {
+		var (
+			tx, _  = testDao.BeginBiliDMTrans(c)
+			mid    = int64(0)
+			fType  = int8(0)
+			fltMap = map[string]string{
+				"test": "test",
+			}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.MultiAddUpFilter(tx, mid, fType, fltMap)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoUpFilter(t *testing.T) {
+	convey.Convey("UpFilter", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			mid   = int64(0)
+			fType = int8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UpFilter(c, mid, fType)
+		})
+	})
+}
+
+func TestDaoUpFilters(t *testing.T) {
+	convey.Convey("UpFilters", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UpFilters(c, mid)
+		})
+	})
+}
+
+func TestDaoUpdateUpFilter(t *testing.T) {
+	convey.Convey("UpdateUpFilter", t, func(ctx convey.C) {
+		var (
+			tx, _   = testDao.BeginBiliDMTrans(context.TODO())
+			mid     = int64(0)
+			fType   = int8(0)
+			active  = int8(0)
+			filters = []string{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UpdateUpFilter(tx, mid, fType, active, filters)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoAddGlobalFilter(t *testing.T) {
+	convey.Convey("AddGlobalFilter", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			fType  = int8(0)
+			filter = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			lastID, err := testDao.AddGlobalFilter(c, fType, filter)
+			ctx.Convey("Then err should be nil.lastID should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(lastID, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGlobalFilter(t *testing.T) {
+	convey.Convey("GlobalFilter", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			fType  = int8(0)
+			filter = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := testDao.GlobalFilter(c, fType, filter)
+			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 TestDaoGlobalFilters(t *testing.T) {
+	convey.Convey("GlobalFilters", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			sid   = int64(0)
+			limit = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.GlobalFilters(c, sid, limit)
+		})
+	})
+}
+
+func TestDaoDelGlobalFilters(t *testing.T) {
+	convey.Convey("DelGlobalFilters", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			ids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.DelGlobalFilters(c, ids)
+		})
+	})
+}
+
+func TestDaoUserFilterCnt(t *testing.T) {
+	convey.Convey("UserFilterCnt", t, func(ctx convey.C) {
+		var (
+			tx, _ = testDao.BeginBiliDMTrans(c)
+			mid   = int64(0)
+			tp    = int8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UserFilterCnt(c, tx, mid, tp)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoInsertUserFilterCnt(t *testing.T) {
+	convey.Convey("InsertUserFilterCnt", t, func(ctx convey.C) {
+		var (
+			tx, _ = testDao.BeginBiliDMTrans(c)
+			mid   = int64(0)
+			tp    = int8(0)
+			count = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.InsertUserFilterCnt(c, tx, mid, tp, count)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoUpdateUserFilterCnt(t *testing.T) {
+	convey.Convey("UpdateUserFilterCnt", t, func(ctx convey.C) {
+		var (
+			tx, _ = testDao.BeginBiliDMTrans(c)
+			mid   = int64(0)
+			tp    = int8(0)
+			count = int64(0)
+			limit = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UpdateUserFilterCnt(c, tx, mid, tp, count, limit)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoUpFilterCnt(t *testing.T) {
+	convey.Convey("UpFilterCnt", t, func(ctx convey.C) {
+		var (
+			tx, _ = testDao.BeginBiliDMTrans(c)
+			mid   = int64(0)
+			tp    = int8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UpFilterCnt(c, tx, mid, tp)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoInsertUpFilterCnt(t *testing.T) {
+	convey.Convey("InsertUpFilterCnt", t, func(ctx convey.C) {
+		var (
+			tx, _ = testDao.BeginBiliDMTrans(c)
+			mid   = int64(0)
+			tp    = int8(0)
+			count = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.InsertUpFilterCnt(c, tx, mid, tp, count)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoUpdateUpFilterCnt(t *testing.T) {
+	convey.Convey("UpdateUpFilterCnt", t, func(ctx convey.C) {
+		var (
+			tx, _ = testDao.BeginBiliDMTrans(c)
+			mid   = int64(0)
+			tp    = int8(0)
+			count = int(0)
+			limit = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UpdateUpFilterCnt(c, tx, mid, tp, count, limit)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}

app/interface/main/dm2/dao/mysql_subtitle.go

@@ -0,0 +1,269 @@
+package dao
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	"go-common/app/interface/main/dm2/model"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+const (
+	_subtitleSharding = 100
+
+	_getSubtitlePubIds = "SELECT subtitle_id FROM subtitle_pub WHERE oid=? AND type=? AND is_delete=0"
+	_addSubtitlePub    = "INSERT INTO subtitle_pub(oid,type,lan,subtitle_id,is_delete) VALUES(?,?,?,?,?) ON DUPLICATE KEY UPDATE subtitle_id=?,is_delete=?"
+
+	_addSubtitleSubject = "INSERT INTO subtitle_subject(aid,allow,lan_code) VALUES(?,?,?) ON DUPLICATE KEY UPDATE allow=?,lan_code=?"
+	_getSubtitleSubject = "SELECT aid,allow,attr,lan_code from subtitle_subject WHERE aid=?"
+
+	_getSubtitleOne   = "SELECT id,oid,type,lan,aid,mid,author_mid,up_mid,is_sign,is_lock,status,checksum,subtitle_url,pub_time,reject_comment FROM subtitle_%02d WHERE oid=? AND type=? AND lan=? AND status=5 ORDER BY pub_time DESC limit 1"
+	_getSubtitles     = "SELECT id,oid,type,lan,aid,mid,author_mid,up_mid,is_sign,is_lock,status,checksum,subtitle_url,pub_time,reject_comment,mtime FROM subtitle_%02d WHERE id in (%s)"
+	_getSubtitle      = "SELECT id,oid,type,lan,aid,mid,author_mid,up_mid,is_sign,is_lock,status,checksum,subtitle_url,pub_time,reject_comment,mtime FROM subtitle_%02d WHERE id = ? AND status!=4"
+	_getSubtitleDraft = "SELECT id,oid,type,lan,aid,mid,author_mid,up_mid,is_sign,is_lock,status,checksum,subtitle_url,pub_time,reject_comment FROM subtitle_%02d WHERE oid=? AND type=? AND lan=? AND mid=? AND pub_time=0"
+	_updateSubtitle   = "UPDATE subtitle_%02d SET aid=?,author_mid=?,up_mid=?,is_sign=?,is_lock=?,status=?,checksum=?,subtitle_url=?,pub_time=?,reject_comment=? WHERE id=?"
+	_addSubtitle      = "INSERT INTO subtitle_%02d(id,oid,type,lan,aid,mid,author_mid,up_mid,is_sign,is_lock,status,checksum,subtitle_url,pub_time,reject_comment) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+
+	_addWaveForm = "INSERT INTO subtitle_waveform(oid,type,state,wave_form_url) VALUES(?,?,?,?) ON DUPLICATE KEY UPDATE state=?,wave_form_url=?"
+	_getWaveForm = "SELECT oid,type,state,wave_form_url,mtime FROM subtitle_waveform WHERE oid=? AND type=?"
+
+	_getSubtitleLans = "SELECT code,lan,doc_zh FROM subtitle_language WHERE is_delete=0"
+	_addSubtitleLan  = "INSERT INTO subtitle_language(code,lan,doc_zh,doc_en,is_delete) VALUES(?,?,?,?,?) ON DUPLICATE KEY UPDATE lan=?,doc_zh=?,doc_en=?,is_delete=?"
+)
+
+func (d *Dao) hitSubtitle(oid int64) int64 {
+	return oid % _subtitleSharding
+}
+
+// AddSubtitleSubject .
+func (d *Dao) AddSubtitleSubject(c context.Context, subtitleSubject *model.SubtitleSubject) (err error) {
+	if _, err = d.dbDM.Exec(c, _addSubtitleSubject, subtitleSubject.Aid, subtitleSubject.Allow, subtitleSubject.Lan, subtitleSubject.Allow, subtitleSubject.Lan); err != nil {
+		log.Error("params(subtitleSubject:%+v),error(%v)", subtitleSubject, err)
+		return
+	}
+	return
+}
+
+// GetSubtitleSubject .
+func (d *Dao) GetSubtitleSubject(c context.Context, aid int64) (subtitleSubject *model.SubtitleSubject, err error) {
+	subtitleSubject = new(model.SubtitleSubject)
+	row := d.dbDM.QueryRow(c, _getSubtitleSubject, aid)
+	if err = row.Scan(&subtitleSubject.Aid, &subtitleSubject.Allow, &subtitleSubject.Attr, &subtitleSubject.Lan); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			subtitleSubject = nil
+			return
+		}
+		log.Error("params(aid:%v),error(%v)", aid, err)
+		return
+	}
+	return
+}
+
+// GetSubtitleIds .
+func (d *Dao) GetSubtitleIds(c context.Context, oid int64, tp int32) (subtitlIds []int64, err error) {
+	rows, err := d.dbDM.Query(c, _getSubtitlePubIds, oid, tp)
+	if err != nil {
+		log.Error("params(oid:%v,tp:%v),error(%v)", oid, tp, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var subtitleID int64
+		if err = rows.Scan(&subtitleID); err != nil {
+			log.Error("params(oid:%v,tp:%v),=error(%v)", oid, tp, err)
+			return
+		}
+		subtitlIds = append(subtitlIds, subtitleID)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("params(oid:%v,tp:%v),=error(%v)", oid, tp, err)
+		return
+	}
+	return
+}
+
+// GetSubtitles .
+func (d *Dao) GetSubtitles(c context.Context, oid int64, subtitleIds []int64) (subtitles []*model.Subtitle, err error) {
+	rows, err := d.dbDM.Query(c, fmt.Sprintf(_getSubtitles, d.hitSubtitle(oid), xstr.JoinInts(subtitleIds)))
+	if err != nil {
+		log.Error("params(subtitleIds:%v),=error(%v)", subtitleIds, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		subtitle := &model.Subtitle{}
+		var t time.Time
+		if err = rows.Scan(&subtitle.ID, &subtitle.Oid, &subtitle.Type, &subtitle.Lan, &subtitle.Aid, &subtitle.Mid, &subtitle.AuthorID, &subtitle.UpMid, &subtitle.IsSign, &subtitle.IsLock, &subtitle.Status, &subtitle.CheckSum, &subtitle.SubtitleURL, &subtitle.PubTime, &subtitle.RejectComment, &t); err != nil {
+			log.Error("params(subtitleIds:%v),=error(%v)", subtitleIds, err)
+			return
+		}
+		subtitle.Mtime = t.Unix()
+		subtitles = append(subtitles, subtitle)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("params(subtitleIds:%v),=error(%v)", subtitleIds, err)
+		return
+	}
+	return
+}
+
+// GetSubtitleDraft query a SubtitleDrfat
+func (d *Dao) GetSubtitleDraft(c context.Context, oid int64, tp int32, mid int64, lan uint8) (subtitle *model.Subtitle, err error) {
+	subtitle = &model.Subtitle{}
+	row := d.dbDM.QueryRow(c, fmt.Sprintf(_getSubtitleDraft, d.hitSubtitle(oid)), oid, tp, lan, mid)
+	if err = row.Scan(&subtitle.ID, &subtitle.Oid, &subtitle.Type, &subtitle.Lan, &subtitle.Aid, &subtitle.Mid, &subtitle.AuthorID, &subtitle.UpMid, &subtitle.IsSign, &subtitle.IsLock, &subtitle.Status, &subtitle.CheckSum, &subtitle.SubtitleURL, &subtitle.PubTime, &subtitle.RejectComment); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			subtitle = nil
+			return
+		}
+		log.Error("params(oid:%v, tp:%v, mid:%v, lan:%v),=error(%v)", oid, tp, mid, lan, err)
+		return
+	}
+	return
+}
+
+// GetSubtitle query a SubtitleDrfat
+func (d *Dao) GetSubtitle(c context.Context, oid int64, subtitleID int64) (subtitle *model.Subtitle, err error) {
+	var t time.Time
+	subtitle = &model.Subtitle{}
+	row := d.dbDM.QueryRow(c, fmt.Sprintf(_getSubtitle, d.hitSubtitle(oid)), subtitleID)
+	if err = row.Scan(&subtitle.ID, &subtitle.Oid, &subtitle.Type, &subtitle.Lan, &subtitle.Aid, &subtitle.Mid, &subtitle.AuthorID, &subtitle.UpMid, &subtitle.IsSign, &subtitle.IsLock, &subtitle.Status, &subtitle.CheckSum, &subtitle.SubtitleURL, &subtitle.PubTime, &subtitle.RejectComment, &t); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			subtitle = nil
+			return
+		}
+		log.Error("params(subtitleID:%v),error(%v)", subtitleID, err)
+		return
+	}
+	subtitle.Mtime = t.Unix()
+	return
+}
+
+// AddSubtitle .
+func (d *Dao) AddSubtitle(c context.Context, subtitle *model.Subtitle) (insertID int64, err error) {
+	var res sql.Result
+	if res, err = d.dbDM.Exec(c, fmt.Sprintf(_addSubtitle, d.hitSubtitle(subtitle.Oid)),
+		subtitle.ID, subtitle.Oid, subtitle.Type, subtitle.Lan, subtitle.Aid, subtitle.Mid, subtitle.AuthorID, subtitle.UpMid, subtitle.IsSign, subtitle.IsLock, subtitle.Status,
+		subtitle.CheckSum, subtitle.SubtitleURL, subtitle.PubTime, subtitle.RejectComment); err != nil {
+		log.Error("params(%+v),error(%v)", subtitle, err)
+		return
+	}
+	if insertID, err = res.LastInsertId(); err != nil {
+		log.Error("params(%+v),error(%v)", subtitle, err)
+		return
+	}
+	return
+}
+
+// UpdateSubtitle .
+func (d *Dao) UpdateSubtitle(c context.Context, subtitle *model.Subtitle) (err error) {
+	if _, err = d.dbDM.Exec(c, fmt.Sprintf(_updateSubtitle, d.hitSubtitle(subtitle.Oid)),
+		subtitle.Aid, subtitle.AuthorID, subtitle.UpMid, subtitle.IsSign, subtitle.IsLock, subtitle.Status, subtitle.CheckSum, subtitle.SubtitleURL, subtitle.PubTime, subtitle.RejectComment,
+		subtitle.ID); err != nil {
+		log.Error("params(%+v),error(%v)", subtitle, err)
+		return
+	}
+	return
+}
+
+// TxUpdateSubtitle .
+func (d *Dao) TxUpdateSubtitle(tx *xsql.Tx, subtitle *model.Subtitle) (err error) {
+	if _, err = tx.Exec(fmt.Sprintf(_updateSubtitle, d.hitSubtitle(subtitle.Oid)),
+		subtitle.Aid, subtitle.AuthorID, subtitle.UpMid, subtitle.IsSign, subtitle.IsLock, subtitle.Status, subtitle.CheckSum, subtitle.SubtitleURL, subtitle.PubTime, subtitle.RejectComment,
+		subtitle.ID); err != nil {
+		log.Error("params(%+v),error(%v)", subtitle, err)
+		return
+	}
+	return
+}
+
+// TxAddSubtitlePub .
+func (d *Dao) TxAddSubtitlePub(tx *xsql.Tx, subtitlePub *model.SubtitlePub) (err error) {
+	if _, err = tx.Exec(_addSubtitlePub, subtitlePub.Oid, subtitlePub.Type, subtitlePub.Lan, subtitlePub.SubtitleID, subtitlePub.IsDelete, subtitlePub.SubtitleID, subtitlePub.IsDelete); err != nil {
+		log.Error("params(%+v),error(%v)", subtitlePub, err)
+		return
+	}
+	return
+}
+
+// TxGetSubtitleOne .
+func (d *Dao) TxGetSubtitleOne(tx *xsql.Tx, oid int64, tp int32, lan uint8) (subtitle *model.Subtitle, err error) {
+	subtitle = &model.Subtitle{}
+	row := tx.QueryRow(fmt.Sprintf(_getSubtitleOne, d.hitSubtitle(oid)), oid, tp, lan)
+	if err = row.Scan(&subtitle.ID, &subtitle.Oid, &subtitle.Type, &subtitle.Lan, &subtitle.Aid, &subtitle.Mid, &subtitle.AuthorID, &subtitle.UpMid, &subtitle.IsSign, &subtitle.IsLock, &subtitle.Status, &subtitle.CheckSum, &subtitle.SubtitleURL, &subtitle.PubTime, &subtitle.RejectComment); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			subtitle = nil
+			return
+		}
+		log.Error("params(oid:%v, tp:%v, lan:%v),error(%v)", oid, tp, lan, err)
+		return
+	}
+	return
+}
+
+// SubtitleLans .
+func (d *Dao) SubtitleLans(c context.Context) (subtitleLans []*model.SubtitleLan, err error) {
+	rows, err := d.dbDM.Query(c, _getSubtitleLans)
+	if err != nil {
+		log.Error("params(query:%v),error(%v)", _getSubtitleLans, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		subtitleLan := new(model.SubtitleLan)
+		if err = rows.Scan(&subtitleLan.Code, &subtitleLan.Lan, &subtitleLan.DocZh); err != nil {
+			log.Error("params.Sacn(query:%v),error(%v)", _getSubtitleLans, err)
+			return
+		}
+		subtitleLans = append(subtitleLans, subtitleLan)
+	}
+	if err = rows.Err(); err != nil {
+		log.Error("params.Err(query:%v),error(%v)", _getSubtitleLans, err)
+		return
+	}
+	return
+}
+
+// SubtitleLanAdd .
+func (d *Dao) SubtitleLanAdd(c context.Context, subtitleLan *model.SubtitleLan) (err error) {
+	if _, err = d.dbDM.Exec(c, _addSubtitleLan, subtitleLan.Code, subtitleLan.Lan, subtitleLan.DocZh, subtitleLan.DocEn, subtitleLan.IsDelete, subtitleLan.Lan, subtitleLan.DocZh, subtitleLan.DocEn, subtitleLan.IsDelete); err != nil {
+		log.Error("SubtitleLanAdd.params(subtitleLan:%+v),error(%v)", subtitleLan, err)
+		return
+	}
+	return
+}
+
+// UpsertWaveFrom .
+func (d *Dao) UpsertWaveFrom(c context.Context, waveForm *model.WaveForm) (err error) {
+	if _, err = d.dbDM.Exec(c, _addWaveForm, waveForm.Oid, waveForm.Type, waveForm.State, waveForm.WaveFromURL, waveForm.State, waveForm.WaveFromURL); err != nil {
+		log.Error("params(waveForm:%+v),error(%v)", waveForm, err)
+		return
+	}
+	return
+}
+
+// GetWaveForm .
+func (d *Dao) GetWaveForm(c context.Context, oid int64, tp int32) (waveForm *model.WaveForm, err error) {
+	var t time.Time
+	row := d.dbDM.QueryRow(c, _getWaveForm, oid, tp)
+	waveForm = &model.WaveForm{}
+	if err = row.Scan(&waveForm.Oid, &waveForm.Type, &waveForm.State, &waveForm.WaveFromURL, &t); err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			waveForm = nil
+			return
+		}
+		log.Error("params(oid:%v, tp:%v),error(%v)", oid, tp, err)
+		return
+	}
+	waveForm.Mtime = t.Unix()
+	return
+}

app/interface/main/dm2/dao/mysql_subtitle_test.go

@@ -0,0 +1,260 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/interface/main/dm2/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaohitSubtitle(t *testing.T) {
+	convey.Convey("hitSubtitle", t, func(ctx convey.C) {
+		var (
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.hitSubtitle(oid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoAddSubtitleSubject(t *testing.T) {
+	convey.Convey("AddSubtitleSubject", t, func(ctx convey.C) {
+		var (
+			c               = context.Background()
+			subtitleSubject = &model.SubtitleSubject{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.AddSubtitleSubject(c, subtitleSubject)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGetSubtitleSubject(t *testing.T) {
+	convey.Convey("GetSubtitleSubject", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			aid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			subtitleSubject, err := testDao.GetSubtitleSubject(c, aid)
+			ctx.Convey("Then err should be nil.subtitleSubject should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(subtitleSubject, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGetSubtitleIds(t *testing.T) {
+	convey.Convey("GetSubtitleIds", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+			tp  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			subtitlIds, err := testDao.GetSubtitleIds(c, oid, tp)
+			ctx.Convey("Then err should be nil.subtitlIds should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(subtitlIds, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGetSubtitles(t *testing.T) {
+	convey.Convey("GetSubtitles", t, func(ctx convey.C) {
+		var (
+			c           = context.Background()
+			oid         = int64(0)
+			subtitleIds = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.GetSubtitles(c, oid, subtitleIds)
+		})
+	})
+}
+
+func TestDaoGetSubtitleDraft(t *testing.T) {
+	convey.Convey("GetSubtitleDraft", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+			tp  = int32(0)
+			mid = int64(0)
+			lan = uint8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			subtitle, err := testDao.GetSubtitleDraft(c, oid, tp, mid, lan)
+			ctx.Convey("Then err should be nil.subtitle should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(subtitle, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGetSubtitle(t *testing.T) {
+	convey.Convey("GetSubtitle", t, func(ctx convey.C) {
+		var (
+			c          = context.Background()
+			oid        = int64(0)
+			subtitleID = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.GetSubtitle(c, oid, subtitleID)
+		})
+	})
+}
+
+func TestDaoAddSubtitle(t *testing.T) {
+	convey.Convey("AddSubtitle", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			subtitle = &model.Subtitle{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.AddSubtitle(c, subtitle)
+		})
+	})
+}
+
+func TestDaoUpdateSubtitle(t *testing.T) {
+	convey.Convey("UpdateSubtitle", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			subtitle = &model.Subtitle{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.UpdateSubtitle(c, subtitle)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoTxUpdateSubtitle(t *testing.T) {
+	convey.Convey("TxUpdateSubtitle", t, func(ctx convey.C) {
+		var (
+			tx, _    = testDao.BeginBiliDMTrans(c)
+			subtitle = &model.Subtitle{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.TxUpdateSubtitle(tx, subtitle)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoTxAddSubtitlePub(t *testing.T) {
+	convey.Convey("TxAddSubtitlePub", t, func(ctx convey.C) {
+		var (
+			c           = context.Background()
+			tx, _       = testDao.BeginBiliDMTrans(c)
+			subtitlePub = &model.SubtitlePub{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.TxAddSubtitlePub(tx, subtitlePub)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoTxGetSubtitleOne(t *testing.T) {
+	convey.Convey("TxGetSubtitleOne", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tx, _ = testDao.BeginBiliDMTrans(c)
+			oid   = int64(0)
+			tp    = int32(0)
+			lan   = uint8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.TxGetSubtitleOne(tx, oid, tp, lan)
+		})
+		ctx.Reset(func() {
+			tx.Commit()
+		})
+	})
+}
+
+func TestDaoSubtitleLans(t *testing.T) {
+	convey.Convey("SubtitleLans", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			subtitleLans, err := testDao.SubtitleLans(c)
+			ctx.Convey("Then err should be nil.subtitleLans should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(subtitleLans, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSubtitleLanAdd(t *testing.T) {
+	convey.Convey("SubtitleLanAdd", t, func(ctx convey.C) {
+		var (
+			c           = context.Background()
+			subtitleLan = &model.SubtitleLan{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.SubtitleLanAdd(c, subtitleLan)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpsertWaveFrom(t *testing.T) {
+	convey.Convey("UpsertWaveFrom", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			waveForm = &model.WaveForm{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.UpsertWaveFrom(c, waveForm)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoGetWaveForm(t *testing.T) {
+	convey.Convey("GetWaveForm", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			oid = int64(0)
+			tp  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			waveForm, err := testDao.GetWaveForm(c, oid, tp)
+			ctx.Convey("Then err should be nil.waveForm should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(waveForm, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/interface/main/dm2/dao/mysql_test.go

@@ -0,0 +1,385 @@
+package dao
+
+import (
+	"context"
+	xtime "go-common/library/time"
+	"testing"
+	"time"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoSubject(t *testing.T) {
+	convey.Convey("Subject", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			tp  = int32(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.Subject(c, tp, oid)
+		})
+	})
+}
+
+func TestDaoSubjects(t *testing.T) {
+	convey.Convey("Subjects", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			tp   = int32(0)
+			oids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.Subjects(c, tp, oids)
+		})
+	})
+}
+
+func TestDaoUptSubAttr(t *testing.T) {
+	convey.Convey("UptSubAttr", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			tp   = int32(0)
+			oid  = int64(0)
+			attr = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			affect, err := testDao.UptSubAttr(c, tp, oid, attr)
+			ctx.Convey("Then err should be nil.affect should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(affect, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoIncrSubMoveCount(t *testing.T) {
+	convey.Convey("IncrSubMoveCount", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tp    = int32(0)
+			oid   = int64(0)
+			count = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			affect, err := testDao.IncrSubMoveCount(c, tp, oid, count)
+			ctx.Convey("Then err should be nil.affect should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(affect, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpSubjectMCount(t *testing.T) {
+	convey.Convey("UpSubjectMCount", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			tp  = int32(0)
+			oid = int64(0)
+			cnt = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			affect, err := testDao.UpSubjectMCount(c, tp, oid, cnt)
+			ctx.Convey("Then err should be nil.affect should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(affect, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpSubjectPool(t *testing.T) {
+	convey.Convey("UpSubjectPool", t, func(ctx convey.C) {
+		var (
+			c         = context.Background()
+			tp        = int32(0)
+			oid       = int64(0)
+			childpool = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			affect, err := testDao.UpSubjectPool(c, tp, oid, childpool)
+			ctx.Convey("Then err should be nil.affect should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(affect, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoIncrSubjectCount(t *testing.T) {
+	convey.Convey("IncrSubjectCount", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tp    = int32(0)
+			oid   = int64(0)
+			count = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			affect, err := testDao.IncrSubjectCount(c, tp, oid, count)
+			ctx.Convey("Then err should be nil.affect should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(affect, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDMIDs(t *testing.T) {
+	convey.Convey("DMIDs", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tp    = int32(0)
+			oid   = int64(0)
+			ps    = int64(0)
+			pe    = int64(0)
+			limit = int64(0)
+			pool  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.DMIDs(c, tp, oid, ps, pe, limit, pool)
+		})
+	})
+}
+
+func TestDaoIndexs(t *testing.T) {
+	convey.Convey("Indexs", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			tp  = int32(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.Indexs(c, tp, oid)
+		})
+	})
+}
+
+func TestDaoIndexByid(t *testing.T) {
+	convey.Convey("IndexByid", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			tp   = int8(0)
+			oid  = int64(0)
+			dmid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.IndexByid(c, tp, oid, dmid)
+		})
+	})
+}
+
+func TestDaoIndexsByid(t *testing.T) {
+	convey.Convey("IndexsByid", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tp    = int32(0)
+			oid   = int64(0)
+			dmids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.IndexsByid(c, tp, oid, dmids)
+		})
+	})
+}
+
+func TestDaoJudgeIndex(t *testing.T) {
+	convey.Convey("JudgeIndex", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			tp     = int8(0)
+			oid    = int64(0)
+			ctime1 = xtime.Time(time.Now().Unix())
+			ctime2 = xtime.Time(time.Now().Unix())
+			prog1  = int32(0)
+			prog2  = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.JudgeIndex(c, tp, oid, ctime1, ctime2, prog1, prog2)
+		})
+	})
+}
+
+func TestDaoContent(t *testing.T) {
+	convey.Convey("Content", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			oid  = int64(0)
+			dmid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ct, err := testDao.Content(c, oid, dmid)
+			ctx.Convey("Then err should be nil.ct should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ct, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoContents(t *testing.T) {
+	convey.Convey("Contents", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			oid   = int64(0)
+			dmids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ctsMap, err := testDao.Contents(c, oid, dmids)
+			ctx.Convey("Then err should be nil.ctsMap should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ctsMap, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoContentsSpecial(t *testing.T) {
+	convey.Convey("ContentsSpecial", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			dmids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.ContentsSpecial(c, dmids)
+		})
+	})
+}
+
+func TestDaoUpdateDMStat(t *testing.T) {
+	convey.Convey("UpdateDMStat", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tp    = int32(0)
+			oid   = int64(0)
+			state = int32(0)
+			dmids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UpdateDMStat(c, tp, oid, state, dmids)
+		})
+	})
+}
+
+func TestDaoUpdateUserDMStat(t *testing.T) {
+	convey.Convey("UpdateUserDMStat", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tp    = int32(0)
+			oid   = int64(0)
+			mid   = int64(0)
+			state = int32(0)
+			dmids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UpdateUserDMStat(c, tp, oid, mid, state, dmids)
+		})
+	})
+}
+
+func TestDaoUpdateDMPool(t *testing.T) {
+	convey.Convey("UpdateDMPool", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tp    = int32(0)
+			oid   = int64(0)
+			pool  = int32(0)
+			dmids = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.UpdateDMPool(c, tp, oid, pool, dmids)
+		})
+	})
+}
+
+func TestDaoUpdateDMAttr(t *testing.T) {
+	convey.Convey("UpdateDMAttr", t, func(ctx convey.C) {
+		var (
+			c    = context.Background()
+			tp   = int32(0)
+			oid  = int64(0)
+			dmid = int64(0)
+			attr = int32(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			affect, err := testDao.UpdateDMAttr(c, tp, oid, dmid, attr)
+			ctx.Convey("Then err should be nil.affect should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(affect, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDMCount(t *testing.T) {
+	convey.Convey("DMCount", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			typ    = int32(0)
+			oid    = int64(0)
+			states = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.DMCount(c, typ, oid, states)
+		})
+	})
+}
+
+func TestDaoSpecialDmLocation(t *testing.T) {
+	convey.Convey("SpecialDmLocation", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			tp  = int32(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.SpecialDmLocation(c, tp, oid)
+		})
+	})
+}
+
+func TestDaoSpecalDMs(t *testing.T) {
+	convey.Convey("SpecalDMs", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			tp  = int32(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.SpecalDMs(c, tp, oid)
+		})
+	})
+}
+
+func TestDaoAddUpperConfig(t *testing.T) {
+	convey.Convey("AddUpperConfig", t, func(ctx convey.C) {
+		var (
+			c         = context.Background()
+			mid       = int64(0)
+			advPermit = int8(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			affect, err := testDao.AddUpperConfig(c, mid, advPermit)
+			ctx.Convey("Then err should be nil.affect should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(affect, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoUpperConfig(t *testing.T) {
+	convey.Convey("UpperConfig", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			advPermit, err := testDao.UpperConfig(c, mid)
+			ctx.Convey("Then err should be nil.advPermit should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(advPermit, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/interface/main/dm2/dao/notify.go

@@ -0,0 +1,44 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+const (
+	_notifyURI = "/api/notify/send.user.notify.do"
+)
+
+func (d *Dao) notifyURI() string {
+	return d.conf.Host.Message + _notifyURI
+}
+
+// SendNotify 发送站内信
+func (d *Dao) SendNotify(c context.Context, title, content, dataType string, mids []int64) (err error) {
+	res := struct {
+		Code int `json:"code"`
+		Data struct {
+			TotalCount int
+			ErrorCount int
+		} `json:"data"`
+	}{}
+	params := url.Values{}
+	params.Set("mc", "1_8_2")
+	params.Set("title", title)
+	params.Set("data_type", dataType)
+	params.Set("context", content)
+	params.Set("mid_list", xstr.JoinInts(mids))
+	if err = d.httpCli.Post(c, d.notifyURI(), "", params, &res); err != nil {
+		log.Error("d.httpClient.Post(%s,%v,%d)", d.notifyURI(), params, err)
+		return
+	}
+	if res.Code != 0 {
+		err = fmt.Errorf("res.Code:;%d", res.Code)
+		log.Error("d.httpClient.Post(%s,%v,%v,%d)", d.notifyURI(), params, err, res.Code)
+	}
+	return
+}

app/interface/main/dm2/dao/notify_test.go

@@ -0,0 +1,34 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaonotifyURI(t *testing.T) {
+	convey.Convey("notifyURI", t, func(ctx convey.C) {
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := testDao.notifyURI()
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoSendNotify(t *testing.T) {
+	convey.Convey("SendNotify", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			title    = ""
+			content  = ""
+			dataType = ""
+			mids     = []int64{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.SendNotify(c, title, content, dataType, mids)
+		})
+	})
+}

app/interface/main/dm2/dao/redis.go

@@ -0,0 +1,171 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/cache/redis"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	// dm xml list v1
+	_prefixDM = "dm_v1_%d_%d" // dm_v1_type_oid
+
+	_broadcastLimitFmt = "b_room_%d_%d" // b_room_type_oid
+)
+
+func keyDM(tp int32, oid int64) (key string) {
+	return fmt.Sprintf(_prefixDM, tp, oid)
+}
+
+func keyBroadcastLimit(tp int32, oid int64) (key string) {
+	return fmt.Sprintf(_broadcastLimitFmt, tp, oid)
+}
+
+// DMCache 获取redis列表中的弹幕.
+func (d *Dao) DMCache(c context.Context, tp int32, oid int64) (res [][]byte, err error) {
+	conn := d.dmRds.Get(c)
+	key := keyDM(tp, oid)
+	if res, err = redis.ByteSlices(conn.Do("ZRANGE", key, 0, -1)); err != nil {
+		log.Error("conn.Do(ZRANGE %s) error(%v)", key, err)
+	}
+	conn.Close()
+	return
+}
+
+// ExpireDMCache expire dm.
+func (d *Dao) ExpireDMCache(c context.Context, tp int32, oid int64) (ok bool, err error) {
+	key := keyDM(tp, oid)
+	conn := d.dmRds.Get(c)
+	if ok, err = redis.Bool(conn.Do("EXPIRE", key, d.dmRdsExpire)); err != nil {
+		log.Error("conn.Do(EXPIRE %s) error(%v)", key, err)
+	}
+	conn.Close()
+	return
+}
+
+// TrimDMCache 从redis列表中pop掉count条弹幕.
+func (d *Dao) TrimDMCache(c context.Context, tp int32, oid, count int64) (err error) {
+	conn := d.dmRds.Get(c)
+	key := keyDM(tp, oid)
+	if _, err = conn.Do("ZREMRANGEBYRANK", key, 0, count-1); err != nil {
+		log.Error("conn.Do(ZREMRANGEBYRANK %s) error(%v)", key, err)
+	}
+	conn.Close()
+	return
+}
+
+// IncrPubCnt increase pub count of user.
+func (d *Dao) IncrPubCnt(c context.Context, mid, color int64, mode, fontsize int32, ip, msg string) (err error) {
+	conn := d.dmRds.Get(c)
+	defer conn.Close()
+	key := keyPubCntLock(mid, color, mode, fontsize, ip, msg)
+	if err = conn.Send("INCR", key); err != nil {
+		log.Error("conn.Send(INCR %s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Send("EXPIRE", key, 300); err != nil {
+		log.Error("conn.Send(EXPIRE %s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("conn.Flush() error(%v)", err)
+		return
+	}
+	for i := 0; i < 2; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error("conn.Receive() error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// PubCnt get dm pub count of user.
+func (d *Dao) PubCnt(c context.Context, mid, color int64, mode, fontsize int32, ip, msg string) (count int64, err error) {
+	conn := d.dmRds.Get(c)
+	defer conn.Close()
+	key := keyPubCntLock(mid, color, mode, fontsize, ip, msg)
+	if count, err = redis.Int64(conn.Do("GET", key)); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+		} else {
+			log.Error("conn.Do(GET %s) error(%v)", key, err)
+		}
+		return
+	}
+	return
+}
+
+// IncrCharPubCnt increase character pub count of user.
+func (d *Dao) IncrCharPubCnt(c context.Context, mid, oid int64) (err error) {
+	conn := d.dmRds.Get(c)
+	defer conn.Close()
+	key := keyCharPubLock(mid, oid)
+	if err = conn.Send("INCR", key); err != nil {
+		log.Error("conn.Send(INCR %s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Send("EXPIRE", key, 60); err != nil {
+		log.Error("conn.Send(EXPIRE %s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("conn.Flush() error(%v)", err)
+		return
+	}
+	for i := 0; i < 2; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error("conn.Receive() error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// CharPubCnt get character pub count of user.
+func (d *Dao) CharPubCnt(c context.Context, mid, oid int64) (count int64, err error) {
+	conn := d.dmRds.Get(c)
+	defer conn.Close()
+	key := keyCharPubLock(mid, oid)
+	if count, err = redis.Int64(conn.Do("GET", key)); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+		} else {
+			log.Error("conn.Do(GET %s) error(%v)", key, err)
+		}
+		return
+	}
+	return
+}
+
+// DelCharPubCnt delete char
+func (d *Dao) DelCharPubCnt(c context.Context, mid, oid int64) (err error) {
+	conn := d.dmRds.Get(c)
+	key := keyCharPubLock(mid, oid)
+	if _, err = conn.Do("DEL", key); err != nil {
+		log.Error("conn.Do(DEL %s) error(%v)", key, err)
+	}
+	conn.Close()
+	return
+}
+
+// BroadcastLimit .
+func (d *Dao) BroadcastLimit(c context.Context, oid int64, tp int32, count, interval int) (err error) {
+	conn := d.dmRds.Get(c)
+	key := keyBroadcastLimit(tp, oid)
+	defer conn.Close()
+	incred, err := redis.Int64(conn.Do("INCR", key))
+	if err != nil {
+		return nil
+	}
+	if incred == 1 {
+		conn.Do("EXPIRE", key, interval)
+	}
+	if incred > int64(count) {
+		return ecode.LimitExceed
+	}
+	return
+}

app/interface/main/dm2/dao/redis_rct.go

@@ -0,0 +1,75 @@
+package dao
+
+import (
+	"context"
+	"strconv"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/cache/redis"
+	"go-common/library/log"
+)
+
+const (
+	_prefixRecent = "dm_rct_"
+)
+
+func keyRecent(mid int64) string {
+	return _prefixRecent + strconv.FormatInt(mid, 10)
+}
+
+// RecentDM get recent dm of up.
+func (d *Dao) RecentDM(c context.Context, mid, start, end int64) (dms []*model.DM, oids []int64, total int64, err error) {
+	var (
+		conn   = d.dmRctRds.Get(c)
+		key    = keyRecent(mid)
+		oidMap = make(map[int64]struct{})
+	)
+	defer conn.Close()
+	if err = conn.Send("ZREVRANGE", key, start, end); err != nil {
+		log.Error("conn.Send(ZREVRANGE %s) error(%s)", key, err)
+		return
+	}
+	if err = conn.Send("ZCARD", key); err != nil {
+		log.Error("conn.Send(ZCARD %s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("conn.Flush() error(%v)", err)
+		return
+	}
+	values, err := redis.ByteSlices(conn.Receive())
+	if err != nil {
+		log.Error("conn.Receive(%s) error(%v)", key, err)
+		return
+	}
+	if total, err = redis.Int64(conn.Receive()); err != nil {
+		log.Error("conn.Receive(%s) error(%v)", key, err)
+		return
+	}
+	for _, value := range values {
+		dm := &model.DM{}
+		if err = dm.Unmarshal(value); err != nil {
+			log.Error("dm.Unmarshal(%s) error(%v)", value, err)
+			return
+		}
+		dms = append(dms, dm)
+		if _, ok := oidMap[dm.Oid]; !ok {
+			oidMap[dm.Oid] = struct{}{}
+			oids = append(oids, dm.Oid)
+		}
+	}
+	return
+}
+
+// TrimUpRecent zrange remove recent dm of up.
+func (d *Dao) TrimUpRecent(c context.Context, mid, count int64) (err error) {
+	var (
+		conn = d.dmRctRds.Get(c)
+		key  = keyRecent(mid)
+	)
+	defer conn.Close()
+	if _, err = conn.Do("ZREMRANGEBYRANK", key, 0, count-1); err != nil {
+		log.Error("conn.Do(ZREMRANGEBYRANK %s) error(%v)", key, err)
+	}
+	return
+}

app/interface/main/dm2/dao/redis_rct_test.go

@@ -0,0 +1,52 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaokeyRecent(t *testing.T) {
+	convey.Convey("keyRecent", t, func(ctx convey.C) {
+		var (
+			mid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := keyRecent(mid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoRecentDM(t *testing.T) {
+	convey.Convey("RecentDM", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			mid   = int64(0)
+			start = int64(0)
+			end   = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.RecentDM(c, mid, start, end)
+		})
+	})
+}
+
+func TestDaoTrimUpRecent(t *testing.T) {
+	convey.Convey("TrimUpRecent", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			mid   = int64(0)
+			count = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.TrimUpRecent(c, mid, count)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/interface/main/dm2/dao/redis_seg.go

@@ -0,0 +1,209 @@
+package dao
+
+import (
+	"context"
+	"encoding/xml"
+	"fmt"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/cache/redis"
+	"go-common/library/log"
+)
+
+const (
+	_keyIdx        = "i_%d_%d_%d_%d" // normal dm segment sortedset(s_type_oid_cnt_n, ctime, dmid)
+	_keyIdxSub     = "s_%d_%d"       // subtitle dm sortedset(s_type_oid, progress, dmid)
+	_keyIdxSpe     = "spe_%d_%d"     // special dm sortedset(spe_type_oid, progress,dmid)
+	_keyIdxContent = "c_%d_%d"       // dm content hash(d_type_oid, dmid, xml)
+)
+
+func keyIdx(tp int32, oid, cnt, n int64) string {
+	return fmt.Sprintf(_keyIdx, tp, oid, cnt, n)
+}
+
+// keyIdxSub return dm idx key.
+func keyIdxSub(tp int32, oid int64) string {
+	return fmt.Sprintf(_keyIdxSub, tp, oid)
+}
+
+// keyIdxContent return key of different dm.
+func keyIdxContent(tp int32, oid int64) string {
+	return fmt.Sprintf(_keyIdxContent, tp, oid)
+}
+
+func keyIdxSpecial(tp int32, oid int64) string {
+	return fmt.Sprintf(_keyIdxSpe, tp, oid)
+}
+
+// DMIDSubtitlesCache return subtitle dm ids.
+func (d *Dao) DMIDSubtitlesCache(c context.Context, tp int32, oid int64, ps, pe, limit int64) (dmids []int64, err error) {
+	var (
+		conn   = d.dmSegRds.Get(c)
+		keySub = keyIdxSub(tp, oid)
+	)
+	defer conn.Close()
+	if dmids, err = redis.Int64s(conn.Do("ZRANGEBYSCORE", keySub, ps, pe, "LIMIT", 0, limit)); err != nil {
+		log.Error("conn.DO(ZRANGEBYSCORE %s) error(%v)", keySub, err)
+	}
+	if len(dmids) > 0 {
+		PromCacheHit("dm_seg_dmid", 1)
+	} else {
+		PromCacheMiss("dm_seg_dmid", 1)
+	}
+	return
+}
+
+// DMIDCache return dm index id.
+func (d *Dao) DMIDCache(c context.Context, tp int32, oid int64, cnt, n, limit int64) (dmids []int64, err error) {
+	var (
+		conn   = d.dmSegRds.Get(c)
+		keyIdx = keyIdx(tp, oid, cnt, n)
+	)
+	defer conn.Close()
+	if dmids, err = redis.Int64s(conn.Do("ZRANGE", keyIdx, 0, -1)); err != nil {
+		log.Error("DMIDSPCache.conn.DO(ZRANGEBYSCORE %s) error(%v)", keyIdx, err)
+	}
+	if len(dmids) > 0 {
+		PromCacheHit("dm_seg_dmid", 1)
+	} else {
+		PromCacheMiss("dm_seg_dmid", 1)
+	}
+	return
+}
+
+// IdxContentCache get xml info by dmid.
+func (d *Dao) IdxContentCache(c context.Context, tp int32, oid int64, dmids []int64) (res []byte, missed []int64, err error) {
+	var (
+		k      int
+		dmid   int64
+		values [][]byte
+		key    = keyIdxContent(tp, oid)
+		args   = []interface{}{key}
+	)
+	for _, dmid = range dmids {
+		args = append(args, dmid)
+	}
+	conn := d.dmSegRds.Get(c)
+	defer conn.Close()
+	if values, err = redis.ByteSlices(conn.Do("HMGET", args...)); err != nil {
+		log.Error("conn.Do(HMGET %v) error(%v)", args, err)
+		if err == redis.ErrNil {
+			return nil, nil, nil
+		}
+		return
+	}
+	for k, dmid = range dmids {
+		if len(values[k]) == 0 {
+			missed = append(missed, dmid)
+			continue
+		}
+		res = append(res, values[k]...)
+	}
+	PromCacheMiss("dmid_content", int64(len(missed)))
+	PromCacheHit("dmid_content", int64(len(dmids)-len(missed)))
+	return
+}
+
+// IdxContentCacheV2 get elems info by dmid.
+func (d *Dao) IdxContentCacheV2(c context.Context, tp int32, oid int64, dmids []int64) (elems []*model.Elem, missed []int64, err error) {
+	var (
+		k      int
+		dmid   int64
+		values [][]byte
+		key    = keyIdxContent(tp, oid)
+		args   = []interface{}{key}
+	)
+	for _, dmid = range dmids {
+		args = append(args, dmid)
+	}
+	conn := d.dmSegRds.Get(c)
+	defer conn.Close()
+	if values, err = redis.ByteSlices(conn.Do("HMGET", args...)); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+			missed = dmids
+		} else {
+			log.Error("conn.Do(HMGET %v) error(%v)", args, err)
+		}
+		return
+	}
+	for k, dmid = range dmids {
+		if len(values[k]) == 0 {
+			missed = append(missed, dmid)
+			continue
+		}
+		elem, err := d.xmlToElem(values[k])
+		if err != nil {
+			missed = append(missed, dmid)
+			continue
+		}
+		elems = append(elems, elem)
+	}
+	PromCacheMiss("dmid_elem", int64(len(missed)))
+	PromCacheHit("dmid_elem", int64(len(dmids)-len(missed)))
+	return
+}
+
+// 在缓存过渡期将<d p="弹幕ID,弹幕属性,播放时间,弹幕模式,字体大小,颜色,发送时间,弹幕池,用户hash id">弹幕内容</d>
+// 装换为 model.Elem结构
+func (d *Dao) xmlToElem(data []byte) (e *model.Elem, err error) {
+	var v struct {
+		XMLName   xml.Name `xml:"d"`
+		Attribute string   `xml:"p,attr"`
+		Content   string   `xml:",chardata"`
+	}
+	if err = xml.Unmarshal(data, &v); err != nil {
+		return
+	}
+	e = &model.Elem{Content: v.Content, Attribute: v.Attribute}
+	return
+}
+
+// AddIdxContentCache add index content cache to redis.
+func (d *Dao) AddIdxContentCache(c context.Context, tp int32, oid int64, dms []*model.DM, realname bool) (err error) {
+	var (
+		key  string
+		conn = d.dmSegRds.Get(c)
+	)
+	defer conn.Close()
+	for _, dm := range dms {
+		key = keyIdxContent(tp, oid)
+		if err = conn.Send("HSET", key, dm.ID, dm.ToXMLSeg(realname)); err != nil {
+			log.Error("conn.Send(HSET %s,%v) error(%v)", key, dm, err)
+			return
+		}
+	}
+	if err = conn.Send("EXPIRE", key, d.dmSegExpire); err != nil {
+		log.Error("conn.Send(EXPIRE %s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("conn.Flush() error(%v)", err)
+		return
+	}
+	for i := 0; i <= len(dms); i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error("conn.Receive() error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// DMIDSpecialsCache return special dmids
+func (d *Dao) DMIDSpecialsCache(c context.Context, tp int32, oid int64) (dmids []int64, err error) {
+	var (
+		conn   = d.dmSegRds.Get(c)
+		keySpe = keyIdxSpecial(tp, oid)
+	)
+	defer conn.Close()
+	if dmids, err = redis.Int64s(conn.Do("ZRANGE", keySpe, 0, -1)); err != nil {
+		log.Error("conn.DO(ZRANGE %s) error(%v)", keySpe, err)
+	}
+	if len(dmids) > 0 {
+		PromCacheHit("dm_spe_dmid", 1)
+	} else {
+		PromCacheMiss("dm_spe_dmid", 1)
+	}
+	return
+}

app/interface/main/dm2/dao/redis_seg_test.go

@@ -0,0 +1,46 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestDMIDCache(t *testing.T) {
+	var (
+		tp  int32 = 1
+		oid int64 = 1508
+		cnt int64 = 26
+		num int64 = 1
+		c         = context.TODO()
+	)
+	_, err := testDao.DMIDCache(c, tp, oid, cnt, num, 100)
+	if err != nil {
+		t.Fatalf("d.DMIDCache(%d %d %d %d) error(%v)", tp, oid, cnt, num, err)
+	}
+}
+
+func TestIdxContentCache(t *testing.T) {
+	var (
+		tp    int32 = 1
+		oid   int64 = 1508
+		c           = context.TODO()
+		dmids       = []int64{2355015081, 2356915089}
+	)
+	res, missed, err := testDao.IdxContentCache(c, tp, oid, dmids)
+	if err != nil {
+		t.Errorf("d.IdxContentCache(%d %d %v) error(%v)", tp, oid, dmids, err)
+		t.FailNow()
+	}
+	t.Logf("res:%s, missed:%v", res, missed)
+}
+
+func TestXMLToElem(t *testing.T) {
+	Convey("convert xml tag to elem struct", t, func() {
+		s := []byte(`<d p="1,1,1,1,11,111,11,1,23123123">弹幕内容</d>`)
+		elem, err := testDao.xmlToElem(s)
+		So(err, ShouldBeNil)
+		t.Logf("%+v", elem)
+	})
+}

app/interface/main/dm2/dao/redis_test.go

@@ -0,0 +1,194 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaokeyDM(t *testing.T) {
+	convey.Convey("keyDM", t, func(ctx convey.C) {
+		var (
+			tp  = int32(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			key := keyDM(tp, oid)
+			ctx.Convey("Then key should not be nil.", func(ctx convey.C) {
+				ctx.So(key, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaokeyBroadcastLimit(t *testing.T) {
+	convey.Convey("keyBroadcastLimit", t, func(ctx convey.C) {
+		var (
+			tp  = int32(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			key := keyBroadcastLimit(tp, oid)
+			ctx.Convey("Then key should not be nil.", func(ctx convey.C) {
+				ctx.So(key, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDMCache(t *testing.T) {
+	convey.Convey("DMCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			tp  = int32(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := testDao.DMCache(c, tp, oid)
+			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 TestDaoExpireDMCache(t *testing.T) {
+	convey.Convey("ExpireDMCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			tp  = int32(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			ok, err := testDao.ExpireDMCache(c, tp, oid)
+			ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(ok, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoTrimDMCache(t *testing.T) {
+	convey.Convey("TrimDMCache", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			tp    = int32(0)
+			oid   = int64(0)
+			count = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.TrimDMCache(c, tp, oid, count)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoIncrPubCnt(t *testing.T) {
+	convey.Convey("IncrPubCnt", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(0)
+			color    = int64(0)
+			mode     = int32(0)
+			fontsize = int32(0)
+			ip       = ""
+			msg      = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.IncrPubCnt(c, mid, color, mode, fontsize, ip, msg)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoPubCnt(t *testing.T) {
+	convey.Convey("PubCnt", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(0)
+			color    = int64(0)
+			mode     = int32(0)
+			fontsize = int32(0)
+			ip       = ""
+			msg      = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := testDao.PubCnt(c, mid, color, mode, fontsize, ip, msg)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(count, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoIncrCharPubCnt(t *testing.T) {
+	convey.Convey("IncrCharPubCnt", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.IncrCharPubCnt(c, mid, oid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoCharPubCnt(t *testing.T) {
+	convey.Convey("CharPubCnt", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := testDao.CharPubCnt(c, mid, oid)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(count, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoDelCharPubCnt(t *testing.T) {
+	convey.Convey("DelCharPubCnt", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			mid = int64(0)
+			oid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.DelCharPubCnt(c, mid, oid)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoBroadcastLimit(t *testing.T) {
+	convey.Convey("BroadcastLimit", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			oid      = int64(0)
+			tp       = int32(0)
+			count    = int(0)
+			interval = int(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.BroadcastLimit(c, oid, tp, count, interval)
+		})
+	})
+}

app/interface/main/dm2/dao/search.go

@@ -0,0 +1,418 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/database/elastic"
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+var (
+	_dataTimeFormat = "2006-01-02 15:03:04"
+
+	_subtitleFields = []string{"oid", "id"}
+
+	_dmRecentFields = []string{"attr", "color", "ctime", "fontsize", "id", "mid", "mode", "msg", "mtime", "oid", "pool", "progress", "state", "type", "pid"}
+)
+
+func hisDateIndex(month string) string {
+	return "dm_date_" + strings.Replace(month, "-", "_", -1)
+}
+
+// SearchDMHisIndex get dm date index by oid from search.
+func (d *Dao) SearchDMHisIndex(c context.Context, tp int32, oid int64, month string) (dates []string, err error) {
+	var (
+		pn, ps = 1, 31
+		res    model.SearchHistoryIdxResult
+	)
+	req := d.elastic.NewRequest("dm_date")
+	req.Fields("date").WhereEq("oid", oid)
+	req.Index(hisDateIndex(month)).Pn(pn).Ps(ps).Order("date", "asc")
+	if err = req.Scan(c, &res); err != nil {
+		log.Error("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	for _, v := range res.Result {
+		dates = append(dates, v.Date)
+	}
+	return
+}
+
+// SearchDMHistory get history dmid from search.
+// 搜索定制api，改动需要沟通
+func (d *Dao) SearchDMHistory(c context.Context, tp int32, oid, ctimeTo int64, pn, ps int) (dmids []int64, err error) {
+	var (
+		res model.SearchHistoryResult
+		end = time.Unix(ctimeTo, 0).Format("2006-01-02 15:04:05")
+	)
+	req := d.elastic.NewRequest("dm_history")
+	req.Index(fmt.Sprintf("dm_search_%03d", oid%_indexSharding))
+	req.Fields("id").WhereEq("oid", oid).WhereIn("state", []int64{0, 2, 6})
+	req.WhereRange("ctime", nil, end, elastic.RangeScopeLcRc)
+	req.Pn(pn).Ps(ps).Order("ctime", "desc")
+	if err = req.Scan(c, &res); err != nil {
+		log.Error("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	for _, v := range res.Result {
+		dmids = append(dmids, v.ID)
+	}
+	return
+}
+
+// SearchDM 搜索弹幕
+func (d *Dao) SearchDM(c context.Context, p *model.SearchDMParams) (res *model.SearchDMData, err error) {
+	req := d.elastic.NewRequest("dm_search")
+	req.Fields("id").Index(fmt.Sprintf("dm_search_%03d", p.Oid%_indexSharding)).WhereEq("oidstr", p.Oid)
+	if p.Mids != "" {
+		mids, _ := xstr.SplitInts(p.Mids)
+		req.WhereIn("mid", mids)
+	}
+	if p.State != "" {
+		states, _ := xstr.SplitInts(p.State)
+		req.WhereIn("state", states)
+	}
+	if p.Mode != "" {
+		modes, _ := xstr.SplitInts(p.Mode)
+		req.WhereIn("mode", modes)
+	}
+	if p.Pool != "" {
+		pools, _ := xstr.SplitInts(p.Pool)
+		req.WhereIn("pool", pools)
+	}
+	if p.Attrs != "" {
+		attrs, _ := xstr.SplitInts(p.Attrs)
+		req.WhereIn("attr_format", attrs)
+	}
+	req.WhereEq("type", p.Type)
+	switch {
+	case p.ProgressFrom != model.CondIntNil && p.ProgressTo != model.CondIntNil:
+		req.WhereRange("progress_long", p.ProgressFrom, p.ProgressTo, elastic.RangeScopeLcRc)
+	case p.ProgressFrom != model.CondIntNil:
+		req.WhereRange("progress_long", p.ProgressFrom, nil, elastic.RangeScopeLcRc)
+	case p.ProgressTo != model.CondIntNil:
+		req.WhereRange("progress_long", nil, p.ProgressTo, elastic.RangeScopeLcRc)
+	}
+	req.WhereRange("ctime", p.CtimeFrom, p.CtimeTo, elastic.RangeScopeLcRc)
+	if p.Keyword != "" {
+		req.WhereLike([]string{"msg"}, []string{p.Keyword}, true, elastic.LikeLevelHigh)
+		req.OrderScoreFirst(true)
+	}
+	if p.Order == "progress" {
+		p.Order = "progress_long"
+	}
+	req.Order(p.Order, p.Sort)
+	req.Pn(int(p.Pn)).Ps(int(p.Ps))
+	res = &model.SearchDMData{}
+	if err = req.Scan(c, &res); err != nil {
+		log.Error("search params(%s), error(%v)", req.Params(), err)
+	}
+	return
+}
+
+// UptSearchDMState update dm search state
+func (d *Dao) UptSearchDMState(c context.Context, dmids []int64, oid int64, state, tp int32) (err error) {
+	upt := d.elastic.NewUpdate("dm_search")
+	for _, dmid := range dmids {
+		data := &model.UptSearchDMState{
+			ID:    dmid,
+			Oid:   oid,
+			State: state,
+			Type:  tp,
+			Mtime: time.Now().Format("2006-01-02 15:04:05"),
+		}
+		upt.AddData(fmt.Sprintf("dm_search_%03d", oid%_indexSharding), data)
+	}
+	if err = upt.Do(c); err != nil {
+		log.Error("update.Do() params(%s) error(%v)", upt.Params(), err)
+	}
+	return
+}
+
+// UptSearchDMPool update dm search pool
+func (d *Dao) UptSearchDMPool(c context.Context, dmids []int64, oid int64, pool, tp int32) (err error) {
+	upt := d.elastic.NewUpdate("dm_search")
+	for _, dmid := range dmids {
+		data := &model.UptSearchDMPool{
+			ID:    dmid,
+			Oid:   oid,
+			Pool:  pool,
+			Type:  tp,
+			Mtime: time.Now().Format("2006-01-02 15:04:05"),
+		}
+		upt.AddData(fmt.Sprintf("dm_search_%03d", oid%_indexSharding), data)
+	}
+	if err = upt.Do(c); err != nil {
+		log.Error("update.Do() params(%s) error(%v)", upt.Params(), err)
+	}
+	return
+}
+
+// UptSearchDMAttr update dm search attr
+func (d *Dao) UptSearchDMAttr(c context.Context, dmids []int64, oid int64, attr, tp int32) (err error) {
+	var bits []int64
+	for k, v := range strconv.FormatInt(int64(attr), 2) {
+		if v == 49 {
+			bits = append(bits, int64(k+1))
+		}
+	}
+	upt := d.elastic.NewUpdate("dm_search")
+	for _, dmid := range dmids {
+		data := &model.UptSearchDMAttr{
+			ID:         dmid,
+			Oid:        oid,
+			Attr:       attr,
+			AttrFormat: bits,
+			Type:       tp,
+			Mtime:      time.Now().Format("2006-01-02 15:04:05"),
+		}
+		upt.AddData(fmt.Sprintf("dm_search_%03d", oid%_indexSharding), data)
+	}
+	if err = upt.Do(c); err != nil {
+		log.Error("update.Do() params(%s) error(%v)", upt.Params(), err)
+	}
+	return
+}
+
+// SearchSubtitles .
+func (d *Dao) SearchSubtitles(c context.Context, page, size int32, mid int64, upMids []int64, aid, oid int64, tp int32, status []int64) (res *model.SearchSubtitleResult, err error) {
+	var (
+		req    *elastic.Request
+		fields []string
+	)
+	fields = _subtitleFields
+	req = d.elastic.NewRequest("dm_subtitle").Index("subtitle").Fields(fields...).Pn(int(page)).Ps(int(size))
+	if mid > 0 {
+		req.WhereEq("mid", mid)
+	}
+	if aid > 0 {
+		req.WhereEq("aid", aid)
+	}
+	if oid > 0 {
+		req.WhereEq("oid", oid)
+		req.WhereEq("type", tp)
+	}
+
+	switch {
+	case len(upMids) > 0 && len(status) > 0:
+		cmbs := &elastic.Combo{}
+		cmbu := &elastic.Combo{}
+		var (
+			statusInf []interface{}
+			upMidsInf []interface{}
+		)
+		for _, s := range status {
+			statusInf = append(statusInf, s)
+		}
+		for _, s := range upMids {
+			upMidsInf = append(upMidsInf, s)
+		}
+		cmbs.ComboIn([]map[string][]interface{}{
+			{"status": statusInf},
+		})
+		cmbu.ComboIn([]map[string][]interface{}{
+			{"up_mid": upMidsInf},
+		})
+		req = req.WhereCombo(cmbs.MinIn(1).MinAll(1), cmbu.MinIn(1).MinAll(1))
+	case len(upMids) > 0:
+		req.WhereIn("up_mid", upMids)
+	case len(status) > 0:
+		req.WhereIn("status", status)
+	}
+	req.Order("mtime", "desc")
+	if err = req.Scan(c, &res); err != nil {
+		log.Error("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	return
+}
+
+// CountSubtitles .
+func (d *Dao) CountSubtitles(c context.Context, mid int64, upMids []int64, aid, oid int64, tp int32) (countSubtitle *model.CountSubtitleResult, err error) {
+	var (
+		req           *elastic.Request
+		fields        []string
+		res           map[string]interface{}
+		_searchStatus = []string{
+			fmt.Sprint(model.SubtitleStatusDraft),
+			fmt.Sprint(model.SubtitleStatusToAudit),
+			fmt.Sprint(model.SubtitleStatusAuditBack),
+			fmt.Sprint(model.SubtitleStatusPublish),
+			fmt.Sprint(model.SubtitleStatusCheckToAudit),
+			fmt.Sprint(model.SubtitleStatusCheckPublish),
+			fmt.Sprint(model.SubtitleStatusManagerBack),
+		}
+		result      map[string]interface{}
+		groupStatus []interface{}
+		itemStatus  map[string]interface{}
+		ok          bool
+	)
+	req = d.elastic.NewRequest("dm_subtitle").Index("subtitle").Fields(fields...).Pn(0).Ps(0)
+	if mid > 0 {
+		req.WhereEq("mid", mid)
+	}
+	if aid > 0 {
+		req.WhereEq("aid", aid)
+	}
+	if oid > 0 {
+		req.WhereEq("oid", oid)
+		req.WhereEq("type", tp)
+	}
+	if len(upMids) > 0 {
+		req.WhereIn("up_mid", upMids)
+	}
+	req = req.GroupBy(elastic.EnhancedModeGroupBy, "status", nil).WhereIn("status", _searchStatus)
+	if err = req.Scan(c, &res); err != nil {
+		log.Error("elastic search(%s) error(%v)", req.Params(), err)
+		return
+	}
+	countSubtitle = &model.CountSubtitleResult{}
+	if result, ok = res["result"].(map[string]interface{}); !ok {
+		return
+	}
+	if groupStatus, ok = result["group_by_status"].([]interface{}); !ok {
+		return
+	}
+	for _, item := range groupStatus {
+		if itemStatus, ok = item.(map[string]interface{}); ok {
+			docCount, _ := itemStatus["doc_count"].(float64)
+			switch itemStatus["key"] {
+			case fmt.Sprint(model.SubtitleStatusDraft):
+				countSubtitle.Draft += int64(docCount)
+			case fmt.Sprint(model.SubtitleStatusToAudit):
+				countSubtitle.ToAudit += int64(docCount)
+			case fmt.Sprint(model.SubtitleStatusAuditBack):
+				countSubtitle.AuditBack += int64(docCount)
+			case fmt.Sprint(model.SubtitleStatusPublish):
+				countSubtitle.Publish += int64(docCount)
+			case fmt.Sprint(model.SubtitleStatusCheckToAudit):
+				countSubtitle.ToAudit += int64(docCount)
+			case fmt.Sprint(model.SubtitleStatusCheckPublish):
+				countSubtitle.Publish += int64(docCount)
+			case fmt.Sprint(model.SubtitleStatusManagerBack):
+				countSubtitle.AuditBack += int64(docCount)
+			}
+		}
+	}
+	return
+}
+
+// UptSearchRecentState .
+func (d *Dao) UptSearchRecentState(c context.Context, dmids []int64, oid int64, state, tp int32) (err error) {
+	upt := d.elastic.NewUpdate("dm_home")
+	year, month, _ := time.Now().Date()
+	yearPre, monthPre, _ := time.Now().AddDate(0, -1, 0).Date()
+	for _, dmid := range dmids {
+		data := &model.UptSearchDMState{
+			ID:    dmid,
+			Oid:   oid,
+			State: state,
+			Type:  tp,
+			Mtime: time.Now().Format("2006-01-02 15:04:05"),
+		}
+		upt.AddData(fmt.Sprintf("dm_home_%v",
+			fmt.Sprintf("%d_%02d", yearPre, int(monthPre)),
+		), data)
+		upt.AddData(fmt.Sprintf("dm_home_%v",
+			fmt.Sprintf("%d_%02d", year, int(month)),
+		), data)
+	}
+	if err = upt.Do(c); err != nil {
+		log.Error("update.Do() params(%s) error(%v)", upt.Params(), err)
+	}
+	return
+}
+
+// UptSearchRecentAttr .
+func (d *Dao) UptSearchRecentAttr(c context.Context, dmids []int64, oid int64, attr, tp int32) (err error) {
+	var bits []int64
+	for k, v := range strconv.FormatInt(int64(attr), 2) {
+		if v == 49 {
+			bits = append(bits, int64(k+1))
+		}
+	}
+	upt := d.elastic.NewUpdate("dm_home")
+	year, month, _ := time.Now().Date()
+	yearPre, monthPre, _ := time.Now().AddDate(0, -1, 0).Date()
+	for _, dmid := range dmids {
+		data := &model.UptSearchDMAttr{
+			ID:         dmid,
+			Oid:        oid,
+			Attr:       attr,
+			AttrFormat: bits,
+			Type:       tp,
+			Mtime:      time.Now().Format("2006-01-02 15:04:05"),
+		}
+		upt.AddData(fmt.Sprintf("dm_home_%v",
+			fmt.Sprintf("%d_%02d", yearPre, int(monthPre)),
+		), data)
+		upt.AddData(fmt.Sprintf("dm_home_%v",
+			fmt.Sprintf("%d_%02d", year, int(month)),
+		), data)
+	}
+	if err = upt.Do(c); err != nil {
+		log.Error("update.Do() params(%s) error(%v)", upt.Params(), err)
+	}
+	return
+}
+
+// UptSearchRecentPool .
+func (d *Dao) UptSearchRecentPool(c context.Context, dmids []int64, oid int64, pool, tp int32) (err error) {
+	upt := d.elastic.NewUpdate("dm_home")
+	year, month, _ := time.Now().Date()
+	yearPre, monthPre, _ := time.Now().AddDate(0, -1, 0).Date()
+	for _, dmid := range dmids {
+		data := &model.UptSearchDMPool{
+			ID:    dmid,
+			Oid:   oid,
+			Pool:  pool,
+			Type:  tp,
+			Mtime: time.Now().Format("2006-01-02 15:04:05"),
+		}
+		upt.AddData(fmt.Sprintf("dm_home_%v",
+			fmt.Sprintf("%d_%02d", yearPre, int(monthPre)),
+		), data)
+		upt.AddData(fmt.Sprintf("dm_home_%v",
+			fmt.Sprintf("%d_%02d", year, int(month)),
+		), data)
+	}
+	if err = upt.Do(c); err != nil {
+		log.Error("update.Do() params(%s) error(%v)", upt.Params(), err)
+	}
+	return
+}
+
+// SearhcDmRecent .
+func (d *Dao) SearhcDmRecent(c context.Context, param *model.SearchRecentDMParam) (res *model.SearchRecentDMResult, err error) {
+	var (
+		req *elastic.Request
+	)
+	year, month, _ := time.Now().Date()
+	yearPre, monthPre, _ := time.Now().AddDate(0, -1, 0).Date()
+	req = d.elastic.NewRequest("dm_home").Index(fmt.Sprintf("dm_home_%v,dm_home_%v",
+		fmt.Sprintf("%d_%02d", year, int(month)),
+		fmt.Sprintf("%d_%02d", yearPre, int(monthPre)),
+	)).Fields(_dmRecentFields...).Pn(param.Pn).Ps(param.Ps)
+	if param.Type > 0 {
+		req.WhereEq("type", param.Type)
+	}
+	if param.UpMid > 0 {
+		req.WhereEq("o_mid", param.UpMid)
+	}
+	if len(param.States) > 0 {
+		req.WhereIn("state", param.States)
+	}
+	req.WhereRange("ctime", time.Now().Local().AddDate(0, 0, -30).Format(_dataTimeFormat), time.Now().Local().Format(_dataTimeFormat), elastic.RangeScopeLcRo)
+	req.Order(param.Field, param.Sort)
+	res = &model.SearchRecentDMResult{}
+	if err = req.Scan(c, &res); err != nil {
+		log.Error("search params(%s), error(%v)", req.Params(), err)
+	}
+	return
+}

app/interface/main/dm2/dao/search_test.go

@@ -0,0 +1,106 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/dm2/model"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestSearchDM(t *testing.T) {
+	p := &model.SearchDMParams{
+		Oid:          10131156,
+		Mids:         "",
+		Keyword:      "",
+		ProgressFrom: model.CondIntNil,
+		ProgressTo:   model.CondIntNil,
+		CtimeFrom:    "",
+		CtimeTo:      "",
+		Pn:           1,
+		Ps:           100,
+		State:        "0",
+		Type:         1,
+		Mode:         "",
+		Sort:         "desc",
+		Order:        "ctime",
+		Pool:         "",
+		Attrs:        "",
+	}
+	Convey("", t, func() {
+		res, err := testDao.SearchDM(context.TODO(), p)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+		t.Logf("%+v", res.Page)
+		for i, v := range res.Result {
+			t.Logf("%d %v", i, v)
+		}
+	})
+}
+
+func TestSearchDMHisIndex(t *testing.T) {
+	Convey("search dm history index", t, func() {
+		dates, err := testDao.SearchDMHisIndex(context.TODO(), 1, 10109227, "2018-03")
+		So(err, ShouldBeNil)
+		So(dates, ShouldNotBeEmpty)
+		t.Log(dates)
+	})
+}
+
+func TestSearchDMHistory(t *testing.T) {
+	Convey("search dm history", t, func() {
+		ctime, err := time.Parse("2006-01-02 15:04:05", "2016-08-03 23:59:59")
+		if err != nil {
+			t.Fail()
+		}
+		dmids, err := testDao.SearchDMHistory(context.TODO(), 1, 1221, ctime.Unix(), 1, 100)
+		So(err, ShouldBeNil)
+		So(dmids, ShouldNotBeEmpty)
+		t.Log(dmids)
+	})
+}
+
+func TestUptSearchDMPool(t *testing.T) {
+	Convey("update search dm pool", t, func() {
+		err := testDao.UptSearchDMPool(context.TODO(), []int64{416894555258883, 372530664701955}, 10131156, 1, 1)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestUptSearchDMState(t *testing.T) {
+	Convey("update search dm state", t, func() {
+		err := testDao.UptSearchDMState(context.TODO(), []int64{372412118466563}, 10131156, 1, 1)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestUptSearchDMAttr(t *testing.T) {
+	Convey("update search dm attr", t, func() {
+		err := testDao.UptSearchDMAttr(context.TODO(), []int64{372412118466563}, 10131156, 0, 1)
+		So(err, ShouldBeNil)
+	})
+}
+
+func TestSearchSubtitles(t *testing.T) {
+	Convey("search subtitle", t, func() {
+
+		res, err := testDao.SearchSubtitles(context.TODO(), 1, 10, 0, nil, 0, 0, 0, nil)
+		So(err, ShouldBeNil)
+		t.Logf("page:%+v", res.Page)
+		t.Logf("results:%v", len(res.Results))
+		for _, rs := range res.Results {
+			t.Logf("rs:%+v", rs)
+		}
+	})
+}
+
+func TestCountSubtitles(t *testing.T) {
+	Convey("search subtitle", t, func() {
+
+		res, err := testDao.CountSubtitles(context.TODO(), 0, nil, 0, 0, 0)
+		So(err, ShouldBeNil)
+		t.Logf("page:%+v", res)
+	})
+}

app/interface/main/dm2/dao/upos.go

@@ -0,0 +1,74 @@
+package dao
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"net/http"
+)
+
+const (
+	_uposURL = "api/v1/task/push/audiowaveform"
+
+	_uposBfsFmt = "subtitle/waveform_%d_%d.pcm"
+
+	_uposCallback = "x/internal/v2/dm/subtitle/upos/callback"
+
+	_defaultPixelDensity = 20
+)
+
+// UposReq .
+type UposReq struct {
+	Cid          int64  `json:"cid"`
+	SaveTo       string `json:"saveto"`
+	CallbackURL  string `json:"callback_url"`
+	PixelDensity int32  `json:"pixel_density"`
+}
+
+// UposResp .
+type UposResp struct {
+	Code    int32  `json:"code"`
+	Message string `json:"message"`
+}
+
+// Upos .
+func (d *Dao) Upos(c context.Context, oid int64) (saveTo string, err error) {
+	var (
+		req  *http.Request
+		bs   []byte
+		resp []byte
+	)
+	saveTo = fmt.Sprintf(_uposBfsFmt, oid, 1)
+	params := &UposReq{
+		Cid:          oid,
+		SaveTo:       fmt.Sprintf("bfs://%s", saveTo),
+		CallbackURL:  fmt.Sprintf("%s/%s?oid=%d", d.conf.Host.Self, _uposCallback, oid),
+		PixelDensity: _defaultPixelDensity,
+	}
+	if bs, err = json.Marshal(&params); err != nil {
+		log.Error("params(%+v),error(%v)", params, err)
+		return
+	}
+	if req, err = http.NewRequest(http.MethodPost, fmt.Sprintf("%s/%s", d.conf.Host.Upos, _uposURL), bytes.NewReader(bs)); err != nil {
+		log.Error("http.NewReques.error(%v)", err)
+		return
+	}
+	if resp, err = d.httpCli.Raw(c, req); err != nil {
+		log.Error("d.httpCli.Raw.error(%v)", err)
+		return
+	}
+	uposResp := &UposResp{}
+	if err = json.Unmarshal(resp, &uposResp); err != nil {
+		log.Error("params(%s),error(%v)", resp, err)
+		return
+	}
+	if uposResp.Code != 0 {
+		err = ecode.SubtitleWaveFormFailed
+		log.Error("d.Upos,error(%v),info(%s)", err, uposResp.Message)
+	}
+	return
+}

app/interface/main/dm2/dao/upos_test.go

@@ -0,0 +1,16 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestUpos(t *testing.T) {
+	Convey("test upos", t, func() {
+		saveTo, err := testDao.Upos(context.TODO(), 1111)
+		So(err, ShouldBeNil)
+		t.Logf("%+v", saveTo)
+	})
+}

app/interface/main/dm2/dao/user_log.go

@@ -0,0 +1,72 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/queue/databus/report"
+)
+
+const (
+	_businessUserLogDm = 161
+
+	// dm log
+	_typeUserLogDm       = 1
+	_actionUserLogDmPost = "danmu_post"
+
+	// garbage dm
+	_typeUserLogGarbageDm   = 2
+	_actionUserLogGarbageDm = "danmu_garbage"
+)
+
+func init() {
+	report.InitUser(nil)
+}
+
+// ReportDmGarbageLog report garbage dm
+func (d *Dao) ReportDmGarbageLog(c context.Context, dm *model.DM) (err error) {
+	return d.reportUserLog(c, dm, _typeUserLogGarbageDm, _actionUserLogGarbageDm)
+}
+
+// ReportDmLog report dm post log
+func (d *Dao) ReportDmLog(c context.Context, dm *model.DM) (err error) {
+	return d.reportUserLog(c, dm, _typeUserLogDm, _actionUserLogDmPost)
+}
+
+func (d *Dao) reportUserLog(c context.Context, dm *model.DM, userLogType int, userLogAction string) (err error) {
+	var (
+		remoteIP, remoteAddr = metadata.String(c, metadata.RemoteIP), metadata.String(c, metadata.RemotePort)
+		msg                  string
+	)
+	if dm.Content == nil {
+		return
+	}
+	msg = dm.Content.Msg
+	if dm.ContentSpe != nil {
+		msg = dm.ContentSpe.Msg
+	}
+	if err = report.User(&report.UserInfo{
+		Mid:      dm.Mid,
+		Business: _businessUserLogDm,
+		Type:     userLogType,
+		Oid:      dm.ID,
+		Action:   userLogAction,
+		Ctime:    time.Now(),
+		Platform: fmt.Sprint(dm.Content.Plat),
+		IP:       remoteIP,
+		Index:    []interface{}{dm.Oid},
+		Content: map[string]interface{}{
+			"ip":   remoteIP,
+			"port": remoteAddr,
+			"msg":  msg,
+		},
+	}); err != nil {
+		log.Error("reportUserLog(dmid:%v) error(%v)", dm.ID, err)
+		return
+	}
+	return
+}

app/interface/main/dm2/dao/user_log_test.go

@@ -0,0 +1,56 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/interface/main/dm2/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoReportDmGarbageLog(t *testing.T) {
+	convey.Convey("ReportDmGarbageLog", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			dm = &model.DM{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.ReportDmGarbageLog(c, dm)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoReportDmLog(t *testing.T) {
+	convey.Convey("ReportDmLog", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			dm = &model.DM{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.ReportDmLog(c, dm)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDaoreportUserLog(t *testing.T) {
+	convey.Convey("reportUserLog", t, func(ctx convey.C) {
+		var (
+			c             = context.Background()
+			dm            = &model.DM{}
+			userLogType   = int(0)
+			userLogAction = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := testDao.reportUserLog(c, dm, userLogType, userLogAction)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/interface/main/dm2/dao/workflow.go

@@ -0,0 +1,83 @@
+package dao
+
+import (
+	"context"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/dm2/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+)
+
+const (
+	_workFlowTagList      = "/x/internal/workflow/tag/v3/list"
+	_workFlowAppealAdd    = "/x/internal/workflow/appeal/v3/add"
+	_workFlowAppealDelete = "/x/internal/workflow/appeal/v3/delete"
+)
+
+// WorkFlowTagList get tag list from workflow
+func (d *Dao) WorkFlowTagList(c context.Context, bid, rid int64) (data []*model.WorkFlowTag, err error) {
+	var (
+		res    *model.WorkFlowTagListResp
+		params = url.Values{}
+		uri    = d.conf.Host.API + _workFlowTagList
+		ip     = metadata.String(c, metadata.RemoteIP)
+	)
+	params.Set("bid", strconv.FormatInt(bid, 10))
+	params.Set("rid", strconv.FormatInt(rid, 10))
+	if err = d.httpCli.Get(c, uri, ip, params, &res); err != nil {
+		log.Error("WorkFlowTagList(params:%v),error(%v)", params, err)
+		return
+	}
+	if err = ecode.Int(res.Code); err != ecode.OK {
+		log.Error("WorkFlowTagList(params:%v),error(%v)", params, err)
+		return
+	}
+	data = res.Data
+	err = nil
+	return
+}
+
+// WorkFlowAppealAdd add a record to workflow
+func (d *Dao) WorkFlowAppealAdd(c context.Context, req *model.WorkFlowAppealAddReq) (err error) {
+	var (
+		res *model.CommonResponse
+		uri = d.conf.Host.API + _workFlowAppealAdd
+		ip  = metadata.String(c, metadata.RemoteIP)
+	)
+	if err = d.httpCli.Post(c, uri, ip, req.Params(), &res); err != nil {
+		log.Error("WorkFlowAppealAdd(req:%+v),error(%v)", req.Params(), err)
+		return
+	}
+	if err = ecode.Int(res.Code); err != ecode.OK {
+		log.Error("WorkFlowAppealAdd(req:%+v),error(%v)", req, err)
+		return
+	}
+	err = nil
+	return
+}
+
+// WorkFlowAppealDelete .
+func (d *Dao) WorkFlowAppealDelete(c context.Context, bid, oid, subtitleID int64) (err error) {
+	var (
+		res    *model.CommonResponse
+		params = url.Values{}
+		uri    = d.conf.Host.API + _workFlowAppealDelete
+		ip     = metadata.String(c, metadata.RemoteIP)
+	)
+	params.Set("business", strconv.FormatInt(bid, 10))
+	params.Set("oid", strconv.FormatInt(oid, 10))
+	params.Set("eid", strconv.FormatInt(subtitleID, 10))
+	if err = d.httpCli.Post(c, uri, ip, params, &res); err != nil {
+		log.Error("WorkFlowAppealDelete(params:%v),error(%v)", params, err)
+		return
+	}
+	if err = ecode.Int(res.Code); err != ecode.OK {
+		log.Error("WorkFlowAppealDelete(params:%v),error(%v)", params, err)
+		return
+	}
+	err = nil
+	return
+}

app/interface/main/dm2/dao/workflow_test.go

@@ -0,0 +1,48 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/interface/main/dm2/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoWorkFlowTagList(t *testing.T) {
+	convey.Convey("WorkFlowTagList", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			bid = int64(0)
+			rid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.WorkFlowTagList(c, bid, rid)
+		})
+	})
+}
+
+func TestDaoWorkFlowAppealAdd(t *testing.T) {
+	convey.Convey("WorkFlowAppealAdd", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			req = &model.WorkFlowAppealAddReq{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.WorkFlowAppealAdd(c, req)
+		})
+	})
+}
+
+func TestDaoWorkFlowAppealDelete(t *testing.T) {
+	convey.Convey("WorkFlowAppealDelete", t, func(ctx convey.C) {
+		var (
+			c          = context.Background()
+			bid        = int64(0)
+			oid        = int64(0)
+			subtitleID = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			testDao.WorkFlowAppealDelete(c, bid, oid, subtitleID)
+		})
+	})
+}