Create & Init Project...

app/admin/main/reply/http/BUILD

@@ -0,0 +1,69 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["http_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/reply/conf:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/time:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "action.go",
+        "business.go",
+        "emoji.go",
+        "emoji_package.go",
+        "http.go",
+        "log.go",
+        "monitor.go",
+        "notice.go",
+        "reply.go",
+        "report.go",
+        "subject.go",
+    ],
+    importpath = "go-common/app/admin/main/reply/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/reply/conf:go_default_library",
+        "//app/admin/main/reply/model:go_default_library",
+        "//app/admin/main/reply/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/net/ip:go_default_library",
+        "//library/time: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/reply/http/action.go

@@ -0,0 +1,74 @@
+package http
+
+import (
+	"go-common/app/admin/main/reply/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func actionCount(c *bm.Context) {
+	var (
+		err error
+		v   = new(struct {
+			RpID    int64 `form:"rpid" validate:"required"`
+			Oid     int64 `form:"oid" validate:"required"`
+			Type    int32 `form:"type" validate:"required"`
+			AdminID int64 `form:"admin_id"`
+		})
+	)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	like, hate, err := rpSvc.ActionCount(c, v.RpID, v.Oid, v.AdminID, v.Type)
+	if err != nil {
+		log.Warn("svc.ActionInfo(%+v) error(%v)", v, err)
+		c.JSON(nil, err)
+		return
+	}
+	data := map[string]interface{}{
+		"like": like,
+		"hate": hate,
+	}
+	c.JSONMap(data, nil)
+}
+
+func actionUpdate(c *bm.Context) {
+	var (
+		err error
+		v   = new(struct {
+			RpID    int64  `form:"rpid" validate:"required"`
+			Oid     int64  `form:"oid" validate:"required"`
+			Type    int32  `form:"type" validate:"required"`
+			Action  int32  `form:"action" validate:"required,min=1,max=2"`
+			Count   int32  `form:"count"`
+			AdminID int64  `form:"admin_id"`
+			Remark  string `form:"remark"`
+		})
+	)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	adid := v.AdminID
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	switch v.Action {
+	case model.ActionLike:
+		if v.Count < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		err = rpSvc.UpActionLike(c, v.RpID, v.Oid, adid, v.Type, v.Count, v.Remark)
+	case model.ActionHate:
+		err = rpSvc.UpActionHate(c, v.RpID, v.Oid, adid, v.Type, v.Count, v.Remark)
+	default:
+		err = ecode.RequestErr
+	}
+	if err != nil {
+		log.Warn("rpSvc.ActionUpdate(%v) error(%v)", v, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}

app/admin/main/reply/http/business.go

@@ -0,0 +1,77 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func listBusiness(c *bm.Context) {
+	v := new(struct {
+		State int32 `form:"state"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	res, err := rpSvc.ListBusiness(c, v.State)
+	c.JSON(res, err)
+}
+
+func getBusiness(c *bm.Context) {
+	v := new(struct {
+		Type int32 `form:"type"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	res, err := rpSvc.GetBusiness(c, v.Type)
+	c.JSON(res, err)
+}
+
+func addBusiness(c *bm.Context) {
+	v := new(struct {
+		Type   int32  `form:"type" validate:"required"`
+		Name   string `form:"name" validate:"required"`
+		Appkey string `form:"app_key" validate:"required"`
+		Remark string `form:"remark" validate:"required"`
+		Alias  string `form:"alias" validate:"required"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	_, err = rpSvc.AddBusiness(c, v.Type, v.Name, v.Appkey, v.Remark, v.Alias)
+	c.JSON(nil, err)
+}
+
+func upBusiness(c *bm.Context) {
+	v := new(struct {
+		Type   int32  `form:"type" validate:"required"`
+		Name   string `form:"name" validate:"required"`
+		Appkey string `form:"app_key" validate:"required"`
+		Remark string `form:"remark" validate:"required"`
+		Alias  string `form:"alias" validate:"required"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	_, err = rpSvc.UpBusiness(c, v.Name, v.Appkey, v.Remark, v.Alias, v.Type)
+	c.JSON(nil, err)
+}
+
+func upBusiState(c *bm.Context) {
+	v := new(struct {
+		State int32 `form:"state"`
+		Type  int32 `form:"type" validate:"required"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	_, err = rpSvc.UpBusinessState(c, v.State, v.Type)
+	c.JSON(nil, err)
+}

app/admin/main/reply/http/emoji.go

@@ -0,0 +1,93 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func listEmoji(c *bm.Context) {
+	v := new(struct {
+		Pid int64 `form:"pid" default:"0"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	emojis, err := rpSvc.EmojiList(c, v.Pid)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(emojis, nil)
+}
+
+func createEmoji(c *bm.Context) {
+	v := new(struct {
+		Pid    int64  `form:"pid" validate:"min=0"`
+		Name   string `form:"name" validate:"required"`
+		URL    string `form:"url" validate:"required"`
+		Sort   int32  `form:"sort" validate:"min=0"`
+		Remark string `form:"remark" validate:"required"`
+		State  int32  `form:"state" validate:"min=0"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if err := rpSvc.EmojiByName(c, v.Name); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	id, err := rpSvc.CreateEmoji(c, v.Pid, v.Name, v.URL, v.Sort, v.State, v.Remark)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(id, nil)
+}
+
+func upEmojiSort(c *bm.Context) {
+	v := new(struct {
+		IDs string `form:"ids" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	err := rpSvc.UpEmojiSort(c, v.IDs)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func upEmojiState(c *bm.Context) {
+	v := new(struct {
+		ID    int64 `form:"id" validate:"min=0"`
+		State int32 `form:"state" validate:"min=0"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	id, err := rpSvc.UpEmojiState(c, v.State, v.ID)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(id, nil)
+}
+
+func upEmoji(c *bm.Context) {
+	v := new(struct {
+		ID     int64  `form:"id" validate:"min=0"`
+		Name   string `form:"name" validate:"required"`
+		Remark string `form:"remark" validate:"required"`
+		URL    string `form:"url" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	id, err := rpSvc.UpEmoji(c, v.Name, v.Remark, v.URL, v.ID)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(id, nil)
+}

app/admin/main/reply/http/emoji_package.go

@@ -0,0 +1,71 @@
+package http
+
+import (
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func listEmojiPacks(c *bm.Context) {
+	packs, err := rpSvc.EmojiPackageList(c)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(packs, nil)
+}
+
+func createEmojiPackage(c *bm.Context) {
+	v := new(struct {
+		Name   string `form:"name" validate:"required"`
+		URL    string `form:"url" validate:"required"`
+		Sort   int32  `form:"sort" validate:"min=0"`
+		Remark string `form:"remark" default:""`
+		State  int32  `form:"state" validate:"min=0"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	id, err := rpSvc.CreateEmojiPackage(c, v.Name, v.URL, v.Sort, v.Remark, v.State)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(id, nil)
+}
+
+func upEmojiPackageSort(c *bm.Context) {
+	v := new(struct {
+		IDs string `form:"ids" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err := rpSvc.UpEmojiPackageSort(c, v.IDs)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func editEmojiPack(c *bm.Context) {
+	v := new(struct {
+		ID     int64  `form:"id" validate:"min=0"`
+		Name   string `form:"name" default:""`
+		URL    string `form:"url" default:""`
+		Remark string `form:"remark" default:""`
+		State  int32  `form:"state" validate:"min=0"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	id, err := rpSvc.UpEmojiPackage(c, v.Name, v.URL, v.Remark, v.State, v.ID)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(id, nil)
+}

app/admin/main/reply/http/http.go

@@ -0,0 +1,165 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/admin/main/reply/conf"
+	"go-common/app/admin/main/reply/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 (
+	rpSvc     *service.Service
+	verifySvc *verify.Verify
+)
+
+// Init init http.
+func Init(c *conf.Config) {
+	// init services
+	rpSvc = service.New(c)
+	verifySvc = verify.New(c.Verify)
+	auther := permit.New(c.ManagerAuth)
+	engine := bm.DefaultServer(c.HTTPServer)
+	authRouter(engine, auther)
+	interRouter(engine)
+	verifyRouter(engine)
+	// serve port
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+type managerAuther interface {
+	Permit(permit string) bm.HandlerFunc
+}
+
+type fakeAuth struct {
+}
+
+func (a *fakeAuth) Permit(permit string) bm.HandlerFunc {
+	return func(ctx *bm.Context) {
+		ctx.Next()
+	}
+}
+
+func authRouter(engine *bm.Engine, auther managerAuther) {
+	engine.GET("/monitor/ping", ping)
+	group := engine.Group("/x/admin/reply")
+	{
+		// reply
+		group.GET("/search", auther.Permit("REPLY_READONLY"), replySearch)      // 评论列表
+		group.GET("/export", auther.Permit("REPLY_READONLY"), replyExport)      // 评论列表
+		group.POST("/pass", auther.Permit("REPLY_MGR"), adminPassReply)         // 通过评论
+		group.POST("/recover", auther.Permit("REPLY_MGR"), adminRecoverReply)   //  恢复评论
+		group.POST("/edit", auther.Permit("REPLY_MGR"), adminEditReply)         //  编辑评论
+		group.POST("/del", auther.Permit("REPLY_MGR"), adminDelReply)           //  删除评论
+		group.POST("/top", auther.Permit("REPLY_TOP_MGR"), adminTopReply)       //  置顶评论
+		group.GET("/top/log", auther.Permit("REPLY_TOP_MGR"), adminTopReplyLog) //  置顶评论日志搜索
+
+		group.GET("/reply/top", auther.Permit("REPLY_MGR"), topChildReply)
+
+		// report
+		group.GET("/report/search", auther.Permit("REPLY_REPORT_READONLY"), reportSearch) // 举报列表
+		group.POST("/report/del", auther.Permit("REPLY_MGR"), reportDel)                  // 举报删除
+		group.POST("/report/ignore", auther.Permit("REPLY_MGR"), reportIgnore)            // 举报忽略
+		group.POST("/report/recover", auther.Permit("REPLY_MGR"), reportRecover)          // 举报恢复
+		group.POST("/report/transfer", auther.Permit("REPLY_MGR"), reportTransfer)        // 举报转审
+		group.POST("/report/state", auther.Permit("REPLY_MGR"), reportStateSet)           // 设置举报状态
+		// monitor
+		group.GET("/monitor/search", auther.Permit("REPLY_MONITOR_READONLY"), monitorSearch) // 监控列表
+		group.GET("/monitor/stats", auther.Permit("REPLY_MONITOR_READONLY"), monitorStats)   // 监控统计
+		group.POST("/monitor/state", auther.Permit("REPLY_MONITOR_MGR"), monitorState)       // 监控状态
+		group.GET("/mointor/log", auther.Permit("REPLY_MONITOR_READONLY"), monitorLog)       // 监控操作日志
+		// config
+		group.POST("/config/update", auther.Permit("REPLY_MGR"), updateReplyConfig)     // 配置更新
+		group.POST("/config/renew", auther.Permit("REPLY_MGR"), renewReplyConfig)       // 配置添加
+		group.GET("/config/info", auther.Permit("REPLY_READONLY"), loadReplyConfig)     // 配置信息
+		group.GET("/config/list", auther.Permit("REPLY_READONLY"), paginateReplyConfig) // 配置列表
+		// notice
+		group.GET("/notice/detail", auther.Permit("MANAGER_NOTICE"), getNotice)       // 通知信息
+		group.GET("/notice/list", auther.Permit("MANAGER_NOTICE"), listNotice2)       // 通知列表
+		group.POST("/notice/edit", auther.Permit("MANAGER_NOTICE"), editNotice)       // 通知编辑
+		group.POST("/notice/delete", auther.Permit("MANAGER_NOTICE"), deleteNotice)   // 通知删除
+		group.POST("/notice/offline", auther.Permit("MANAGER_NOTICE"), offlineNotice) // 下线通知
+		group.POST("/notice/online", auther.Permit("MANAGER_NOTICE"), onlineNotice)   // 上线通知
+		// subject
+		group.GET("/subject/info", auther.Permit("REPLY_READONLY"), adminSubject)              // 主题信息
+		group.POST("/subject/state", auther.Permit("REPLY_SUBJECT_FREEZE"), adminSubjectState) // 主题状态设置
+		group.POST("/subject/freeze", auther.Permit("REPLY_SUBJECT_FREEZE"), SubFreeze)        // 主题冻结或解冻评论
+		group.GET("/subject/log", auther.Permit("REPLY_READONLY"), SubLogSearch)               // 主题操作日志搜索
+		// action
+		group.GET("/action/count", auther.Permit("REPLY_MGR"), actionCount)
+		group.POST("/action/update", auther.Permit("REPLY_MGR"), actionUpdate)
+		// log
+		group.GET("/log", auther.Permit("REPLY_MGR"), logByRpID)
+
+		// emoji
+		group.GET("/emoji/list", auther.Permit("REPLY_EMOJI"), listEmoji)
+		group.POST("/emoji/add", auther.Permit("REPLY_EMOJI"), createEmoji)
+		group.POST("/emoji/state", auther.Permit("REPLY_EMOJI"), upEmojiState)
+		group.POST("/emoji/sort", auther.Permit("REPLY_EMOJI"), upEmojiSort)
+		group.POST("/emoji/edit", auther.Permit("REPLY_EMOJI"), upEmoji)
+		group.GET("/emoji/package/list", auther.Permit("REPLY_EMOJI"), listEmojiPacks)
+		group.POST("/emoji/package/add", auther.Permit("REPLY_EMOJI"), createEmojiPackage)
+		group.POST("/emoji/package/edit", auther.Permit("REPLY_EMOJI"), editEmojiPack)
+		group.POST("/emoji/package/sort", auther.Permit("REPLY_EMOJI"), upEmojiPackageSort)
+		// business
+		group.GET("/business/list", listBusiness)
+		group.GET("/business/get", getBusiness)
+		group.POST("/business/add", addBusiness)
+		group.POST("/business/update", upBusiness)
+		group.POST("/business/state", upBusiState)
+
+		// fold reply
+		group.POST("/fold", foldReply)
+	}
+}
+
+func interRouter(engine *bm.Engine) {
+	group := engine.Group("/x/internal/replyadmin", verifySvc.Verify)
+	{
+		//log
+		group.GET("/log", logByRpID)
+		//search
+		group.GET("/reply/search", replySearch)
+		group.GET("/report/search", reportSearch)
+		// moniter
+		group.GET("/monitor/stats", monitorStats)
+		group.GET("/monitor/search", monitorSearch)
+		group.POST("/monitor/state", monitorState)
+		// config
+		group.POST("/config/update", updateReplyConfig)
+		group.POST("/config/rewnew", renewReplyConfig)
+		group.GET("/config/info", loadReplyConfig)
+		group.GET("/config/list", paginateReplyConfig)
+		// notice
+		group.GET("/notice/detail", getNotice)
+		group.GET("/notice/list", listNotice)
+		group.POST("/notice/edit", editNotice)
+		group.POST("/notice/delete", deleteNotice)
+		group.POST("/notice/offline", offlineNotice)
+		group.POST("/notice/online", onlineNotice)
+	}
+}
+
+func verifyRouter(engine *bm.Engine) {
+	group := engine.Group("/x/admin/reply/internal")
+	{
+		group.POST("/spam", verifySvc.Verify, adminMarkAsSpam)          // 标记评论为垃圾
+		group.POST("/del", verifySvc.Verify, adminDelReply)             // 删除评论
+		group.POST("/callback/del", verifySvc.Verify, callbackDelReply) // 回调删除评论
+		group.GET("/reply", adminReplyList)                             // 获得评论列表接口
+	}
+}
+
+func ping(ctx *bm.Context) {
+	if err := rpSvc.Ping(ctx); err != nil {
+		log.Error("reply admin ping error(%v)", err)
+		ctx.JSON(nil, err)
+		ctx.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

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

@@ -0,0 +1,61 @@
+package http
+
+import (
+	"context"
+	"net/url"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/reply/conf"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	xtime "go-common/library/time"
+)
+
+const (
+	_monitorState = "http://127.0.0.1:6711/x/internal/replyadmin/monitor/state"
+)
+
+func TestHttp(t *testing.T) {
+	var (
+		err error
+	)
+	if err = conf.Init(); err != nil {
+		t.Errorf("conf.Init() error(%v)", err)
+		t.FailNow()
+	}
+	log.Init(conf.Conf.Log)
+	defer log.Close()
+	client := bm.NewClient(&bm.ClientConfig{
+		Dial:    xtime.Duration(time.Second),
+		Timeout: xtime.Duration(time.Second),
+	})
+	Init(conf.Conf)
+	// test
+	testMonitorState(client, t)
+}
+
+func testMonitorState(client *bm.Client, t *testing.T) {
+	var err error
+	params := url.Values{}
+	params.Set("type", "1")
+	params.Set("oid", "1")
+	params.Set("state", "1")
+	params.Set("adid", "11")
+	params.Set("remark", "test")
+	// send
+	res := map[string]interface{}{}
+	if err = client.Post(context.Background(), _monitorState, "", params, &res); err != nil {
+		t.Errorf("client.Post() error(%v)", err)
+		t.FailNow()
+	}
+	validRes(_monitorState, params, res, t)
+}
+
+func validRes(url string, params url.Values, res map[string]interface{}, t *testing.T) {
+	if code, ok := res["code"]; ok && code.(float64) == 0 {
+		t.Logf("\nurl:%s\nparams:%s\nres:%v", url, params.Encode(), res)
+	} else {
+		t.Errorf("\nurl:%s\nparams:%s\nres:%v", url, params.Encode(), res)
+	}
+}

app/admin/main/reply/http/log.go

@@ -0,0 +1,25 @@
+package http
+
+import (
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func logByRpID(c *bm.Context) {
+	var (
+		err error
+		v   = new(struct {
+			RpID int64 `form:"rpid" validate:"required"`
+		})
+	)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	list, err := rpSvc.LogsByRpID(c, v.RpID)
+	if err != nil {
+		log.Error("svc.ActionInfo(%+v) error(%v)", v, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(list, nil)
+}

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

@@ -0,0 +1,236 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/reply/conf"
+	"go-common/app/admin/main/reply/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+func monitorStats(c *bm.Context) {
+	var (
+		err       error
+		mode      int64
+		startTime int64
+		endTime   int64
+		page      = int64(conf.Conf.Reply.PageNum)
+		pageSize  = int64(conf.Conf.Reply.PageSize)
+	)
+	params := c.Request.Form
+	modeStr := params.Get("mode")
+	sortStr := params.Get("sort")
+	pageStr := params.Get("page")
+	pageSizeStr := params.Get("pagesize")
+	adminIDsStr := params.Get("adminids")
+	startTimeStr := params.Get("start_time")
+	endTimeStr := params.Get("end_time")
+	orderStr := params.Get("order_time")
+	if mode, err = strconv.ParseInt(modeStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(mode:%s) error(%v)", modeStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if pageStr != "" {
+		if page, err = strconv.ParseInt(pageStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(page:%s) error(%v)", pageStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if pageSizeStr != "" {
+		if pageSize, err = strconv.ParseInt(pageSizeStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(pageSize:%s) error(%v)", pageSizeStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if startTimeStr != "" {
+		if startTime, err = strconv.ParseInt(startTimeStr, 10, 64); err == nil {
+			startTimeStr = time.Unix(startTime, 0).Format(model.DateSimpleFormat)
+		}
+	}
+	if endTimeStr != "" {
+		if endTime, err = strconv.ParseInt(endTimeStr, 10, 64); err == nil {
+			endTimeStr = time.Unix(endTime, 0).Format(model.DateSimpleFormat)
+		}
+	} else {
+		t := time.Now()
+		endTimeStr = t.Format(model.DateSimpleFormat)
+
+	}
+	stats, err := rpSvc.MonitorStats(c, mode, page, pageSize, adminIDsStr, sortStr, orderStr, startTimeStr, endTimeStr)
+	if err != nil {
+		log.Error("svc.MonitorStats(%d,%d,%d,%s,%s,%s,%s,%s) error(%v)", mode, page, pageSize, adminIDsStr, sortStr, orderStr, startTimeStr, endTimeStr, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(stats, nil)
+}
+
+func monitorSearch(c *bm.Context) {
+	var (
+		err       error
+		mode, typ int64
+		page      = int64(conf.Conf.Reply.PageNum)
+		pageSize  = int64(conf.Conf.Reply.PageSize)
+		sp        = &model.SearchMonitorParams{}
+	)
+
+	params := c.Request.Form
+	modeStr := params.Get("mode")
+	typeStr := params.Get("type")
+	oidStr := params.Get("oid")
+	uidStr := params.Get("uid")
+	pageStr := params.Get("page")
+	pageSizeStr := params.Get("pagesize")
+	if typ, err = strconv.ParseInt(typeStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(type:%s) error(%v)", typeStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if modeStr != "" {
+		if mode, err = strconv.ParseInt(modeStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(mode:%s) error(%v)", typeStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if oidStr != "" {
+		if sp.Oid, err = strconv.ParseInt(oidStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(oid:%s) error(%v)", oidStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if uidStr != "" {
+		if sp.UID, err = strconv.ParseInt(uidStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(uid:%s) error(%v)", uidStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	sp.Mode = int8(mode)
+	sp.Type = int8(typ)
+	sp.Keyword = params.Get("keyword")
+	sp.NickName = params.Get("nickname")
+	sp.Sort = params.Get("sort")
+	sp.Order = params.Get("order")
+	if pageStr != "" {
+		if page, err = strconv.ParseInt(pageStr, 10, 64); err != nil || page < 1 {
+			log.Warn("strconv.ParseInt(page:%s) error(%v)", pageStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if pageSizeStr != "" {
+		if pageSize, err = strconv.ParseInt(pageSizeStr, 10, 64); err != nil || pageSize < 1 || pageSize > int64(conf.Conf.Reply.PageSize) {
+			log.Warn("strconv.ParseInt(pagesize:%s) error(%v)", pageSizeStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	rpts, err := rpSvc.MonitorSearch(c, sp, page, pageSize)
+	if err != nil {
+		log.Error("svc.ReportSearch(%d,%d,%v) error(%v)", page, pageSize, sp, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(rpts, nil)
+}
+
+func monitorState(c *bm.Context) {
+	var (
+		err     error
+		typ     int64
+		state   int64
+		adminID int64
+		oids    []int64
+	)
+
+	params := c.Request.Form
+	typeStr := params.Get("type")
+	oidStr := params.Get("oid")
+	stateStr := params.Get("state")
+	adminIDStr := params.Get("adid")
+	remark := params.Get("remark")
+	if oids, err = xstr.SplitInts(oidStr); err != nil {
+		log.Warn("strconv.ParseInt(oid:%s) error(%v)", oidStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if typ, err = strconv.ParseInt(typeStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(type:%s) error(%v)", typeStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if state, err = strconv.ParseInt(stateStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(state:%s) error(%v)", stateStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if adminIDStr != "" {
+		if adminID, err = strconv.ParseInt(adminIDStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(admin:%s) error(%v)", adminIDStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if uid, ok := c.Get("uid"); ok {
+		adminID = uid.(int64)
+	}
+	var adName string
+	if uname, ok := c.Get("username"); ok {
+		adName = uname.(string)
+	}
+	for _, oid := range oids {
+		if err = rpSvc.UpMonitorState(c, adminID, adName, oid, int32(typ), int32(state), remark); err != nil {
+			log.Error("svc.MonitorState(%d,%d,%d,%d,%s) error(%v)", oid, typ, state, adminID, remark, err)
+			c.JSON(nil, err)
+			return
+		}
+	}
+	c.JSON(nil, nil)
+}
+
+// monitorLog get monitor log.
+func monitorLog(c *bm.Context) {
+	v := new(struct {
+		Oid       int64  `form:"oid" `
+		Type      int32  `form:"type" `
+		StartTime string `form:"start_time"`
+		EndTime   string `form:"end_time"`
+		Page      int64  `form:"pn"`
+		PageSize  int64  `form:"ps"`
+		Mid       int64  `form:"mid"`
+		Order     string `form:"order"`
+		Sort      string `form:"sort"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+
+	sp := model.LogSearchParam{
+		Oid:       v.Oid,
+		Type:      v.Type,
+		Mid:       v.Mid,
+		CtimeFrom: v.StartTime,
+		CtimeTo:   v.EndTime,
+		Pn:        v.Page,
+		Ps:        v.PageSize,
+		Order:     v.Order,
+		Sort:      v.Sort,
+	}
+	data, err := rpSvc.MointorLog(c, sp)
+	res := map[string]interface{}{}
+	res["data"] = data
+
+	c.JSONMap(res, err)
+	return
+}

app/admin/main/reply/http/notice.go

@@ -0,0 +1,334 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/reply/conf"
+	"go-common/app/admin/main/reply/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	xtime "go-common/library/time"
+)
+
+//panigate notice list
+func listNotice(c *bm.Context) {
+	var (
+		err      error
+		page     = int64(1)
+		pageSize = int64(conf.Conf.Reply.PageSize)
+	)
+
+	params := c.Request.Form
+	pageStr := params.Get("page")
+	pageSizeStr := params.Get("pagesize")
+	if pageStr != "" {
+		if page, err = strconv.ParseInt(pageStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(page:%s) error(%v)", pageStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if page < 1 {
+			page = 1
+		}
+	}
+	if pageSizeStr != "" {
+		if pageSize, err = strconv.ParseInt(pageSizeStr, 10, 64); err != nil || pageSize < 1 {
+			log.Warn("strconv.ParseInt(pagesize:%s) error(%v)", pageSizeStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	data, total, err := rpSvc.ListNotice(c, page, pageSize)
+	if err != nil {
+		log.Error("svc.ListNotcie(%d,%d) error(%v)", page, pageSize, err)
+		c.JSON(nil, err)
+		return
+	}
+	res := map[string]interface{}{}
+	res["data"] = data
+	res["pager"] = map[string]interface{}{
+		"num":   page,
+		"size":  pageSize,
+		"total": total,
+	}
+	c.JSONMap(res, nil)
+	return
+}
+
+//panigate notice list
+func listNotice2(c *bm.Context) {
+	var (
+		err      error
+		page     int64 = 1
+		pageSize       = int64(conf.Conf.Reply.PageSize)
+	)
+
+	params := c.Request.Form
+	pageStr := params.Get("page")
+	pageSizeStr := params.Get("pagesize")
+	if pageStr != "" {
+		if page, err = strconv.ParseInt(pageStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(page:%s) error(%v)", pageStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if page < 1 {
+			page = 1
+		}
+	}
+	if pageSizeStr != "" {
+		if pageSize, err = strconv.ParseInt(pageSizeStr, 10, 64); err != nil || pageSize < 1 {
+			log.Warn("strconv.ParseInt(pagesize:%s) error(%v)", pageSizeStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	data, total, err := rpSvc.ListNotice(c, page, pageSize)
+	if err != nil {
+		log.Error("svc.ListNotcie(%d,%d) error(%v)", page, pageSize, err)
+		c.JSON(nil, err)
+		return
+	}
+	res := map[string]interface{}{}
+	res["data"] = data
+	res["pager"] = model.Pager{Page: page, PageSize: pageSize, Total: total}
+	c.JSONMap(res, nil)
+	return
+}
+
+//return a notice detail
+func getNotice(c *bm.Context) {
+	var (
+		err error
+		id  uint64
+	)
+
+	params := c.Request.Form
+	idStr := params.Get("id")
+	if idStr == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if id, err = strconv.ParseUint(idStr, 10, 32); err != nil {
+		log.Warn("strconv.ParseUint(id:%s) error(%v)", idStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	data, err := rpSvc.GetNotice(c, uint32(id))
+	if err != nil {
+		log.Error("svc.GetNotice(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	if data == nil {
+		c.JSON(nil, ecode.NothingFound)
+		return
+	}
+	c.JSON(data, nil)
+	return
+}
+
+//update or create a notice
+func editNotice(c *bm.Context) {
+	var (
+		err        error
+		id         uint64
+		plat       uint64
+		condition  uint64
+		version    string
+		build      uint64
+		title      string
+		content    string
+		link       string
+		stime      int64
+		etime      int64
+		clientType string
+	)
+
+	params := c.Request.Form
+	idStr := params.Get("id")
+	platStr := params.Get("plat")
+	conditionStr := params.Get("condi")
+	version = params.Get("version")
+	buildStr := params.Get("build")
+	title = params.Get("title")
+	content = params.Get("content")
+	link = params.Get("link")
+	stimeStr := params.Get("stime")
+	etimeStr := params.Get("etime")
+	clientType = params.Get("client_type")
+	if platStr == "" || title == "" || content == "" || stimeStr == "" || etimeStr == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if idStr != "" {
+		if id, err = strconv.ParseUint(idStr, 10, 32); err != nil {
+			log.Warn("strconv.ParseUint(id:%s) error(%v)", idStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if plat, err = strconv.ParseUint(platStr, 10, 8); err != nil {
+		log.Warn("strconv.ParseUint(plat:%s) error(%v)", platStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if conditionStr != "" {
+		if condition, err = strconv.ParseUint(conditionStr, 10, 8); err != nil {
+			log.Warn("strconv.ParseUint(condition:%s) error(%v)", conditionStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if buildStr != "" {
+		if build, err = strconv.ParseUint(buildStr, 10, 32); err != nil {
+			log.Warn("strconv.ParseUint(build:%s) error(%v)", buildStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	var tempTime time.Time
+	if tempTime, err = time.Parse("2006-01-02 15:04:05", stimeStr); err != nil {
+		//error,so try to parse as unix timestamp again
+		stime, err = strconv.ParseInt(stimeStr, 10, 64)
+		if err != nil {
+			log.Warn("strconv.ParseUint(stime:%s) error(%v)", stimeStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	} else {
+		//标准库的time.parse默认以UTC为标准转换成unix时间戳，所以需要减去8小时
+		stime = tempTime.Unix() - 8*3600
+	}
+	if tempTime, err = time.Parse("2006-01-02 15:04:05", etimeStr); err != nil {
+		//error,so try to parse as unix timestamp again
+		etime, err = strconv.ParseInt(etimeStr, 10, 64)
+		if err != nil {
+			log.Warn("strconv.ParseUint(etime:%s) error(%v)", etimeStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	} else {
+		//标准库的time.parse默认以UTC为标准转换成unix时间戳，所以需要减去8小时
+		etime = tempTime.Unix() - 8*3600
+	}
+	//开始时间必须小于等于结束时间
+	if stime > etime {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	nt := &model.Notice{
+		ID:         uint32(id),
+		Plat:       model.NoticePlat(plat),
+		Version:    version,
+		Condition:  model.NoticeCondition(condition),
+		Build:      uint32(build),
+		Title:      title,
+		Content:    content,
+		Link:       link,
+		StartTime:  xtime.Time(stime),
+		EndTime:    xtime.Time(etime),
+		ClientType: clientType,
+	}
+	if idStr == "" {
+		_, err = rpSvc.CreateNotice(c, nt)
+		if err != nil {
+			log.Error("svc.CreateNotice(%v) error(%v)", *nt, err)
+			c.JSON(nil, err)
+			return
+		}
+	} else {
+		err = rpSvc.UpdateNotice(c, nt)
+		if err != nil {
+			log.Error("svc.UpdateNotice(%v) error(%v)", *nt, err)
+			c.JSON(nil, err)
+			return
+		}
+	}
+	c.JSON(nil, nil)
+	return
+}
+
+func deleteNotice(c *bm.Context) {
+	var (
+		err error
+		id  uint64
+	)
+
+	params := c.Request.Form
+	idStr := params.Get("id")
+	if idStr == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if id, err = strconv.ParseUint(idStr, 10, 32); err != nil {
+		log.Warn("strconv.ParseUint(id:%s) error(%v)", idStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = rpSvc.DeleteNotice(c, uint32(id))
+	if err != nil {
+		log.Error("svc.DeleteNotice(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+	return
+}
+
+func offlineNotice(c *bm.Context) {
+
+	var (
+		err error
+		id  uint64
+	)
+
+	params := c.Request.Form
+	idStr := params.Get("id")
+	if idStr == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if id, err = strconv.ParseUint(idStr, 10, 32); err != nil {
+		log.Warn("strconv.ParseUint(id:%s) error(%v)", idStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = rpSvc.UpdateNoticeStatus(c, model.StatusOffline, uint32(id))
+	if err != nil {
+		log.Error("svc.UpdateNoticeStatus(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+	return
+}
+
+func onlineNotice(c *bm.Context) {
+	var (
+		err error
+		id  uint64
+	)
+
+	params := c.Request.Form
+	idStr := params.Get("id")
+	if idStr == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if id, err = strconv.ParseUint(idStr, 10, 32); err != nil {
+		log.Warn("strconv.ParseUint(id:%s) error(%v)", idStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	err = rpSvc.UpdateNoticeStatus(c, model.StatusOnline, uint32(id))
+	if err != nil {
+		log.Error("svc.UpdateNoticeStatus(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+	return
+}

app/admin/main/reply/http/reply.go

@@ -0,0 +1,721 @@
+package http
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/admin/main/reply/conf"
+	"go-common/app/admin/main/reply/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+	"go-common/library/net/ip"
+)
+
+func replyExport(c *bm.Context) {
+	var (
+		err       error
+		startTime time.Time
+		endTime   time.Time
+	)
+	v := new(struct {
+		Oid       int64   `form:"oid" validate:"required"`
+		Type      int8    `form:"type" validate:"required"`
+		StartTime string  `form:"start_time"`
+		EndTime   string  `form:"end_time"`
+		States    []int64 `form:"states,split"`
+		Mid       int64   `form:"uid"`
+	})
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	if v.StartTime == "" {
+		startTime = time.Now().AddDate(0, -3, 0)
+		v.StartTime = startTime.Format("2006-01-02")
+	} else {
+		if startTime, err = time.Parse("2006-01-02", v.StartTime); err != nil {
+			log.Warn("time.Parse(%s) error(%v)", v.StartTime, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if v.EndTime == "" {
+		endTime = time.Now()
+		v.EndTime = endTime.Format("2006-01-02")
+	} else {
+		if endTime, err = time.Parse("2006-01-02", v.EndTime); err != nil {
+			log.Warn("time.Parse(%s) error(%v)", v.EndTime, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	states := strings.Trim(strings.Join(strings.Split(fmt.Sprint(v.States), " "), ","), "[]")
+	data, err := rpSvc.ExportReply(c, v.Oid, v.Mid, v.Type, states, startTime, endTime)
+	if err != nil {
+		log.Error("Svc.ExportReply(%d,%d,%d,%s,%v,%v) error(%v)", v.Oid, v.Mid, v.Type, states, startTime, endTime, err)
+		c.Render(http.StatusInternalServerError, model.CSV{
+			Data:  nil,
+			Title: "",
+		})
+		return
+	}
+	c.Render(http.StatusOK, model.CSV{
+		Data:  data,
+		Title: v.StartTime + "至" + v.EndTime,
+	})
+	return
+}
+
+func replySearch(c *bm.Context) {
+	var (
+		err                     error
+		typ, startTime, endTime int64
+		page                    = int64(conf.Conf.Reply.PageNum)
+		pageSize                = int64(conf.Conf.Reply.PageSize)
+		sp                      = &model.SearchParams{}
+	)
+	params := c.Request.Form
+	typeStr := params.Get("type")
+	oidStr := params.Get("oid")
+	uidStr := params.Get("uid")
+	adminIDStr := params.Get("adminid")
+	startTimeStr := params.Get("start_time")
+	endTimeStr := params.Get("end_time")
+	ipStr := params.Get("ip")
+	pageStr := params.Get("page")
+	pageSizeStr := params.Get("pagesize")
+	// parse params
+	if typ, err = strconv.ParseInt(typeStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(type:%s) error(%v)", typeStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if oidStr != "" {
+		if sp.Oid, err = strconv.ParseInt(oidStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(oid:%s) error(%v)", oidStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if uidStr != "" {
+		if sp.UID, err = strconv.ParseInt(uidStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(uid:%s) error(%v)", uidStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if adminIDStr != "" {
+		if sp.AdminID, err = strconv.ParseInt(adminIDStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(adminid:%s) error(%v)", adminIDStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if startTimeStr != "" {
+		if startTime, err = strconv.ParseInt(startTimeStr, 10, 64); err == nil {
+			sp.Begin = time.Unix(startTime, 0)
+		} else {
+			var t time.Time
+			t, err = time.Parse("2006-01-02", startTimeStr)
+			if err == nil {
+				sp.Begin = t
+			} else {
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+		}
+	}
+	if endTimeStr != "" {
+		if endTime, err = strconv.ParseInt(endTimeStr, 10, 64); err == nil {
+			sp.End = time.Unix(endTime, 0)
+		} else {
+			var t time.Time
+			t, err = time.Parse("2006-01-02", endTimeStr)
+			if err == nil {
+				sp.End = t
+			} else {
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+		}
+	} else if startTimeStr != "" {
+		sp.End = time.Now()
+	}
+	if ipStr != "" {
+		if sp.IP, err = strconv.ParseInt(ipStr, 10, 64); err != nil {
+			sp.IP = int64(ip.InetAtoN(ipStr))
+		}
+	}
+	if pageStr != "" {
+		if page, err = strconv.ParseInt(pageStr, 10, 64); err != nil || page < 1 {
+			log.Warn("strconv.ParseInt(page:%s) error(%v)", pageStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if pageSizeStr != "" {
+		if pageSize, err = strconv.ParseInt(pageSizeStr, 10, 64); err != nil || pageSize < int64(1) || pageSize > int64(conf.Conf.Reply.PageSize) {
+			log.Warn("strconv.ParseInt(pagesize:%s) error(%v)", pageSizeStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	sp.Type = int32(typ)
+	sp.TypeIds = params.Get("typeids")
+	sp.Keyword = params.Get("keyword")
+	sp.KeywordHigh = params.Get("keyword_high")
+	sp.Uname = params.Get("nickname")
+	sp.States = params.Get("states")
+	sp.Sort = params.Get("sort")
+	sp.Order = params.Get("order")
+	sp.Attr = params.Get("attr")
+	sp.AdminName = params.Get("adminname")
+	sp.Sort, sp.Order = sp.Order, sp.Sort
+	if sp.Sort == "" {
+		sp.Sort = "desc"
+	}
+	if sp.Order == "" {
+		sp.Order = "ctime"
+	}
+	rs, err := rpSvc.ReplySearch(c, sp, page, pageSize)
+	if err != nil {
+		log.Error("svc.ReplySearch(%v,%d,%d) error(%v)", sp, page, pageSize, err)
+		c.JSON(nil, err)
+		return
+	}
+	res := map[string]interface{}{}
+	res["data"] = rs
+	c.JSONMap(res, nil)
+	return
+}
+
+func updateReplyConfig(c *bm.Context) {
+	var (
+		err                                     error
+		typ, oid, showEntry, showAdmin, adminID int64
+		operator                                string
+		config                                  = &model.Config{}
+		bs                                      []byte
+	)
+	params := c.Request.Form
+	typeStr := params.Get("type")
+	oidStr := params.Get("oid")
+	adminIDStr := params.Get("adminid")
+	operator = params.Get("operator")
+	showEntityStr := params.Get("showentry")
+	showAdminStr := params.Get("showadmin")
+	if oid, err = strconv.ParseInt(oidStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(oid:%s) error(%v)", oidStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if typ, err = strconv.ParseInt(typeStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(type:%s) error(%v)", typeStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if showEntry, err = strconv.ParseInt(showEntityStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(showEntry:%s) error(%v)", showEntityStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if showAdmin, err = strconv.ParseInt(showAdminStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(showAdmin:%s) error(%v)", showAdminStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	adminID, _ = strconv.ParseInt(adminIDStr, 10, 64)
+	if uid, ok := c.Get("uid"); ok {
+		adminID = uid.(int64)
+	}
+	config.Oid = oid
+	config.Type = int32(typ)
+	config.Category = 1
+	config.AdminID = adminID
+	config.Operator = operator
+	configValue := map[string]int64{
+		"showentry": showEntry,
+		"showadmin": showAdmin,
+	}
+	config.ShowEntry = int32(showEntry)
+	config.ShowAdmin = int32(showAdmin)
+	if bs, err = json.Marshal(configValue); err == nil {
+		config.Config = string(bs)
+	}
+	if _, err = rpSvc.AddReplyConfig(c, config); err != nil {
+		log.Error("svc.AddReplyConfig(%v) error(%v)", config, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func renewReplyConfig(c *bm.Context) {
+	var (
+		err error
+		id  int64
+	)
+
+	params := c.Request.Form
+	idStr := params.Get("id")
+	if id, err = strconv.ParseInt(idStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(type:%s) error(%v)", idStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if _, err = rpSvc.RenewReplyConfig(c, id); err != nil {
+		log.Error("svc.RenewReplyConfig(%d) error(%v)", id, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func paginateReplyConfig(c *bm.Context) {
+	var (
+		err                error
+		oid, typ, category int64
+		page               = int64(conf.Conf.Reply.PageNum)
+		pageSize           = int64(conf.Conf.Reply.PageSize)
+	)
+
+	params := c.Request.Form
+	typeStr := params.Get("type")
+	categoryStr := params.Get("category")
+	oidStr := params.Get("oid")
+	operator := params.Get("operator")
+	pageStr := params.Get("pn")
+	pageSizeStr := params.Get("ps")
+	if oid, err = strconv.ParseInt(oidStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(oid:%s) error(%v)", oidStr, err)
+	}
+	if typ, err = strconv.ParseInt(typeStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(type:%s) error(%v)", typeStr, err)
+	}
+	if category, err = strconv.ParseInt(categoryStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(category:%s) error(%v)", categoryStr, err)
+	}
+	if pageStr != "" {
+		if page, err = strconv.ParseInt(pageStr, 10, 64); err != nil || page < 1 {
+			log.Warn("strconv.ParseInt(page:%s) error(%v)", pageStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if pageSizeStr != "" {
+		if pageSize, err = strconv.ParseInt(pageSizeStr, 10, 64); err != nil || pageSize < 1 || pageSize > int64(conf.Conf.Reply.PageSize) {
+			log.Warn("strconv.ParseInt(pagesize:%s) error(%v)", pageSizeStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	configs, totalCount, pages, err := rpSvc.PaginateReplyConfig(c, int32(typ), int32(category), oid, operator, int(page-1)*int(pageSize), int(pageSize))
+	if err != nil {
+		log.Error("svc.PaginateReplyConfig(%d,%d,%d,%v,%d,%d) error(%v)", int32(typ), 1, oid, operator, int(page), int(pageSize), err)
+		c.JSON(nil, err)
+		return
+	}
+	data := map[string]interface{}{
+		"page":      page,
+		"pagesize":  pageSize,
+		"pagecount": pages,
+		"total":     totalCount,
+		"order":     "default",
+		"result":    configs,
+	}
+	c.JSONMap(data, nil)
+	return
+}
+
+func loadReplyConfig(c *bm.Context) {
+	var (
+		err                error
+		oid, typ, category int64
+	)
+
+	params := c.Request.Form
+	typeStr := params.Get("type")
+	categoryStr := params.Get("category")
+	oidStr := params.Get("oid")
+	if oid, err = strconv.ParseInt(oidStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(oid:%s) error(%v)", oidStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if typ, err = strconv.ParseInt(typeStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(type:%s) error(%v)", typeStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if category, err = strconv.ParseInt(categoryStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(category:%s) error(%v)", categoryStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	config, err := rpSvc.LoadReplyConfig(c, int32(typ), int32(category), oid)
+	if err != nil {
+		log.Error("Svc.LoadReplyConfig(%d,%d,%d) error(%v)", int32(typ), 1, oid, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(config, nil)
+	return
+}
+
+// adminPassReply pass reply normal.
+func adminPassReply(c *bm.Context) {
+	v := new(struct {
+		RpID    []int64 `form:"rpid,split" validate:"required"`
+		Oid     []int64 `form:"oid,split" validate:"required"`
+		Type    int32   `form:"type" validate:"required"`
+		AdminID int64   `form:"adid"`
+		Remark  string  `form:"remark"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	if len(v.Oid) != len(v.RpID) {
+		log.Warn("len(v.Oid) != len(v.RpID),%d != %d", len(v.Oid), len(v.RpID))
+		c.JSON(nil, ecode.RequestErr)
+	}
+	adid := v.AdminID
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	var adName string
+	if uname, ok := c.Get("username"); ok {
+		adName = uname.(string)
+	}
+	err = rpSvc.AdminPassReply(c, adid, adName, v.Oid, v.RpID, v.Type, v.Remark)
+	c.JSON(nil, err)
+	return
+}
+
+// adminRecoverReply recover reply normal.
+func adminRecoverReply(c *bm.Context) {
+	v := new(struct {
+		RpID    int64  `form:"rpid" validate:"required"`
+		Oid     int64  `form:"oid" validate:"required"`
+		Type    int32  `form:"type" validate:"required"`
+		AdminID int64  `form:"adid"`
+		Remark  string `form:"remark"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	adid := v.AdminID
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	var adName string
+	if uname, ok := c.Get("username"); ok {
+		adName = uname.(string)
+	}
+	err = rpSvc.AdminRecoverReply(c, adid, adName, v.Oid, v.RpID, v.Type, v.Remark)
+	c.JSON(nil, err)
+	return
+}
+
+// adminEditReply edit reply normal.
+func adminEditReply(c *bm.Context) {
+	v := new(struct {
+		RpID    int64  `form:"rpid" validate:"required"`
+		Oid     int64  `form:"oid" validate:"required"`
+		Type    int32  `form:"type" validate:"required"`
+		AdminID int64  `form:"adid"`
+		Message string `form:"message"`
+		Remark  string `form:"remark"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	adid := v.AdminID
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	var adName string
+	if uname, ok := c.Get("username"); ok {
+		adName = uname.(string)
+	}
+	err = rpSvc.AdminEditReply(c, adid, adName, v.Oid, v.RpID, v.Type, v.Message, v.Remark)
+	c.JSON(nil, err)
+	return
+}
+
+// Compose compose struct
+type Compose struct {
+	RpIDs []int64
+	Oids  []int64
+}
+
+// adminDelReply del reply normal.
+func adminDelReply(c *bm.Context) {
+	v := new(struct {
+		RpID    []int64 `form:"rpid,split" validate:"required"`
+		Oid     []int64 `form:"oid,split" validate:"required"`
+		Type    []int32 `form:"type,split" validate:"required"`
+		AdminID int64   `form:"adid"`
+		Remark  string  `form:"remark"`
+		Moral   int32   `form:"moral"`
+		Notify  bool    `form:"notify"`
+		FTime   int64   `form:"ftime"`
+		AdName  string  `form:"adname"`
+		Reason  int32   `form:"reason"`
+		FReason int32   `form:"freason"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	if len(v.RpID) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if len(v.RpID) != len(v.Oid) || len(v.RpID) != len(v.Type) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	tMap := make(map[int32]*Compose)
+	for i, tp := range v.Type {
+		if c, ok := tMap[tp]; ok {
+			c.Oids = append(c.Oids, v.Oid[i])
+			c.RpIDs = append(c.RpIDs, v.RpID[i])
+		} else {
+			c = &Compose{
+				Oids:  []int64{v.Oid[i]},
+				RpIDs: []int64{v.RpID[i]},
+			}
+			tMap[tp] = c
+		}
+	}
+	if uid, ok := c.Get("uid"); ok {
+		v.AdminID = uid.(int64)
+	}
+	if uname, ok := c.Get("username"); ok {
+		v.AdName = uname.(string)
+	}
+	for tp, com := range tMap {
+		err = rpSvc.AdminDeleteReply(c, v.AdminID, com.Oids, com.RpIDs, v.FTime, tp, v.Moral, v.Notify, v.AdName, v.Remark, v.Reason, v.FReason)
+		if !ecode.NothingFound.Equal(err) {
+			err = nil
+		}
+	}
+	c.JSON(nil, err)
+	return
+}
+
+// callbackDelReply del reply normal.
+func callbackDelReply(c *bm.Context) {
+	v := new(struct {
+		Actor struct {
+			AdminID   int64  `json:"admin_id"`
+			AdminName string `json:"admin_name"`
+		} `json:"actor"`
+		CTime  int64 `json:"ctime"`
+		Object struct {
+			TagID         int32  `json:"tag_id"`
+			DecreaseMoral int32  `json:"decrease_moral"`
+			BlockReasonID int32  `json:"block_reason_id"`
+			BlockDay      int64  `json:"block_day"`
+			Reason        string `json:"reason"`
+			DisposeMode   int32  `json:"dispose_mode"`
+			State         int32  `json:"state"`
+			RID           int32  `json:"rid"`
+		} `json:"object"`
+		Target []struct {
+			OID   int64 `json:"oid"`
+			FID   int32 `json:"fid"`
+			EID   int64 `json:"eid"`
+			State int32 `json:"state"`
+		} `json:"targets"`
+	})
+	var err error
+	err = c.BindWith(v, binding.JSON)
+	if err != nil {
+		return
+	}
+	log.Info("callbackDelReply V:%+v", *v)
+	if v.Object.State == 2 {
+		for _, t := range v.Target {
+			rpSvc.ReportIgnore(c, []int64{t.OID}, []int64{t.EID}, v.Actor.AdminID, v.Actor.AdminName, t.FID, v.Object.RID, v.Object.Reason, false)
+		}
+	} else if v.Object.State == 1 {
+		for _, t := range v.Target {
+			err = rpSvc.CallbackDeleteReply(c, v.Actor.AdminID, t.OID, t.EID, v.Object.BlockDay, t.FID, v.Object.DecreaseMoral, v.Actor.AdminName, v.Object.Reason, v.Object.TagID, v.Object.BlockReasonID)
+		}
+	} else if v.Object.State == 10 {
+		for _, t := range v.Target {
+			rpSvc.ReportStateSet(c, []int64{t.OID}, []int64{t.EID}, v.Actor.AdminID, v.Actor.AdminName, t.FID, 8, v.Object.Reason, false)
+		}
+	} else {
+		log.Warn("callbackDelReply RequestErr(%d,%d)", v.Object.State, v.Object.DisposeMode)
+	}
+
+	c.JSON(nil, err)
+	return
+}
+
+// adminTopReply top reply normal.
+func adminTopReply(c *bm.Context) {
+	v := new(struct {
+		RpID    int64  `form:"rpid" validate:"required"`
+		Oid     int64  `form:"oid" validate:"required"`
+		Type    int32  `form:"type" validate:"required"`
+		AdminID int64  `form:"adid"`
+		Action  uint32 `form:"action"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	adid := v.AdminID
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	var adName string
+	if uname, ok := c.Get("username"); ok {
+		adName = uname.(string)
+	}
+	err = rpSvc.AddTop(c, adid, adName, v.Oid, v.RpID, v.Type, v.Action)
+	c.JSON(nil, err)
+	return
+}
+
+// adminTopReplyLog get reply top log.
+func adminTopReplyLog(c *bm.Context) {
+	v := new(struct {
+		Oid       int64  `form:"oid" `
+		Type      int32  `form:"type" `
+		StartTime string `form:"start_time"`
+		EndTime   string `form:"end_time"`
+		Page      int64  `form:"pn"`
+		PageSize  int64  `form:"ps"`
+		Order     string `form:"order"`
+		Sort      string `form:"sort"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+
+	sp := model.LogSearchParam{
+		Oid:       v.Oid,
+		Type:      v.Type,
+		CtimeFrom: v.StartTime,
+		CtimeTo:   v.EndTime,
+		Pn:        v.Page,
+		Ps:        v.PageSize,
+		Order:     v.Order,
+		Sort:      v.Sort,
+	}
+	data, err := rpSvc.ReplyTopLog(c, sp)
+	res := map[string]interface{}{}
+	res["data"] = data
+	c.JSONMap(res, err)
+
+	return
+}
+
+// adminMarkAsSpam make a reply as spam
+func adminMarkAsSpam(c *bm.Context) {
+	v := new(struct {
+		RpIDs   []int64 `form:"rpid,split" validate:"required"`
+		Oids    []int64 `form:"oid,split" validate:"required"`
+		AdminID int64   `form:"adid"`
+		Remark  string  `form:"remark"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	adid := v.AdminID
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	var adName string
+	if uname, ok := c.Get("username"); ok {
+		adName = uname.(string)
+	}
+	err = rpSvc.MarkAsSpam(c, v.Oids, v.RpIDs, adid, adName, v.Remark)
+	c.JSON(nil, err)
+	return
+}
+
+// adminMarkAsSpam make a reply as spam
+func adminReplyList(c *bm.Context) {
+	v := new(struct {
+		RpIDs []int64 `form:"eids,split" validate:"required"`
+		Oids  []int64 `form:"oids,split" validate:"required"`
+		IDs   []int64 `form:"ids,split" validate:"required"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	res := make(map[int64]*model.ReplyEx)
+
+	if len(v.RpIDs) == len(v.IDs) && len(v.IDs) == len(v.Oids) && len(v.RpIDs) > 0 {
+		for i := range v.IDs {
+			ex := &model.ReplyEx{}
+			ex.ID = v.RpIDs[i]
+			ex.Oid = v.Oids[i]
+			res[v.IDs[i]] = ex
+		}
+		var rpMap map[int64]*model.ReplyEx
+		rpMap, err = rpSvc.ReplyList(c, v.Oids, v.RpIDs)
+		for k, data := range res {
+			res[k] = rpMap[data.ID]
+		}
+	} else {
+		log.Error("adminReplyList request invalid(%v)", v)
+		err = ecode.RequestErr
+	}
+
+	c.JSON(res, err)
+	return
+}
+
+func topChildReply(c *bm.Context) {
+	v := new(struct {
+		Root  int64 `form:"root" validate:"required"`
+		Child int64 `form:"child" validate:"required"`
+		Oid   int64 `form:"oid" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(nil, rpSvc.TopChildReply(c, v.Root, v.Child, v.Oid))
+}
+
+func foldReply(c *bm.Context) {
+	v := new(struct {
+		Oids  []int64 `form:"oids,split" validate:"required"`
+		RpIDs []int64 `form:"rpids,split" validate:"required"`
+		Types []int64 `form:"types,split" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if len(v.Oids) != len(v.RpIDs) || len(v.Oids) != len(v.Types) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, rpSvc.FoldReplies(c, v.Oids, v.Types, v.RpIDs))
+}

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

@@ -0,0 +1,369 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/reply/conf"
+	"go-common/app/admin/main/reply/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func reportSearch(c *bm.Context) {
+	var (
+		err                     error
+		typ, startTime, endTime int64
+		page                    = int64(conf.Conf.Reply.PageNum)
+		pageSize                = int64(conf.Conf.Reply.PageSize)
+		sp                      = &model.SearchReportParams{}
+	)
+
+	params := c.Request.Form
+	typeStr := params.Get("type")
+	oidStr := params.Get("oid")
+	uidStr := params.Get("uid")
+	startTimeStr := params.Get("start_time")
+	endTimeStr := params.Get("end_time")
+	pageStr := params.Get("page")
+	pageSizeStr := params.Get("pagesize")
+	// parse params
+	if typ, err = strconv.ParseInt(typeStr, 10, 64); err != nil {
+		log.Warn("strconv.ParseInt(type:%s) error(%v)", typeStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if oidStr != "" {
+		if sp.Oid, err = strconv.ParseInt(oidStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(oid:%s) error(%v)", oidStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if uidStr != "" {
+		if sp.UID, err = strconv.ParseInt(uidStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(uid:%s) error(%v)", uidStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if startTimeStr != "" {
+		if startTime, err = strconv.ParseInt(startTimeStr, 10, 64); err == nil {
+			sp.StartTime = time.Unix(startTime, 0).Format(model.DateFormat)
+		} else {
+			var t time.Time
+			t, err = time.Parse("2006-01-02", startTimeStr)
+			if err == nil {
+				sp.StartTime = t.Format(model.DateFormat)
+			} else {
+				sp.StartTime = startTimeStr
+			}
+		}
+	}
+	if endTimeStr != "" {
+		if endTime, err = strconv.ParseInt(endTimeStr, 10, 64); err == nil {
+			sp.EndTime = time.Unix(endTime, 0).Format(model.DateFormat)
+		} else {
+			var t time.Time
+			t, err = time.Parse("2006-01-02", endTimeStr)
+			if err == nil {
+				sp.EndTime = t.Format(model.DateFormat)
+			} else {
+				sp.EndTime = endTimeStr
+			}
+		}
+	} else if startTimeStr != "" {
+		t := time.Now()
+		sp.EndTime = t.Format(model.DateFormat)
+	}
+	if pageStr != "" {
+		if page, err = strconv.ParseInt(pageStr, 10, 64); err != nil || page < 1 {
+			log.Warn("strconv.ParseInt(page:%s) error(%v)", pageStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if pageSizeStr != "" {
+		if pageSize, err = strconv.ParseInt(pageSizeStr, 10, 64); err != nil || pageSize < 1 || pageSize > int64(conf.Conf.Reply.PageSize) {
+			log.Warn("strconv.ParseInt(page:%s) error(%v)", pageSizeStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	sp.Type = int32(typ)
+	sp.Reason = params.Get("reason")
+	sp.Typeids = params.Get("typeids")
+	sp.Keyword = params.Get("keyword")
+	sp.Nickname = params.Get("nickname")
+	sp.States = params.Get("states")
+	sp.Order = params.Get("order")
+	sp.Sort = params.Get("sort")
+	rpts, err := rpSvc.ReportSearch(c, sp, page, pageSize)
+	if err != nil {
+		log.Error("rpSvc.ReportSearch(%d,%d,%v) error(%v)", page, pageSize, sp, err)
+		c.JSON(nil, err)
+		return
+	}
+	res := map[string]interface{}{}
+	res["data"] = rpts
+	c.JSONMap(res, nil)
+}
+
+func reportDel(c *bm.Context) {
+	v := new(struct {
+		RpID    []int64 `form:"rpid,split" validate:"required"`
+		Oid     []int64 `form:"oid,split" validate:"required"`
+		Type    []int32 `form:"type,split" validate:"required"`
+		AdminID int64   `form:"adid"`
+		Remark  string  `form:"remark"`
+		Moral   int32   `form:"moral"`
+		Notify  bool    `form:"notify"`
+		FTime   int64   `form:"ftime"`
+		AdName  string  `form:"adname"`
+		FReason int32   `form:"freason"`
+		Audit   int32   `form:"audit"`
+		Reason  int32   `form:"reason"`
+		Content string  `form:"reason_content"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	if len(v.RpID) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if len(v.RpID) != len(v.Oid) || len(v.RpID) != len(v.Type) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	// reason没传修改为-1而不是0
+	params := c.Request.Form
+	if params.Get("reason") == "" {
+		v.Reason = -1
+	}
+	tMap := make(map[int32]*Compose)
+	for i, tp := range v.Type {
+		if c, ok := tMap[tp]; ok {
+			c.Oids = append(c.Oids, v.Oid[i])
+			c.RpIDs = append(c.RpIDs, v.RpID[i])
+		} else {
+			c = &Compose{
+				Oids:  []int64{v.Oid[i]},
+				RpIDs: []int64{v.RpID[i]},
+			}
+			tMap[tp] = c
+		}
+	}
+	adid := v.AdminID
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	adname := v.AdName
+	if username, ok := c.Get("username"); ok {
+		adname = username.(string)
+	}
+	for tp, com := range tMap {
+		err = rpSvc.ReportDel(c, com.Oids, com.RpIDs, adid, v.FTime, tp, v.Audit, v.Moral, v.Reason, v.FReason, v.Notify, adname, v.Remark, v.Content)
+		if err != nil {
+			c.JSON(nil, err)
+			return
+		}
+	}
+	c.JSON(nil, err)
+	return
+}
+
+func reportIgnore(c *bm.Context) {
+	v := new(struct {
+		RpID    []int64 `form:"rpid,split" validate:"required"`
+		Oid     []int64 `form:"oid,split" validate:"required"`
+		Type    []int32 `form:"type,split" validate:"required"`
+		AdminID int64   `form:"adid"`
+		Remark  string  `form:"remark"`
+		Audit   int32   `form:"audit"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	if len(v.RpID) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if len(v.RpID) != len(v.Oid) || len(v.RpID) != len(v.Type) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	tMap := make(map[int32]*Compose)
+	for i, tp := range v.Type {
+		if c, ok := tMap[tp]; ok {
+			c.Oids = append(c.Oids, v.Oid[i])
+			c.RpIDs = append(c.RpIDs, v.RpID[i])
+		} else {
+			c = &Compose{
+				Oids:  []int64{v.Oid[i]},
+				RpIDs: []int64{v.RpID[i]},
+			}
+			tMap[tp] = c
+		}
+	}
+	adid := v.AdminID
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	var adName string
+	if uname, ok := c.Get("username"); ok {
+		adName = uname.(string)
+	}
+	for tp, com := range tMap {
+		err = rpSvc.ReportIgnore(c, com.Oids, com.RpIDs, adid, adName, tp, v.Audit, v.Remark, true)
+	}
+	c.JSON(nil, err)
+	return
+}
+
+func reportRecover(c *bm.Context) {
+	v := new(struct {
+		RpID    []int64 `form:"rpid,split" validate:"required"`
+		Oid     []int64 `form:"oid,split" validate:"required"`
+		Type    []int32 `form:"type,split" validate:"required"`
+		AdminID int64   `form:"adid"`
+		Remark  string  `form:"remark"`
+		Audit   int32   `form:"audit"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	if len(v.RpID) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if len(v.RpID) != len(v.Oid) || len(v.RpID) != len(v.Type) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	tMap := make(map[int32]*Compose)
+	for i, tp := range v.Type {
+		if c, ok := tMap[tp]; ok {
+			c.Oids = append(c.Oids, v.Oid[i])
+			c.RpIDs = append(c.RpIDs, v.RpID[i])
+		} else {
+			c = &Compose{
+				Oids:  []int64{v.Oid[i]},
+				RpIDs: []int64{v.RpID[i]},
+			}
+			tMap[tp] = c
+		}
+	}
+	adid := v.AdminID
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+
+	for tp, com := range tMap {
+		err = rpSvc.ReportRecover(c, com.Oids, com.RpIDs, adid, tp, v.Audit, v.Remark)
+	}
+	c.JSON(nil, err)
+}
+
+func reportTransfer(c *bm.Context) {
+	v := new(struct {
+		RpID    []int64 `form:"rpid,split" validate:"required"`
+		Oid     []int64 `form:"oid,split" validate:"required"`
+		Type    []int32 `form:"type,split" validate:"required"`
+		AdminID int64   `form:"adid"`
+		Remark  string  `form:"remark"`
+		Audit   int32   `form:"audit"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	if len(v.RpID) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if len(v.RpID) != len(v.Oid) || len(v.RpID) != len(v.Type) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	tMap := make(map[int32]*Compose)
+	for i, tp := range v.Type {
+		if c, ok := tMap[tp]; ok {
+			c.Oids = append(c.Oids, v.Oid[i])
+			c.RpIDs = append(c.RpIDs, v.RpID[i])
+		} else {
+			c = &Compose{
+				Oids:  []int64{v.Oid[i]},
+				RpIDs: []int64{v.RpID[i]},
+			}
+			tMap[tp] = c
+		}
+	}
+	adid := v.AdminID
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	var adName string
+	if uname, ok := c.Get("username"); ok {
+		adName = uname.(string)
+	}
+	for tp, com := range tMap {
+		err = rpSvc.ReportTransfer(c, com.Oids, com.RpIDs, adid, adName, tp, v.Audit, v.Remark)
+	}
+	c.JSON(nil, err)
+}
+
+func reportStateSet(c *bm.Context) {
+	v := new(struct {
+		RpID    []int64 `form:"rpid,split" validate:"required"`
+		Oid     []int64 `form:"oid,split" validate:"required"`
+		Type    []int32 `form:"type,split" validate:"required"`
+		AdminID int64   `form:"adid"`
+		AdName  string  `form:"adname"`
+		Remark  string  `form:"remark"`
+		State   int32   `form:"state"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	if len(v.RpID) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if len(v.RpID) != len(v.Oid) || len(v.RpID) != len(v.Type) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	tMap := make(map[int32]*Compose)
+	for i, tp := range v.Type {
+		if c, ok := tMap[tp]; ok {
+			c.Oids = append(c.Oids, v.Oid[i])
+			c.RpIDs = append(c.RpIDs, v.RpID[i])
+		} else {
+			c = &Compose{
+				Oids:  []int64{v.Oid[i]},
+				RpIDs: []int64{v.RpID[i]},
+			}
+			tMap[tp] = c
+		}
+	}
+	if uid, ok := c.Get("uid"); ok {
+		v.AdminID = uid.(int64)
+	}
+	if uname, ok := c.Get("username"); ok {
+		v.AdName = uname.(string)
+	}
+	for tp, com := range tMap {
+		err = rpSvc.ReportStateSet(c, com.Oids, com.RpIDs, v.AdminID, v.AdName, tp, v.State, v.Remark, true)
+	}
+	c.JSON(nil, err)
+
+}

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

@@ -0,0 +1,133 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/reply/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+const (
+	_remarkLength = 200
+)
+
+func adminSubject(c *bm.Context) {
+	params := c.Request.Form
+	oidStr := params.Get("oid")
+	tpStr := params.Get("type")
+	oid, err := strconv.ParseInt(oidStr, 10, 64)
+	if err != nil {
+		log.Warn("strconv.ParseInt(%s) error(%v)", oidStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	tp, err := strconv.ParseInt(tpStr, 10, 64)
+	if err != nil {
+		log.Warn("strconv.ParseInt(%s) error(%v)", tpStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	sub, err := rpSvc.Subject(c, oid, int32(tp))
+	if err != nil {
+		log.Error("rpSvr.AdminGetSubjectState(oid%d,tp,%d)error(%v)", oid, int32(tp))
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(sub, nil)
+	return
+}
+
+// adminSubjectState modify subject state
+func adminSubjectState(c *bm.Context) {
+	v := new(struct {
+		Oid    []int64 `form:"oid,split" validate:"required"`
+		Type   int32   `form:"type" validate:"required"`
+		State  int32   `form:"state"`
+		Remark string  `form:"remark"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	var adid int64
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	var adName string
+	if uname, ok := c.Get("username"); ok {
+		adName = uname.(string)
+	}
+	fails, err := rpSvc.ModifySubState(c, adid, adName, v.Oid, v.Type, v.State, v.Remark)
+	c.JSON(fails, err)
+	return
+}
+
+// SubLogSearch returns all subjects in recent 3 months by default,
+// accept start time, end time, page, pagesize, order, sort as parameters.
+func SubLogSearch(c *bm.Context) {
+	v := new(struct {
+		Oid       int64  `form:"oid"`
+		Type      int32  `form:"type"`
+		StartTime string `form:"start_time"`
+		EndTime   string `form:"end_time"`
+		Page      int64  `form:"pn"`
+		PageSize  int64  `form:"ps"`
+		Order     string `form:"order"`
+		Sort      string `form:"sort"`
+	})
+	var err error
+	err = c.Bind(v)
+	if err != nil {
+		return
+	}
+	if v.EndTime == "" {
+		v.EndTime = time.Now().Format(model.DateFormat)
+	}
+	// 默认只展示3个月内的数据
+	if v.StartTime == "" {
+		v.StartTime = time.Now().AddDate(0, -3, 0).Format(model.DateFormat)
+	}
+	sp := model.LogSearchParam{
+		Oid:       v.Oid,
+		Type:      v.Type,
+		CtimeFrom: v.StartTime,
+		CtimeTo:   v.EndTime,
+		Pn:        v.Page,
+		Ps:        v.PageSize,
+		Order:     v.Order,
+		Sort:      v.Sort,
+	}
+	data, err := rpSvc.SubjectLog(c, sp)
+	res := map[string]interface{}{}
+	res["data"] = data
+	c.JSONMap(res, err)
+	return
+}
+
+// SubFreeze freeze or unfreeze the comments.
+func SubFreeze(c *bm.Context) {
+	v := new(struct {
+		Oid    []int64 `form:"oid,split"`
+		Type   int32   `form:"type"`
+		Freeze int32   `form:"freeze"`
+		Remark string  `form:"remark"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	var adid int64
+	if uid, ok := c.Get("uid"); ok {
+		adid = uid.(int64)
+	}
+	var adName string
+	if uname, ok := c.Get("username"); ok {
+		adName = uname.(string)
+	}
+	fails, err := rpSvc.FreezeSub(c, adid, adName, v.Oid, v.Type, v.Freeze, v.Remark)
+	c.JSON(fails, err)
+	return
+}