Create & Init Project...

app/admin/main/dm/http/BUILD

@@ -0,0 +1,67 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "adv_test.go",
+        "filter_test.go",
+        "http_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = ["//app/admin/main/dm/conf:go_default_library"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "adv.go",
+        "dm.go",
+        "filter.go",
+        "http.go",
+        "mask.go",
+        "monitor.go",
+        "report.go",
+        "shield.go",
+        "subject.go",
+        "subtitle.go",
+        "task.go",
+        "transfer.go",
+    ],
+    importpath = "go-common/app/admin/main/dm/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/dm/conf:go_default_library",
+        "//app/admin/main/dm/model:go_default_library",
+        "//app/admin/main/dm/service:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/binding:go_default_library",
+        "//library/net/http/blademaster/middleware/permit:go_default_library",
+        "//library/net/http/blademaster/middleware/verify:go_default_library",
+        "//library/xstr:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/dm/http/adv.go

@@ -0,0 +1,60 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/admin/main/dm/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// advList 高级弹幕列表
+func advList(c *bm.Context) {
+	var (
+		p  = c.Request.Form
+		pn = int64(1)
+		ps = int64(50)
+	)
+	dmInid, err := strconv.ParseInt(p.Get("oid"), 10, 64)
+	if err != nil || dmInid == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	typ := p.Get("bType")
+	if typ == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	mode := p.Get("mode")
+	if mode == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if p.Get("pn") != "" {
+		if pn, err = strconv.ParseInt(p.Get("pn"), 10, 64); err != nil || pn <= 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("ps") != "" {
+		if ps, err = strconv.ParseInt(p.Get("ps"), 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	result, total, err := dmSvc.Advances(c, dmInid, typ, mode, pn, ps)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	pageInfo := &model.PageInfo{
+		Num:   pn,
+		Size:  ps,
+		Total: total,
+	}
+	data := &model.AdvanceRes{
+		Result: result,
+		Page:   pageInfo,
+	}
+	c.JSON(data, nil)
+}

app/admin/main/dm/http/adv_test.go

@@ -0,0 +1,35 @@
+package http
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"fmt"
+	"net/url"
+	"strconv"
+	"testing"
+	"time"
+)
+
+func TestAdvList(t *testing.T) {
+	params := url.Values{}
+	params.Set("oid", "10108682")
+	params.Set("bType", "all")
+	params.Set("mode", "all")
+
+	params.Set("appkey", "53e2fa226f5ad348")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "3cf6bd1b0ff671021da5f424fea4b04a"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	s := managerHost + "/x/admin/dm/adv/list?" + params.Encode()
+	body, err := oget(s)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", s, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	t.Logf("=========%v\n", body)
+	fmt.Println(string(body))
+}

app/admin/main/dm/http/dm.go

@@ -0,0 +1,286 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/admin/main/dm/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+func contentList(c *bm.Context) {
+	var (
+		v = new(model.SearchDMParams)
+	)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(dmSvc.DMSearch(c, v))
+}
+
+// xmlCacheFlush flush danmu xml cache.
+func xmlCacheFlush(c *bm.Context) {
+	var (
+		err error
+		tp  = int64(model.SubTypeVideo)
+		p   = c.Request.Form
+	)
+	if p.Get("type") != "" {
+		if tp, err = strconv.ParseInt(p.Get("type"), 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	oid, err := strconv.ParseInt(p.Get("oid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	dmSvc.XMLCacheFlush(c, int32(tp), oid)
+	c.JSON(nil, nil)
+}
+
+// dmSearch danmu content List by cid
+func dmSearch(c *bm.Context) {
+	p := c.Request.Form
+	params := &model.SearchDMParams{
+		Mid:          model.CondIntNil,
+		State:        p.Get("state"),
+		Pool:         p.Get("pool"),
+		ProgressFrom: model.CondIntNil,
+		ProgressTo:   model.CondIntNil,
+		CtimeFrom:    model.CondIntNil,
+		CtimeTo:      model.CondIntNil,
+		Page:         1,
+		Size:         100,
+		Sort:         p.Get("sort"),
+		Order:        p.Get("order"),
+		Keyword:      p.Get("keyword"),
+		IP:           p.Get("ip"),
+		Attrs:        p.Get("attrs"),
+	}
+	tp, err := strconv.ParseInt(p.Get("type"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	params.Type = int32(tp)
+	oid, err := strconv.ParseInt(p.Get("oid"), 10, 64)
+	if err != nil {
+		log.Error("param err oid %s %v", p.Get("oid"), err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	params.Oid = oid
+	if p.Get("page") != "" {
+		if params.Page, err = strconv.ParseInt(p.Get("page"), 10, 64); err != nil {
+			log.Error("param err page %s %v", p.Get("page"), err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("page_size") != "" {
+		if params.Size, err = strconv.ParseInt(p.Get("page_size"), 10, 64); err != nil {
+			log.Error("param err page_size %s %v", p.Get("page_size"), err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("mid") != "" {
+		if params.Mid, err = strconv.ParseInt(p.Get("mid"), 10, 64); err != nil {
+			log.Error("param err mid %s %v", p.Get("mid"), err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("progress_from") != "" {
+		if params.ProgressFrom, err = strconv.ParseInt(p.Get("progress_from"), 10, 64); err != nil {
+			log.Error("param err progress_from %s %v", p.Get("progress_from"), err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("progress_to") != "" {
+		if params.ProgressTo, err = strconv.ParseInt(p.Get("progress_to"), 10, 64); err != nil {
+			log.Error("param err progress_to %s %v", p.Get("progress_to"), err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("ctime_from") != "" {
+		if params.CtimeFrom, err = strconv.ParseInt(p.Get("ctime_from"), 10, 64); err != nil {
+			log.Error("param err ctime_from %s %v", p.Get("ctime_from"), err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("ctime_to") != "" {
+		if params.CtimeTo, err = strconv.ParseInt(p.Get("ctime_to"), 10, 64); err != nil {
+			log.Error("param err ctime_to %s %v", p.Get("ctime_to"), err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	data, err := dmSvc.DMSearch(c, params)
+	c.JSON(data, err)
+}
+
+// editDMState batch operation by danmu content id
+func editDMState(c *bm.Context) {
+	var (
+		moral, reason int64
+		p             = c.Request.Form
+	)
+	tp, err := strconv.ParseInt(p.Get("type"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	oid, err := strconv.ParseInt(p.Get("oid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if p.Get("reason_id") != "" {
+		reason, err = strconv.ParseInt(p.Get("reason_id"), 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	state, err := strconv.ParseInt(p.Get("state"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if p.Get("moral") != "" {
+		moral, err = strconv.ParseInt(p.Get("moral"), 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	adminID, err := strconv.ParseInt(p.Get("adminId"), 10, 64)
+	if err != nil || adminID <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	uname := p.Get("uname")
+	if uname == "" {
+		c.JSON(nil, ecode.RequestErr)
+		log.Error("empty uname is not allow")
+		return
+	}
+	remark := p.Get("remark")
+	dmids, err := xstr.SplitInts(p.Get("dmids"))
+	if err != nil || len(dmids) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.EditDMState(c, int32(tp), int32(state), oid, int8(reason), dmids, float64(moral), adminID, uname, remark)
+	c.JSON(nil, err)
+}
+
+// editDMPool batch operation by danmu content id
+func editDMPool(c *bm.Context) {
+	p := c.Request.Form
+	tp, err := strconv.ParseInt(p.Get("type"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	oid, err := strconv.ParseInt(p.Get("oid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	pool, err := strconv.ParseInt(p.Get("pool"), 10, 64)
+	if err != nil || (pool != 0 && pool != 1) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	dmids, err := xstr.SplitInts(p.Get("dmids"))
+	if err != nil || len(dmids) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	adminID, err := strconv.ParseInt(p.Get("adminId"), 10, 64)
+	if err != nil || adminID <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.EditDMPool(c, int32(tp), oid, int32(pool), dmids, adminID)
+	c.JSON(nil, err)
+}
+
+// editDMAttr change attr
+func editDMAttr(c *bm.Context) {
+	var (
+		p     = c.Request.Form
+		bit   uint
+		value int32
+	)
+	tp, err := strconv.ParseInt(p.Get("type"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	oid, err := strconv.ParseInt(p.Get("oid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	attr, err := strconv.ParseInt(p.Get("attr"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	switch attr {
+	case 0: // unprotect dm
+		bit = model.AttrProtect
+		value = model.AttrNo
+	case 1: // protect dm
+		bit = model.AttrProtect
+		value = model.AttrYes
+	default:
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	dmids, err := xstr.SplitInts(p.Get("dmids"))
+	if err != nil || len(dmids) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	adminID, err := strconv.ParseInt(p.Get("adminId"), 10, 64)
+	if err != nil || adminID <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.EditDMAttr(c, int32(tp), oid, dmids, bit, value, adminID)
+	c.JSON(nil, err)
+}
+
+// dmIndexInfo get dm_index info
+func dmIndexInfo(c *bm.Context) {
+	p := c.Request.Form
+	cid, err := strconv.ParseInt(p.Get("cid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	info, err := dmSvc.DMIndexInfo(c, cid)
+	c.JSON(info, err)
+}
+
+func fixDMCount(c *bm.Context) {
+	p := c.Request.Form
+	aid, err := strconv.ParseInt(p.Get("aid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.FixDMCount(c, aid)
+	c.JSON(nil, err)
+}

app/admin/main/dm/http/filter.go

@@ -0,0 +1,86 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/admin/main/dm/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func upFilters(c *bm.Context) {
+	var (
+		p     = c.Request.Form
+		pn    = int64(1)
+		ps    = int64(50)
+		fType = int64(-1)
+	)
+	mid, err := strconv.ParseInt(p.Get("mid"), 10, 64)
+	if err != nil || mid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if p.Get("type") != "" {
+		if fType, err = strconv.ParseInt(p.Get("type"), 10, 64); err != nil || fType < -1 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+
+	if p.Get("pn") != "" {
+		if pn, err = strconv.ParseInt(p.Get("pn"), 10, 64); err != nil || pn <= 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("ps") != "" {
+		if ps, err = strconv.ParseInt(p.Get("ps"), 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	list, total, err := dmSvc.UpFilters(c, mid, fType, pn, ps)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	pageInfo := &model.PageInfo{
+		Num:   pn,
+		Size:  ps,
+		Total: total,
+	}
+	data := &model.UpFilterRes{
+		Result: list,
+		Page:   pageInfo,
+	}
+	c.JSON(data, nil)
+}
+
+func editUpFilters(c *bm.Context) {
+	p := c.Request.Form
+	mid, err := strconv.ParseInt(p.Get("mid"), 10, 64)
+	if err != nil || mid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	id, err := strconv.ParseInt(p.Get("id"), 10, 64)
+	if err != nil || id < 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	fType, err := strconv.ParseInt(p.Get("type"), 10, 64)
+	if err != nil || fType < 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	active, err := strconv.ParseInt(p.Get("active"), 10, 64)
+	if err != nil || (int8(active) != model.FilterActive && int8(active) != model.FilterUnActive) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if _, err = dmSvc.EditUpFilters(c, id, mid, int8(fType), int8(active)); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}

app/admin/main/dm/http/filter_test.go

@@ -0,0 +1,31 @@
+package http
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"fmt"
+	"net/url"
+	"testing"
+)
+
+func TestUpFilters(t *testing.T) {
+	params := url.Values{}
+	params.Set("mid", "27515615")
+	params.Set("type", "3")
+	params.Set("pn", "1")
+	params.Set("ps", "5")
+	mh := md5.Sum([]byte(params.Encode() + "3cf6bd1b0ff671021da5f424fea4b04a"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	s := managerHost + "/x/admin/dm/upfilter/list?" + params.Encode()
+	fmt.Println(s)
+	body, err := oget(s)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", s, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	t.Logf("=========%v\n", body)
+}

app/admin/main/dm/http/http.go

@@ -0,0 +1,134 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/admin/main/dm/conf"
+	"go-common/app/admin/main/dm/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	//dmSvc service
+	dmSvc     *service.Service
+	verifySvc *verify.Verify
+	// authSvc auth service
+	authSvc *permit.Permit
+)
+
+// Init http init
+func Init(c *conf.Config, s *service.Service) {
+	dmSvc = s
+	verifySvc = verify.New(c.Verify)
+	authSvc = permit.New(c.ManagerAuth)
+	engine := bm.DefaultServer(c.HTTPServer)
+	authRouter(engine)
+	innerRouter(engine)
+	// init internal server
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func authRouter(engine *bm.Engine) {
+	engine.GET("/monitor/ping", ping)
+	group := engine.Group("/x/admin/dm")
+	{
+		// up filter
+		group.GET("/upfilter/list", authSvc.Permit("DANMU_POOL_OPERATION"), upFilters)
+		group.POST("/upfilter/edit", authSvc.Permit("DANMU_POOL_OPERATION"), editUpFilters)
+		// advance dm list
+		group.GET("/adv/list", authSvc.Permit("DANMU_POOL_OPERATION"), advList)
+		// dm transfer
+		group.GET("/transfer/list", authSvc.Permit("DANMU_POOL_OPERATION"), transferList)
+		group.POST("/transfer/retry", authSvc.Permit("DANMU_POOL_OPERATION"), reTransferJob)
+		// dm subject
+		group.POST("/subject/state/edit", authSvc.Permit("DANMAKU_POOL_SWITCH"), uptSubjectsState)
+		group.GET("/subject/log", authSvc.Permit("DANMU_LIST"), subjectLog)
+		group.GET("/subject/archive", authSvc.Permit("DANMU_LIST"), archiveList)
+		group.POST("/subject/maxlimit", authSvc.Permit("DANMU_POOL_OPERATION"), upSubjectMaxLimit)
+		// dm mask
+		group.GET("/mask/state", authSvc.Permit("DANMU_LIST"), maskState)
+		group.POST("/mask/state/update", authSvc.Permit("DANMAKU_MASK_SWITCH"), updateMaskState)
+		group.POST("/mask/generate", authSvc.Permit("DANMAKU_MASK_SWITCH"), generateMask)
+		group.GET("/mask/up", authSvc.Permit("DANMU_LIST"), maskUps)
+		group.POST("/mask/up/open", authSvc.Permit("DANMAKU_MASK_SWITCH"), maskUpOpen)
+		// dm task
+		group.GET("/task/list", authSvc.Permit("DM_TASK_LIST"), taskList)
+		group.POST("/task/new", authSvc.Permit("DM_TASK_OPERATION"), addTask)
+		group.POST("/task/review", authSvc.Permit("DM_TASK_REVIEW"), reviewTask)
+		group.POST("/task/state/edit", authSvc.Permit("DM_TASK_OPERATION"), editTaskState)
+		group.GET("/task/view", authSvc.Permit("DM_TASK_LIST"), taskView)
+		group.GET("/task/csv", authSvc.Permit("DM_TASK_LIST"), taskCsv)
+		// dm list
+		group.GET("/content/list", authSvc.Permit("DANMU_LIST"), contentList)
+		group.GET("/report/list/first", authSvc.Permit("DM_REPORT_FIRST_READ"), reportList2)
+		group.GET("/report/list/second", authSvc.Permit("DM_REPORT_SECOND_READ"), reportList2)
+
+		// dm bnj shield
+		group.POST("/shield/upload", authSvc.Permit("DANMU_LIST"), shieldUpload)
+	}
+	subtitleG := group.Group("/subtitle")
+	{
+		subtitleG.GET("/list", authSvc.Permit("DM_SUBTITLE"), subtitleList)
+		subtitleG.POST("/edit", authSvc.Permit("DM_SUBTITLE"), subtitleEdit)
+		subtitleG.POST("/subject/switch", authSvc.Permit("DM_SUBTITLE"), subtitleSwitch)
+	}
+}
+
+// innerRouter init inner router.
+func innerRouter(engine *bm.Engine) {
+	group := engine.Group("/x/internal/dmadmin", verifySvc.Verify)
+	{
+		group.POST("/trans/add", addTrJob)
+		cg := group.Group("/content")
+		{
+			cg.POST("/edit/state", editDMState)
+			cg.POST("/edit/pool", editDMPool)
+			cg.POST("/edit/attr", editDMAttr)
+			cg.GET("/list", dmSearch)
+			cg.POST("/refresh", xmlCacheFlush)
+			cg.GET("/index/info", dmIndexInfo)
+			cg.GET("/log/query", logList)
+		}
+		sg := group.Group("/subject")
+		{
+			sg.GET("/info", dmIndexInfo)
+			sg.POST("/fix/count", fixDMCount)
+		}
+		rg := group.Group("/report")
+		{
+			rg.GET("/list", reportList)
+			rg.GET("/log", reportLog)
+			rg.POST("/user/stat/change", changeReportUserStat)
+			rg.POST("/stat/change", changeReportStat)
+			rg.POST("/judge", transferJudge)
+			rg.POST("/judge/result", JudgeResult)
+		}
+		mg := group.Group("/monitor")
+		{
+			mg.GET("/list", monitorList)
+			mg.POST("/edit", editMonitor)
+		}
+		subtitleG := group.Group("/subtitle")
+		{
+			subtitleG.POST("/workflow/callback", subtitleEditCallback)
+			subtitleG.GET("/workflow/status/list", subtitleStatusList)
+			subtitleG.GET("/workflow/lans/list", subtitleLanList)
+		}
+	}
+}
+
+// ping check server state.
+func ping(ctx *bm.Context) {
+	if err := dmSvc.Ping(ctx); err != nil {
+		log.Error("dm admin ping error(%v)", err)
+		ctx.JSON(nil, err)
+		ctx.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+	ctx.Next()
+}

app/admin/main/dm/http/http_test.go

@@ -0,0 +1,752 @@
+package http
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/dm/conf"
+)
+
+const (
+	localHost   = "http://127.0.0.1:6311"
+	host        = "http://uat-api.bilibili.co"
+	managerHost = "http://uat-manager.bilibili.co"
+)
+
+var (
+	_dmList         = host + "/x/internal/dmadmin/content/list"
+	_refresh        = host + "/x/internal/dmadmin/content/refresh"
+	_editState      = host + "/x/internal/dmadmin/content/edit/state"
+	_editPool       = host + "/x/internal/dmadmin/content/edit/pool"
+	_editAttr       = host + "/x/internal/dmadmin/content/edit/attr"
+	_monitorList    = host + "/x/internal/dmadmin/monitor/list"
+	_editMonitor    = host + "/x/internal/dmadmin/monitor/edit"
+	_dmReportStat   = host + "/x/internal/dmadmin/report/stat/change"
+	_dmReportList   = host + "/x/internal/dmadmin/report/list"
+	_dmReportdetail = host + "/x/internal/dmadmin/report"
+	_archiveList    = localHost + "/x/admin/dm/subject/archive"
+	_subjectLog     = localHost + "/x/admin/dm/subject/log"
+	_uptSubState    = localHost + "/x/admin/dm/subject/state/edit"
+	_dmSendJudge    = host + "/x/internal/dmadmin/report/judge"
+	_dmJudgeResult  = host + "/x/internal/dmadmin/report/judge/result"
+	_dmIndexInfoURL = host + "/x/internal/dmadmin/content/index/info"
+	_subjectLimit   = host + "/x/admin/dm/subject/maxlimit"
+	_maskUps        = localHost + "/x/admin/dm/mask/up"
+	_maskUpOpen     = localHost + "/x/admin/dm/mask/up/open"
+	_taskList       = managerHost + "/x/admin/dm/task/list"
+	_taskNew        = managerHost + "/x/admin/dm/task/new"
+	_taskReview     = localHost + "/x/admin/dm/task/review"
+	_taskView       = localHost + "/x/admin/dm/task/view"
+)
+
+func TestMain(m *testing.M) {
+	var err error
+	conf.ConfPath = "../cmd/dm-admin-test.toml"
+	if err = conf.Init(); err != nil {
+		panic(err)
+	}
+	os.Exit(m.Run())
+}
+
+// TestDMList list
+func TestDMList(t *testing.T) {
+	params := url.Values{}
+	params.Set("type", "1")
+	params.Set("oid", "10108994")
+	params.Set("keyword", "哈哈")
+	params.Set("page_size", "1")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	s := _dmList + "?" + params.Encode()
+	fmt.Println(s)
+	body, err := oget(s)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", s, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	fmt.Println(string(body))
+}
+
+// TestRefrash refrash
+func TestRefresh(t *testing.T) {
+	params := url.Values{}
+	params.Set("cid", "8937277")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	url := _refresh + "?" + params.Encode()
+	t.Log(url)
+	body, err := opost(url)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", url, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+// TestEditState batch
+func TestEditState(t *testing.T) {
+	params := url.Values{}
+	params.Set("type", "1")
+	params.Set("oid", "1222")
+	params.Set("state", "0")
+	params.Set("dmids", "719181990,719181991")
+	params.Set("moral", "1")
+	params.Set("uname", "test")
+	params.Set("remark", "测试下")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	url := _editState + "?" + params.Encode()
+	body, err := opost(url)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", url, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+// TestEditPool batch
+func TestEditPool(t *testing.T) {
+	params := url.Values{}
+	params.Set("type", "1")
+	params.Set("oid", "1222")
+	params.Set("pool", "0")
+	params.Set("dmids", "719181990,719181991")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	url := _editPool + "?" + params.Encode()
+	fmt.Println(url)
+	body, err := opost(url)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", url, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+// TestEditAttr batch
+func TestEditAttr(t *testing.T) {
+	params := url.Values{}
+	params.Set("type", "1")
+	params.Set("oid", "1222")
+	params.Set("attr", "1")
+	params.Set("dmids", "719181990,719181991")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	url := _editAttr + "?" + params.Encode()
+	fmt.Println(url)
+	body, err := opost(url)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", url, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestArchiveList(t *testing.T) {
+	p := url.Values{}
+	//	p.Set("type", "oid")
+	//	p.Set("id", "1345")
+	p.Set("sort", "desc")
+	p.Set("order", "mtime")
+	requestURL := _archiveList + "?" + p.Encode()
+	fmt.Println(requestURL)
+	body, err := oget(requestURL)
+	fmt.Println(string(body))
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestSubjectLog(t *testing.T) {
+	p := url.Values{}
+	p.Set("type", "1")
+	p.Set("oid", "1221")
+	requestURL := _subjectLog + "?" + p.Encode()
+	fmt.Println(requestURL)
+	body, err := oget(requestURL)
+	fmt.Println(string(body))
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestUptSubjectsState(t *testing.T) {
+	p := url.Values{}
+	p.Set("oids", "1223")
+	p.Set("state", "1")
+	requestURL := _uptSubState + "?" + p.Encode()
+	fmt.Println(requestURL)
+	body, err := opost(requestURL)
+	fmt.Println(string(body))
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestReportStatChange(t *testing.T) {
+	params := url.Values{}
+	params.Set("ids", "9968618:719923090,719923092,719923093")
+	params.Set("state", "2")
+	params.Set("uid", "150781")
+	params.Set("reason", "1")
+	params.Set("state", "3")
+	params.Set("remark", "test")
+	params.Set("notice", "3")
+	params.Set("block", "-1")
+	params.Set("moral", "10")
+	params.Set("block_reason", "5")
+	params.Set("uname", "zhanghongwen")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	requestURL := _dmReportStat + "?" + params.Encode()
+	body, err := opost(requestURL)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestReportList(t *testing.T) {
+	params := url.Values{}
+	params.Set("state", "0,1")
+	params.Set("up_op", "0")
+	params.Set("page", "1")
+	params.Set("tid", "24")
+	params.Set("aid", "")
+	params.Set("uid", "")
+	params.Set("rp_user", "")
+	params.Set("rp_type", "")
+	params.Set("start", url.QueryEscape("2017-03-21 00:00:00"))
+	params.Set("end", url.QueryEscape("2017-05-29 00:00:00"))
+	params.Set("order", "desc")
+	params.Set("sort", "rp_time")
+	params.Set("page_size", "2")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	requestURL := _dmReportList + "?" + params.Encode()
+	t.Log(requestURL)
+	body, err := oget(requestURL)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestReportDetail(t *testing.T) {
+	params := url.Values{}
+	params.Set("dmid", "719254592")
+	params.Set("cid", "10106598")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	requestURL := _dmReportdetail + "?" + params.Encode()
+	body, err := oget(requestURL)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestSendJudge(t *testing.T) {
+	params := url.Values{}
+	params.Set("ids", "10108441:719925897")
+	params.Set("uname", "luoxiaofan")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	requestURL := _dmSendJudge + "?" + params.Encode()
+	t.Log(requestURL)
+	fmt.Println(requestURL)
+	body, err := opost(requestURL)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestJudgeResult(t *testing.T) {
+	params := url.Values{}
+	params.Set("cid", "1")
+	params.Set("dmid", "2")
+	params.Set("result", "1")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	requestURL := _dmJudgeResult + "?" + params.Encode()
+	fmt.Println(requestURL)
+	body, err := opost(requestURL)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestSubjectLimit(t *testing.T) {
+	params := url.Values{}
+	params.Set("cid", "1221")
+	params.Set("limit", "99")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	requestURL := _subjectLimit + "?" + params.Encode()
+	fmt.Println(requestURL)
+	body, err := opost(requestURL)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestDMIndexInfo(t *testing.T) {
+	params := url.Values{}
+	params.Set("cid", "9967205")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	requestURL := _dmIndexInfoURL + "?" + params.Encode()
+	fmt.Println(requestURL)
+	body, err := oget(requestURL)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestAddTrJob(t *testing.T) {
+	params := url.Values{}
+	params.Set("cid", "9967205")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+}
+
+func TestMonitorList(t *testing.T) {
+	params := url.Values{}
+	params.Set("page", "1")
+	params.Set("page_size", "5")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	requestURL := _monitorList + "?" + params.Encode()
+	t.Log(requestURL)
+	body, err := oget(requestURL)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestEditMonitor(t *testing.T) {
+	params := url.Values{}
+	params.Set("type", "1")
+	params.Set("oids", "1221,1222")
+	params.Set("state", "1")
+	params.Set("appkey", "f6433799dbd88751")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "36f8ddb1806207fe07013ab6a77a3935"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	requestURL := _editMonitor + "?" + params.Encode()
+	t.Log(requestURL)
+	body, err := opost(requestURL)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", requestURL, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestTransferList(t *testing.T) {
+	params := url.Values{}
+	params.Set("cid", "10108682")
+	params.Set("state", "1")
+	params.Set("appkey", "53e2fa226f5ad348")
+	params.Set("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	mh := md5.Sum([]byte(params.Encode() + "3cf6bd1b0ff671021da5f424fea4b04a"))
+	params.Set("sign", hex.EncodeToString(mh[:]))
+	s := managerHost + "/x/admin/dm/transfer/list?" + params.Encode()
+	fmt.Println(s)
+	body, err := oget(s)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", s, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	//t.Logf("===========%v", body)
+}
+
+func TestReTransferJob(t *testing.T) {
+	params := url.Values{}
+	params.Set("id", "265")
+	params.Set("mid", "1")
+	s := managerHost + "/x/admin/dm/transfer/retry?" + params.Encode()
+	t.Log(s)
+	body, err := cpost(s)
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", s, err)
+		t.FailNow()
+	}
+	if err = ccode(body); err != nil {
+		t.Fatal(err, string(body))
+		t.FailNow()
+	}
+	fmt.Println(string(body))
+}
+
+func TestMaskUps(t *testing.T) {
+	body, err := oget(_maskUps)
+	fmt.Println(string(body))
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", _maskUps, err)
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestMaskUpOpen(t *testing.T) {
+	params := url.Values{}
+	params.Set("mids", "11111")
+	params.Set("state", "1")
+	//	params.Set("comment", "test")
+	requestURL := _maskUpOpen + "?" + params.Encode()
+	fmt.Println(requestURL)
+	body, err := opost(requestURL)
+	fmt.Println(string(body))
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", _maskUps, err)
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestTaskList(t *testing.T) {
+	body, err := oget(_taskList)
+	fmt.Println(string(body))
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", _taskList, err)
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestTaskNew(t *testing.T) {
+	params := url.Values{}
+	params.Set("title", "test")
+	params.Set("mids", "1111")
+	params.Set("start", "2018-11-11 00:00:00")
+	params.Set("end", "2018-11-12 00:00:00")
+	requestURL := _taskNew + "?" + params.Encode()
+	body, err := cpost(requestURL)
+	fmt.Println(string(body))
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", _taskNew, err)
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestTaskReview(t *testing.T) {
+	params := url.Values{}
+	params.Set("id", "15")
+	params.Set("state", "1")
+	requestURL := _taskReview + "?" + params.Encode()
+	body, err := opost(requestURL)
+	fmt.Println(string(body))
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", _taskNew, err)
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+func TestTaskView(t *testing.T) {
+	params := url.Values{}
+	params.Set("id", "14")
+	requestURL := _taskView + "?" + params.Encode()
+	body, err := oget(requestURL)
+	fmt.Println(string(body))
+	if err != nil {
+		t.Errorf("url(%s) error(%s)", _taskNew, err)
+		t.FailNow()
+	}
+	var out bytes.Buffer
+	if err = json.Indent(&out, body, "", " "); err != nil {
+		t.Fatal(err)
+		t.FailNow()
+	}
+	fmt.Println(out.String())
+}
+
+// oget http get request
+func oget(url string) (body []byte, err error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+	body, err = ioutil.ReadAll(resp.Body)
+	return
+}
+
+// ccode check code == 0
+func ccode(body []byte) (err error) {
+	var d interface{}
+	err = json.Unmarshal(body, d)
+	if err != nil {
+		return
+	}
+	ma, ok := d.(map[string]interface{})
+	if !ok {
+		return
+	}
+	code := ma["code"].(int)
+	if code != 0 {
+		err = errors.New("code != 0")
+		return
+	}
+	return
+}
+
+// opost http post request
+func opost(url string) (body []byte, err error) {
+	resp, err := http.Post(url, "", nil)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+	body, err = ioutil.ReadAll(resp.Body)
+	return
+}
+
+func cpost(url string) (body []byte, err error) {
+	client := &http.Client{}
+	req, err := http.NewRequest("POST", url, nil)
+	if err != nil {
+		return
+	}
+	req.Header.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
+	req.Header.Add("Accept-Language", "ja,zh-CN;q=0.8,zh;q=0.6")
+	req.Header.Add("Connection", "keep-alive")
+	req.Header.Add("Cookie", `uid=1130; username=fengduzhen; mng-bilibili=b4nec4bi6un0l9ftkfsgj59uq1; _AJSESSIONID=0935506167be9a62bd477a9f10bd6021; JSESSIONID=940FB2C9CAE4FD14171A5D632689C6E5; _uuid=FCC1090C-7E26-52E5-2DC6-26D8EE1B830506546infoc; mng-go=d56eabfa9edf138604586d5dee4929273d1f76a00cfcd69278b6264c453bae2e`)
+	req.Header.Add("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0")
+	resp, err := client.Do(req)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+	body, err = ioutil.ReadAll(resp.Body)
+	return
+}

app/admin/main/dm/http/mask.go

@@ -0,0 +1,121 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+func maskState(c *bm.Context) {
+	var (
+		p       = c.Request.Form
+		oid, tp int64
+		err     error
+	)
+	if oid, err = strconv.ParseInt(p.Get("oid"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if tp, err = strconv.ParseInt(p.Get("type"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	open, mobile, web, err := dmSvc.MaskState(c, int32(tp), oid)
+	res := map[string]interface{}{}
+	res["open"] = open
+	res["mobile"] = mobile
+	res["web"] = web
+	c.JSON(res, err)
+}
+
+func updateMaskState(c *bm.Context) {
+	var (
+		p                    = c.Request.Form
+		oid, tp, plat, state int64
+		err                  error
+	)
+	if oid, err = strconv.ParseInt(p.Get("oid"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if tp, err = strconv.ParseInt(p.Get("type"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if plat, err = strconv.ParseInt(p.Get("plat"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if state, err = strconv.ParseInt(p.Get("state"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.UpdateMaskState(c, int32(tp), oid, int8(plat), int32(state))
+	c.JSON(nil, err)
+}
+
+func generateMask(c *bm.Context) {
+	var (
+		p             = c.Request.Form
+		oid, tp, plat int64
+		err           error
+	)
+	if oid, err = strconv.ParseInt(p.Get("oid"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if tp, err = strconv.ParseInt(p.Get("type"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if plat, err = strconv.ParseInt(p.Get("plat"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.GenerateMask(c, int32(tp), oid, int8(plat))
+	c.JSON(nil, err)
+}
+
+func maskUps(c *bm.Context) {
+	var (
+		p   = c.Request.Form
+		pn  = int64(1)
+		ps  = int64(50)
+		err error
+	)
+	if p.Get("pn") != "" {
+		if pn, err = strconv.ParseInt(p.Get("pn"), 10, 64); err != nil || pn <= 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("ps") != "" {
+		if ps, err = strconv.ParseInt(p.Get("ps"), 10, 64); err != nil || ps <= 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	c.JSON(dmSvc.MaskUps(c, pn, ps))
+}
+
+func maskUpOpen(c *bm.Context) {
+	var (
+		p       = c.Request.Form
+		comment = p.Get("comment")
+		mids    []int64
+		state   int64
+		err     error
+	)
+	if mids, err = xstr.SplitInts(p.Get("mids")); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if state, err = strconv.ParseInt(p.Get("state"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.MaskUpOpen(c, mids, int32(state), comment)
+	c.JSON(nil, err)
+}

app/admin/main/dm/http/monitor.go

@@ -0,0 +1,111 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/admin/main/dm/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+func monitorList(c *bm.Context) {
+	var (
+		err                  error
+		tp                   = int64(model.SubTypeVideo)
+		aid, cid, mid, state int64
+		page, size           int64 = 1, 50
+		params                     = c.Request.Form
+	)
+	if params.Get("type") != "" {
+		tp, err = strconv.ParseInt(params.Get("type"), 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	aidStr := params.Get("aid")
+	if len(aidStr) > 0 {
+		aid, err = strconv.ParseInt(aidStr, 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	cidStr := params.Get("cid")
+	if len(cidStr) > 0 {
+		cid, err = strconv.ParseInt(cidStr, 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	midStr := params.Get("mid")
+	if len(midStr) > 0 {
+		mid, err = strconv.ParseInt(midStr, 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	kw := params.Get("keyword")
+	if params.Get("state") != "" {
+		state, err = strconv.ParseInt(params.Get("state"), 10, 64)
+		if err != nil || (int32(state) != model.MonitorBefore && int32(state) != model.MonitorAfter) {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	pageStr := params.Get("page")
+	if len(pageStr) > 0 {
+		page, err = strconv.ParseInt(pageStr, 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	psStr := params.Get("page_size")
+	if len(psStr) > 0 {
+		size, err = strconv.ParseInt(psStr, 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	sort := params.Get("sort")
+	order := params.Get("order")
+	data, err := dmSvc.MonitorList(c, int32(tp), aid, cid, mid, int32(state), kw, sort, order, page, size)
+	res := map[string]interface{}{}
+	res["data"] = data
+	c.JSONMap(res, err)
+}
+
+func editMonitor(c *bm.Context) {
+	p := c.Request.Form
+	tp, err := strconv.ParseInt(p.Get("type"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	state, err := strconv.ParseInt(p.Get("state"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if int32(state) != model.MonitorClosed &&
+		int32(state) != model.MonitorAfter &&
+		int32(state) != model.MonitorBefore {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	oids, err := xstr.SplitInts(p.Get("oids"))
+	if err != nil || len(oids) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if _, err = dmSvc.UpdateMonitor(c, int32(tp), oids, int32(state)); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}

app/admin/main/dm/http/report.go

@@ -0,0 +1,344 @@
+package http
+
+import (
+	"net/url"
+	"strconv"
+	"strings"
+
+	"go-common/app/admin/main/dm/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+// checkState check admin operation.
+func checkState(state int8) (ok bool) {
+	if state != model.StatFirstInit &&
+		state != model.StatFirstDelete &&
+		state != model.StatFirstIgnore &&
+		state != model.StatSecondInit &&
+		state != model.StatSecondIgnore &&
+		state != model.StatSecondAutoDelete &&
+		state != model.StatSecondDelete {
+		ok = false
+	} else {
+		ok = true
+	}
+	return
+}
+
+func reportList2(c *bm.Context) {
+	var (
+		v = new(model.ReportListParams)
+	)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(dmSvc.ReportList2(c, v))
+}
+
+func changeReportStat(c *bm.Context) {
+	var (
+		reason, notice, block, blockReason, moral int64
+		cidDmids                                  = map[int64][]int64{}
+		params                                    = c.Request.Form
+		data                                      struct {
+			Affect int64 `json:"affect"`
+		}
+	)
+	uid, err := strconv.ParseInt(params.Get("adminId"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	state, err := strconv.ParseInt(params.Get("state"), 10, 8)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	uname := params.Get("uname")
+	remark := params.Get("remark")
+	noticeStr := params.Get("notice")
+	if noticeStr != "" {
+		if notice, err = strconv.ParseInt(noticeStr, 10, 8); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	ids := strings.Split(params.Get("ids"), "|")
+	if len(ids) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	for _, idStr := range ids {
+		var (
+			cid   int64
+			dmids []int64
+		)
+		s := strings.Split(idStr, ":")
+		if len(s) != 2 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if cid, err = strconv.ParseInt(s[0], 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if dmids, err = xstr.SplitInts(s[1]); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if !checkState(int8(state)) {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		cidDmids[cid] = dmids
+	}
+	if state == int64(model.StatSecondDelete) || state == int64(model.StatFirstDelete) {
+		blockStr := params.Get("block")
+		if blockStr != "" {
+			if block, err = strconv.ParseInt(blockStr, 10, 8); err != nil {
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+		}
+		MoralStr := params.Get("moral")
+		if MoralStr != "" {
+			if moral, err = strconv.ParseInt(MoralStr, 10, 8); err != nil {
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+		}
+		blockReasonStr := params.Get("block_reason")
+		if blockReasonStr != "" {
+			if blockReason, err = strconv.ParseInt(blockReasonStr, 10, 8); err != nil {
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+		}
+		reasonStr := params.Get("reason")
+		if reasonStr != "" {
+			if reason, err = strconv.ParseInt(reasonStr, 10, 8); err != nil {
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+		}
+	}
+	data.Affect, err = dmSvc.ChangeReportStat(c, cidDmids, int8(state), int8(reason), int8(notice), uid, block, blockReason, moral, remark, uname)
+	if err != nil {
+		log.Error("dmSvc.ChangeReportStat(id:%+v, uid:%d) error(%v)", cidDmids, uid, err)
+		c.JSON(nil, err)
+	}
+	res := map[string]interface{}{}
+	res["data"] = data
+	c.JSONMap(res, err)
+}
+
+func reportList(c *bm.Context) {
+	var (
+		tid, rpID                        []int64
+		rt                               *model.Report
+		p                                = c.Request.Form
+		start, end, sort, order, keyword string
+	)
+	rt = &model.Report{
+		Aid:    -1,
+		UID:    -1,
+		RpUID:  -1,
+		RpType: -1,
+		Cid:    -1,
+	}
+	state, err := xstr.SplitInts(p.Get("state"))
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	upOp, err := xstr.SplitInts(p.Get("up_op"))
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	page, err := strconv.ParseInt(p.Get("page"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	tidStr := p.Get("tid")
+	if tidStr != "" {
+		if tid, err = xstr.SplitInts(tidStr); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	aidStr := p.Get("aid")
+	if aidStr != "" {
+		if rt.Aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	cidStr := p.Get("cid")
+	if cidStr != "" {
+		if rt.Cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	uidStr := p.Get("uid")
+	if uidStr != "" {
+		if rt.UID, err = strconv.ParseInt(uidStr, 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	userStr := p.Get("rp_user")
+	if userStr != "" {
+		if rt.RpUID, err = strconv.ParseInt(userStr, 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	typeStr := p.Get("rp_type")
+	if typeStr != "" {
+		if rpID, err = xstr.SplitInts(typeStr); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	startStr := p.Get("start")
+	start, err = url.QueryUnescape(startStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	endStr := p.Get("end")
+	end, err = url.QueryUnescape(endStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	pageSizeStr := p.Get("page_size")
+	var pageSize int64
+	if pageSizeStr != "" {
+		if pageSize, err = strconv.ParseInt(pageSizeStr, 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if pageSize > 100 {
+			pageSize = 100
+		}
+	} else {
+		pageSize = 100
+	}
+	// TODO: swap order&sort
+	order = p.Get("sort")
+	sort = p.Get("order")
+	keyword = p.Get("keyword")
+	rpts, err := dmSvc.ReportList(c, page, pageSize, start, end, order, sort, keyword, tid, rpID, state, upOp, rt)
+	res := map[string]interface{}{}
+	res["data"] = rpts
+	c.JSONMap(res, err)
+}
+
+func reportLog(c *bm.Context) {
+	p := c.Request.Form
+	dmid, err := strconv.ParseInt(p.Get("dmid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	data, err := dmSvc.ReportLog(c, dmid)
+	res := map[string]interface{}{}
+	res["data"] = data
+	c.JSONMap(res, err)
+}
+
+func changeReportUserStat(c *bm.Context) {
+	p := c.Request.Form
+	dmids, err := xstr.SplitInts(p.Get("dmids"))
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.ChangeReportUserStat(c, dmids)
+	c.JSON(nil, err)
+}
+
+func transferJudge(c *bm.Context) {
+	var (
+		err      error
+		uname    string
+		cidDmids = map[int64][]int64{}
+		p        = c.Request.Form
+	)
+
+	ids := strings.Split(p.Get("ids"), "|")
+	if len(ids) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	for _, idStr := range ids {
+		var (
+			cid   int64
+			dmids []int64
+		)
+		s := strings.Split(idStr, ":")
+		if len(s) != 2 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if cid, err = strconv.ParseInt(s[0], 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if dmids, err = xstr.SplitInts(s[1]); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		cidDmids[cid] = dmids
+	}
+	uname = p.Get("uname")
+	uid, err := strconv.ParseInt(p.Get("adminId"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.DMReportJudge(c, cidDmids, uid, uname)
+	c.JSON(nil, err)
+}
+
+// JudgeResult post judgement result
+func JudgeResult(c *bm.Context) {
+	p := c.Request.Form
+	cid, err := strconv.ParseInt(p.Get("cid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	dmid, err := strconv.ParseInt(p.Get("dmid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	result, err := strconv.ParseInt(p.Get("result"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.JudgeResult(c, cid, dmid, result)
+	c.JSON(nil, err)
+}
+
+func logList(c *bm.Context) {
+	p := c.Request.Form
+	dmid, err := strconv.ParseInt(p.Get("dmid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	data, err := dmSvc.QueryOpLogs(c, dmid)
+	res := map[string]interface{}{}
+	res["data"] = data
+	c.JSONMap(res, err)
+}

app/admin/main/dm/http/shield.go

@@ -0,0 +1,26 @@
+package http
+
+import (
+	"bytes"
+	"io"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func shieldUpload(c *bm.Context) {
+	file, _, err := c.Request.FormFile("file")
+	if err != nil {
+		log.Error("shieldUpload.file.illegal,err::%v", err)
+		c.JSON(nil, ecode.FileNotExists)
+		return
+	}
+	defer file.Close()
+	buf := new(bytes.Buffer)
+	if _, err = io.Copy(buf, file); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, dmSvc.DmShield(c, buf.Bytes()))
+}

app/admin/main/dm/http/subject.go

@@ -0,0 +1,142 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/admin/main/dm/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+func archiveList(c *bm.Context) {
+	var (
+		p   = c.Request.Form
+		req = &model.ArchiveListReq{
+			Pn:     1,
+			Ps:     20,
+			IDType: p.Get("type"),
+			Sort:   "desc",
+			Order:  "mtime",
+			Page:   int64(model.CondIntNil),
+			Attrs:  make([]int64, 0),
+			State:  int64(model.CondIntNil),
+		}
+		err error
+	)
+	if idStr := p.Get("id"); len(idStr) > 0 {
+		if req.ID, err = strconv.ParseInt(idStr, 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if pageStr := p.Get("page"); len(pageStr) > 0 {
+		if req.Page, err = strconv.ParseInt(pageStr, 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if attrStr := p.Get("attrs"); len(attrStr) > 0 {
+		req.Attrs, err = xstr.SplitInts(attrStr)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if stateStr := p.Get("state"); len(stateStr) > 0 {
+		req.State, err = strconv.ParseInt(stateStr, 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("sort") != "" {
+		req.Sort = p.Get("sort")
+	}
+	if p.Get("order") != "" {
+		req.Order = p.Get("order")
+	}
+	if pnStr := p.Get("pn"); len(pnStr) > 0 {
+		req.Pn, err = strconv.ParseInt(pnStr, 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if psStr := p.Get("ps"); len(psStr) > 0 {
+		req.Ps, err = strconv.ParseInt(psStr, 10, 64)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	data, err := dmSvc.ArchiveList(c, req)
+	c.JSON(data, err)
+}
+
+func uptSubjectsState(c *bm.Context) {
+	var (
+		uid, _   = c.Get("uid")
+		uname, _ = c.Get("username")
+		p        = c.Request.Form
+		comment  = p.Get("comment")
+	)
+	oids, err := xstr.SplitInts(p.Get("oids"))
+	if err != nil || len(oids) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	tp, err := strconv.ParseInt(p.Get("type"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	state, err := strconv.ParseInt(p.Get("state"), 10, 64)
+	if err != nil || (int32(state) != model.SubStateOpen && int32(state) != model.SubStateClosed) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.UptSubjectsState(c, int32(tp), uid.(int64), uname.(string), oids, int32(state), comment)
+	c.JSON(nil, err)
+}
+
+func upSubjectMaxLimit(c *bm.Context) {
+	var (
+		tp            int64
+		p             = c.Request.Form
+		cid, maxlimit int64
+		err           error
+	)
+	if tp, err = strconv.ParseInt(p.Get("type"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if cid, err = strconv.ParseInt(p.Get("cid"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if maxlimit, err = strconv.ParseInt(p.Get("limit"), 10, 64); err != nil || maxlimit > 20000 || maxlimit < 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.UpSubjectMaxLimit(c, int32(tp), cid, maxlimit)
+	c.JSON(nil, err)
+}
+
+func subjectLog(c *bm.Context) {
+	var (
+		p       = c.Request.Form
+		oid, tp int64
+		err     error
+	)
+	if oid, err = strconv.ParseInt(p.Get("oid"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if tp, err = strconv.ParseInt(p.Get("type"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	data, err := dmSvc.SubjectLog(c, int32(tp), oid)
+	c.JSON(data, err)
+}

app/admin/main/dm/http/subtitle.go

@@ -0,0 +1,64 @@
+package http
+
+import (
+	"go-common/app/admin/main/dm/model"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+// subtitleList 字幕后台管理搜索
+func subtitleList(c *bm.Context) {
+	var (
+		v = new(model.SubtitleArg)
+	)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(dmSvc.SubtitleList(c, v))
+}
+
+// subtitleEdit 字幕操作
+func subtitleEdit(c *bm.Context) {
+	var (
+		v = new(model.EditSubtitleArg)
+	)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(nil, dmSvc.EditSubtitle(c, v))
+}
+
+// workflow 回调函数
+func subtitleEditCallback(c *bm.Context) {
+	var (
+		v = new(model.WorkFlowSubtitleArg)
+	)
+	if err := c.BindWith(v, binding.JSON); err != nil {
+		return
+	}
+	c.JSON(nil, dmSvc.WorkFlowEditSubtitle(c, v))
+}
+
+// subtitleStatusList 字幕状态列表 给举报使用
+func subtitleStatusList(c *bm.Context) {
+	c.JSON(dmSvc.SubtitleStatusList(c))
+}
+
+func subtitleLanList(c *bm.Context) {
+	c.JSON(dmSvc.SubtitleLanList(c))
+}
+
+// subtitleSwitch 字幕开关
+func subtitleSwitch(c *bm.Context) {
+	var (
+		v = new(struct {
+			Aid    int64 `form:"aid" validate:"required"`
+			Allow  bool  `form:"allow"`
+			Closed bool  `form:"closed"`
+		})
+	)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(nil, dmSvc.SubtitleSwitch(c, v.Aid, v.Allow, v.Closed))
+}

app/admin/main/dm/http/task.go

@@ -0,0 +1,101 @@
+package http
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"strings"
+
+	"go-common/app/admin/main/dm/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+func taskList(c *bm.Context) {
+	v := new(model.TaskListArg)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(dmSvc.TaskList(c, v))
+}
+
+func addTask(c *bm.Context) {
+	var (
+		uname, _ = c.Get("username")
+		v        = new(model.AddTaskArg)
+		err      error
+	)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if v.Regex == "" && v.Mids == "" && v.IPs == "" && v.Cids == "" && v.KeyWords == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if _, err = xstr.SplitInts(v.Mids); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if _, err = xstr.SplitInts(v.Cids); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if v.IPs != "" {
+		ips := strings.Split(v.IPs, ",")
+		for _, ip := range ips {
+			tmp := net.ParseIP(ip)
+			if tmp == nil {
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+		}
+	}
+	v.Creator = uname.(string)
+	c.JSON(nil, dmSvc.AddTask(c, v))
+}
+
+func editTaskState(c *bm.Context) {
+	v := new(model.EditTasksStateArg)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(nil, dmSvc.EditTaskState(c, v))
+}
+
+func reviewTask(c *bm.Context) {
+	var (
+		reviewer, _ = c.Get("username")
+		v           = new(model.ReviewTaskArg)
+	)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	v.Reviewer = reviewer.(string)
+	c.JSON(nil, dmSvc.ReviewTask(c, v))
+}
+func taskView(c *bm.Context) {
+	v := new(model.TaskViewArg)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(dmSvc.TaskView(c, v))
+}
+
+func taskCsv(c *bm.Context) {
+	var (
+		bs          []byte
+		err         error
+		contentType = "text/csv"
+	)
+	v := new(model.TaskCsvArg)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if bs, err = dmSvc.TaskCsv(c, v.ID); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.Writer.Header().Set("Content-Disposition", fmt.Sprintf("attachment;filename=%v.csv", v.ID))
+	c.Bytes(http.StatusOK, contentType, bs)
+}

app/admin/main/dm/http/transfer.go

@@ -0,0 +1,106 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/admin/main/dm/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func addTrJob(c *bm.Context) {
+	var (
+		state int8
+		p     = c.Request.Form
+	)
+	from, err := strconv.ParseInt(p.Get("from"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	to, err := strconv.ParseInt(p.Get("to"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	mid, err := strconv.ParseInt(p.Get("mid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	offset, err := strconv.ParseFloat(p.Get("offset"), 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.AddTransferJob(c, from, to, mid, offset, state)
+	c.JSON(nil, err)
+}
+
+func transferList(c *bm.Context) {
+	var (
+		p     = c.Request.URL.Query()
+		pn    = int64(1)
+		ps    = int64(50)
+		state = int64(-1)
+	)
+	cid, err := strconv.ParseInt(p.Get("cid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if p.Get("state") != "" {
+		if state, err = strconv.ParseInt(p.Get("state"), 10, 64); err != nil || state < -1 || state > 3 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("pn") != "" {
+		if pn, err = strconv.ParseInt(p.Get("pn"), 10, 64); err != nil || pn <= 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if p.Get("ps") != "" {
+		if ps, err = strconv.ParseInt(p.Get("ps"), 10, 64); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	list, total, err := dmSvc.TransferList(c, cid, state, pn, ps)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	pageInfo := &model.PageInfo{
+		Num:   pn,
+		Size:  ps,
+		Total: total,
+	}
+	data := &model.TransListRes{
+		Result: list,
+		Page:   pageInfo,
+	}
+	c.JSON(data, nil)
+}
+
+// reTransferJob retransfer job
+func reTransferJob(c *bm.Context) {
+	p := c.Request.Form
+	id, err := strconv.ParseInt(p.Get("id"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	mid, err := strconv.ParseInt(p.Get("mid"), 10, 64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = dmSvc.ReTransferJob(c, id, mid)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}