Create & Init Project...

app/interface/main/space/http/BUILD

@@ -0,0 +1,65 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "account.go",
+        "album.go",
+        "app.go",
+        "archive.go",
+        "article.go",
+        "assist.go",
+        "bangumi.go",
+        "blacklist.go",
+        "channel.go",
+        "coin.go",
+        "dynamic.go",
+        "fav.go",
+        "http.go",
+        "setting.go",
+        "shop.go",
+        "tag.go",
+        "web.go",
+    ],
+    importpath = "go-common/app/interface/main/space/http",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/space/conf:go_default_library",
+        "//app/interface/main/space/model:go_default_library",
+        "//app/interface/main/space/service:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/service/main/assist/model/assist:go_default_library",
+        "//library/conf/env:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/auth:go_default_library",
+        "//library/net/http/blademaster/middleware/supervisor: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"],
+)
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)

app/interface/main/space/http/account.go

@@ -0,0 +1,178 @@
+package http
+
+import (
+	"strconv"
+	"strings"
+
+	"go-common/app/interface/main/space/conf"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func navNum(c *bm.Context) {
+	var (
+		vmid, mid int64
+		err       error
+	)
+	midStr := c.Request.Form.Get("mid")
+	if vmid, err = strconv.ParseInt(midStr, 10, 64); err != nil || vmid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.NavNum(c, mid, vmid), nil)
+}
+
+func upStat(c *bm.Context) {
+	var (
+		mid int64
+		err error
+	)
+	midStr := c.Request.Form.Get("mid")
+	if mid, err = strconv.ParseInt(midStr, 10, 64); err != nil || mid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(spcSvc.UpStat(c, mid))
+}
+
+func myInfo(c *bm.Context) {
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(spcSvc.MyInfo(c, mid))
+}
+
+func notice(c *bm.Context) {
+	v := new(struct {
+		Mid int64 `form:"mid" validate:"gt=0"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(spcSvc.Notice(c, v.Mid))
+}
+
+func setNotice(c *bm.Context) {
+	v := new(struct {
+		Notice string `form:"notice" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	notice := strings.Trim(v.Notice, " ")
+	if len([]rune(notice)) > conf.Conf.Rule.MaxNoticeLen {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(nil, spcSvc.SetNotice(c, mid, notice))
+}
+
+func accTags(c *bm.Context) {
+	v := new(struct {
+		Mid int64 `form:"mid" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(spcSvc.AccTags(c, v.Mid))
+}
+
+func setAccTags(c *bm.Context) {
+	v := new(struct {
+		Tags string `form:"tags" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	tags := strings.Split(v.Tags, ",")
+	var addTags []string
+	for _, v := range tags {
+		if tag := strings.TrimSpace(v); tag != "" {
+			addTags = append(addTags, tag)
+		}
+	}
+	if len(addTags) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, spcSvc.SetAccTags(c, strings.Join(addTags, ","), c.Request.Header.Get("Cookie")))
+}
+
+func accInfo(c *bm.Context) {
+	var (
+		mid, vmid int64
+		err       error
+	)
+	vmidStr := c.Request.Form.Get("mid")
+	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || vmid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.AccInfo(c, mid, vmid))
+}
+
+func lastPlayGame(c *bm.Context) {
+	var (
+		mid, vmid int64
+		err       error
+	)
+	vmidStr := c.Request.Form.Get("mid")
+	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || vmid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.LastPlayGame(c, mid, vmid))
+}
+
+func themeList(c *bm.Context) {
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(spcSvc.ThemeList(c, mid))
+}
+
+func themeActive(c *bm.Context) {
+	var (
+		themeID int64
+		err     error
+	)
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	themeIDStr := c.Request.Form.Get("theme_id")
+	if themeID, err = strconv.ParseInt(themeIDStr, 10, 64); err != nil || themeID <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, spcSvc.ThemeActive(c, mid, themeID))
+}
+
+func relation(c *bm.Context) {
+	v := new(struct {
+		Vmid int64 `form:"mid" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(spcSvc.Relation(c, mid, v.Vmid), nil)
+}
+
+func clearCache(c *bm.Context) {
+	v := new(struct {
+		Msg string `form:"msg" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(nil, spcSvc.ClearCache(c, v.Msg))
+}

app/interface/main/space/http/album.go

@@ -0,0 +1,16 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func albumIndex(c *bm.Context) {
+	v := new(struct {
+		Mid int64 `form:"mid" validate:"min=1"`
+		Ps  int   `form:"ps" default:"8" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(spcSvc.AlbumIndex(c, v.Mid, v.Ps))
+}

app/interface/main/space/http/app.go

@@ -0,0 +1,71 @@
+package http
+
+import (
+	"go-common/app/interface/main/space/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func appIndex(c *bm.Context) {
+	v := new(model.AppIndexArg)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		v.Mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.AppIndex(c, v))
+}
+
+func appPlayedGame(c *bm.Context) {
+	var (
+		mid   int64
+		list  []*model.AppGame
+		count int
+		err   error
+	)
+	v := new(struct {
+		VMid     int64  `form:"mid" validate:"min=1"`
+		Platform string `form:"platform" default:"android" validate:"required"`
+		Pn       int    `form:"pn" default:"1" validate:"min=1"`
+		Ps       int    `form:"ps" default:"20" validate:"min=1"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	list, count, err = spcSvc.AppPlayedGame(c, mid, v.VMid, v.Platform, v.Pn, v.Ps)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	data := make(map[string]interface{}, 2)
+	page := map[string]int{
+		"pn":    v.Pn,
+		"ps":    v.Ps,
+		"count": count,
+	}
+	data["page"] = page
+	data["list"] = list
+	c.JSON(data, nil)
+}
+
+func appTopPhoto(c *bm.Context) {
+	var mid int64
+	v := new(struct {
+		Vmid     int64  `form:"mid" validate:"min=1"`
+		Platform string `form:"platform" default:"android"`
+		Device   string `form:"device"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	imgURL := spcSvc.AppTopPhoto(c, mid, v.Vmid, v.Platform, v.Device)
+	c.JSON(&struct {
+		ImgURL string `json:"img_url"`
+	}{ImgURL: imgURL}, nil)
+}

app/interface/main/space/http/archive.go

@@ -0,0 +1,183 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/space/conf"
+	"go-common/app/interface/main/space/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"strings"
+)
+
+func topArc(c *bm.Context) {
+	var (
+		mid, vmid int64
+		err       error
+	)
+	vmidStr := c.Request.Form.Get("vmid")
+	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || vmid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.TopArc(c, mid, vmid))
+}
+
+func setTopArc(c *bm.Context) {
+	v := new(struct {
+		Aid    int64  `form:"aid" validate:"min=1"`
+		Reason string `form:"reason"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	reason := strings.TrimSpace(v.Reason)
+	if len([]rune(reason)) > conf.Conf.Rule.MaxTopReasonLen {
+		c.JSON(nil, ecode.TopReasonLong)
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(nil, spcSvc.SetTopArc(c, mid, v.Aid, reason))
+}
+
+func cancelTopArc(c *bm.Context) {
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(nil, spcSvc.DelTopArc(c, mid))
+}
+
+func masterpiece(c *bm.Context) {
+	var (
+		mid, vmid int64
+		err       error
+	)
+	vmidStr := c.Request.Form.Get("vmid")
+	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || vmid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.Masterpiece(c, mid, vmid))
+}
+
+func addMasterpiece(c *bm.Context) {
+	v := new(struct {
+		Aid    int64  `form:"aid" validate:"min=1"`
+		Reason string `form:"reason"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	reason := strings.TrimSpace(v.Reason)
+	if len([]rune(reason)) > conf.Conf.Rule.MaxMpReasonLen {
+		c.JSON(nil, ecode.TopReasonLong)
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(nil, spcSvc.AddMasterpiece(c, mid, v.Aid, reason))
+}
+
+func editMasterpiece(c *bm.Context) {
+	v := new(struct {
+		Aid    int64  `form:"aid" validate:"min=1"`
+		PreAid int64  `form:"pre_aid" validate:"min=1"`
+		Reason string `form:"reason"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	reason := strings.TrimSpace(v.Reason)
+	if len([]rune(reason)) > conf.Conf.Rule.MaxMpReasonLen {
+		c.JSON(nil, ecode.TopReasonLong)
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(nil, spcSvc.EditMasterpiece(c, mid, v.Aid, v.PreAid, reason))
+}
+
+func cancelMasterpiece(c *bm.Context) {
+	v := new(struct {
+		Aid int64 `form:"aid" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(nil, spcSvc.CancelMasterpiece(c, mid, v.Aid))
+}
+
+func arcSearch(c *bm.Context) {
+	var (
+		res   *model.SearchRes
+		total int
+		mid   int64
+		err   error
+		v     = new(model.SearchArg)
+	)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if v.CheckType != "" {
+		if _, ok := model.ArcCheckType[v.CheckType]; !ok {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if v.CheckID <= 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	if res, total, err = spcSvc.ArcSearch(c, mid, v); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	data := make(map[string]interface{}, 2)
+	page := map[string]int{
+		"pn":    v.Pn,
+		"ps":    v.Ps,
+		"count": total,
+	}
+	data["page"] = page
+	data["list"] = res
+	c.JSON(data, nil)
+}
+
+func arcList(c *bm.Context) {
+	var (
+		rs  *model.UpArc
+		err error
+	)
+	v := new(struct {
+		Mid int64 `form:"mid" validate:"min=1"`
+		Pn  int32 `form:"pn" default:"1" validate:"min=1"`
+		Ps  int32 `form:"ps" default:"20" validate:"min=1"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if rs, err = spcSvc.UpArcs(c, v.Mid, v.Pn, v.Ps); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	data := make(map[string]interface{}, 2)
+	page := map[string]int64{
+		"pn":    int64(v.Pn),
+		"ps":    int64(v.Ps),
+		"count": rs.Count,
+	}
+	data["page"] = page
+	data["archives"] = rs.List
+	c.JSON(data, nil)
+}

app/interface/main/space/http/article.go

@@ -0,0 +1,44 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/space/conf"
+	"go-common/app/interface/main/space/model"
+	artmdl "go-common/app/interface/openplatform/article/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func article(c *bm.Context) {
+	var (
+		mid          int64
+		pn, ps, sort int
+		ok           bool
+		err          error
+	)
+	params := c.Request.Form
+	midStr := params.Get("mid")
+	pnStr := params.Get("pn")
+	psStr := params.Get("ps")
+	sortStr := params.Get("sort")
+	if mid, err = strconv.ParseInt(midStr, 10, 64); err != nil || mid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if pn, err = strconv.Atoi(pnStr); err != nil || pn < 1 {
+		pn = 1
+	}
+	if ps, err = strconv.Atoi(psStr); err != nil || ps < 1 || ps > conf.Conf.Rule.MaxArticlePs {
+		ps = conf.Conf.Rule.MaxArticlePs
+	}
+	if sortStr != "" {
+		if sort, ok = model.ArticleSortType[sortStr]; !ok {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	} else {
+		sort = artmdl.FieldDefault
+	}
+	c.JSON(spcSvc.Article(c, mid, pn, ps, sort))
+}

app/interface/main/space/http/assist.go

@@ -0,0 +1,61 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/space/conf"
+	"go-common/app/service/main/assist/model/assist"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func riderList(c *bm.Context) {
+	var (
+		mid    int64
+		pn, ps int
+		rider  *assist.AssistUpsPager
+		err    error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	pnStr := params.Get("pn")
+	psStr := params.Get("ps")
+	if pn, err = strconv.Atoi(pnStr); err != nil || pn < 1 {
+		pn = 1
+	}
+	if ps, err = strconv.Atoi(psStr); err != nil || ps < 1 || ps > conf.Conf.Rule.MaxRiderPs {
+		ps = conf.Conf.Rule.MaxRiderPs
+	}
+	if rider, err = spcSvc.RiderList(c, mid, pn, ps); err != nil {
+		log.Error("spcSvc.RiderList(%d,%d,%d) error(%v)", mid, pn, ps, err)
+		c.JSON(nil, err)
+		return
+	}
+	data := make(map[string]interface{}, 2)
+	page := map[string]int{
+		"pn":    pn,
+		"ps":    ps,
+		"count": int(rider.Pager.Total),
+	}
+	data["page"] = page
+	data["list"] = rider.Data
+	c.JSON(data, nil)
+}
+
+func exitRider(c *bm.Context) {
+	var (
+		mid, upMid int64
+		err        error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	upMidStr := params.Get("up_mid")
+	if upMid, err = strconv.ParseInt(upMidStr, 10, 64); err != nil || upMid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, spcSvc.ExitRider(c, mid, upMid))
+}

app/interface/main/space/http/bangumi.go

@@ -0,0 +1,59 @@
+package http
+
+import (
+	"go-common/app/interface/main/space/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func bangumiList(c *bm.Context) {
+	var (
+		mid   int64
+		list  []*model.Bangumi
+		count int
+		err   error
+	)
+	v := new(struct {
+		Vmid int64 `form:"vmid" validate:"min=1"`
+		Pn   int   `form:"pn" default:"1" validate:"min=1"`
+		Ps   int   `form:"ps" default:"15" validate:"min=1"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	if list, count, err = spcSvc.BangumiList(c, mid, v.Vmid, v.Pn, v.Ps); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	type data struct {
+		List []*model.Bangumi `json:"list"`
+		*model.Page
+	}
+	c.JSON(&data{List: list, Page: &model.Page{Pn: v.Pn, Ps: v.Ps, Total: count}}, nil)
+}
+
+func bangumiConcern(c *bm.Context) {
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	v := new(struct {
+		SeasonID int64 `form:"season_id" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(nil, spcSvc.BangumiConcern(c, mid, v.SeasonID))
+}
+
+func bangumiUnConcern(c *bm.Context) {
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	v := new(struct {
+		SeasonID int64 `form:"season_id" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(nil, spcSvc.BangumiUnConcern(c, mid, v.SeasonID))
+}

app/interface/main/space/http/blacklist.go

@@ -0,0 +1,22 @@
+package http
+
+import (
+	"go-common/library/conf/env"
+	bm "go-common/library/net/http/blademaster"
+)
+
+var (
+	_EmptyBlacklistValue = make(map[int64]struct{})
+)
+
+func blacklist(c *bm.Context) {
+	black := spcSvc.BlacklistValue
+	if env.DeployEnv == env.DeployEnvProd {
+		if len(black) == 0 {
+			black = _EmptyBlacklistValue
+		}
+	} else {
+		black = _EmptyBlacklistValue
+	}
+	c.JSON(black, nil)
+}

app/interface/main/space/http/channel.go

@@ -0,0 +1,343 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/space/conf"
+	"go-common/app/interface/main/space/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+func channel(c *bm.Context) {
+	var (
+		vmid, mid, cid int64
+		isGuest        bool
+		err            error
+	)
+	params := c.Request.Form
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	vmidStr := params.Get("mid")
+	cidStr := params.Get("cid")
+	guestStr := params.Get("guest")
+	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || (vmid <= 0 && mid <= 0) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil || cid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if guestStr != "" {
+		if isGuest, err = strconv.ParseBool(guestStr); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if !isGuest && vmid > 0 && mid != vmid {
+		mid = vmid
+	}
+	c.JSON(spcSvc.Channel(c, mid, cid))
+}
+
+func channelIndex(c *bm.Context) {
+	var (
+		vmid, mid int64
+		isGuest   bool
+		err       error
+	)
+	params := c.Request.Form
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	vmidStr := params.Get("mid")
+	guestStr := params.Get("guest")
+	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || (vmid <= 0 && mid <= 0) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if guestStr != "" {
+		if isGuest, err = strconv.ParseBool(guestStr); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if !isGuest && vmid > 0 && mid != vmid {
+		isGuest = true
+		mid = vmid
+	}
+	c.JSON(spcSvc.ChannelIndex(c, mid, isGuest))
+}
+
+func channelList(c *bm.Context) {
+	var (
+		vmid, mid int64
+		channels  []*model.Channel
+		isGuest   bool
+		err       error
+	)
+	params := c.Request.Form
+	vmidStr := params.Get("mid")
+	guestStr := params.Get("guest")
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || (vmid <= 0 && mid <= 0) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if guestStr != "" {
+		if isGuest, err = strconv.ParseBool(guestStr); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if !isGuest && vmid > 0 && mid != vmid {
+		isGuest = true
+		mid = vmid
+	}
+	if channels, err = spcSvc.ChannelList(c, mid, isGuest); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	data := make(map[string]interface{}, 2)
+	data["count"] = len(channels)
+	data["list"] = channels
+	c.JSON(data, nil)
+}
+
+func addChannel(c *bm.Context) {
+	var (
+		mid, cid int64
+		err      error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	name := params.Get("name")
+	intro := params.Get("intro")
+	if name == "" || len([]rune(name)) > conf.Conf.Rule.MaxChNameLen {
+		c.JSON(nil, ecode.ChNameToLong)
+		return
+	}
+	if intro != "" && len([]rune(intro)) > conf.Conf.Rule.MaxChIntroLen {
+		c.JSON(nil, ecode.ChIntroToLong)
+		return
+	}
+	if cid, err = spcSvc.AddChannel(c, mid, name, intro); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(struct {
+		Cid int64 `json:"cid"`
+	}{Cid: cid}, nil)
+}
+
+func editChannel(c *bm.Context) {
+	var (
+		mid, cid int64
+		err      error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	cidStr := params.Get("cid")
+	name := params.Get("name")
+	intro := params.Get("intro")
+	if cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil || cid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if name == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if len([]rune(name)) > conf.Conf.Rule.MaxChNameLen {
+		c.JSON(nil, ecode.ChNameToLong)
+		return
+	}
+	if intro != "" && len([]rune(intro)) > conf.Conf.Rule.MaxChIntroLen {
+		c.JSON(nil, ecode.ChIntroToLong)
+		return
+	}
+	c.JSON(nil, spcSvc.EditChannel(c, mid, cid, name, intro))
+}
+
+func delChannel(c *bm.Context) {
+	var (
+		mid, cid int64
+		err      error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	cidStr := params.Get("cid")
+	if cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil || cid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, spcSvc.DelChannel(c, mid, cid))
+}
+
+func channelVideo(c *bm.Context) {
+	var (
+		vmid, mid, cid int64
+		pn, ps         int
+		isGuest, order bool
+		channelDetail  *model.ChannelDetail
+		err            error
+	)
+	params := c.Request.Form
+	vmidStr := params.Get("mid")
+	cidStr := params.Get("cid")
+	pnStr := params.Get("pn")
+	psStr := params.Get("ps")
+	guestStr := params.Get("guest")
+	orderStr := params.Get("order")
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || (vmid <= 0 && mid <= 0) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil || cid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if pn, err = strconv.Atoi(pnStr); err != nil || pn < 1 {
+		pn = 1
+	}
+	if ps, err = strconv.Atoi(psStr); err != nil || ps < 1 || ps > conf.Conf.Rule.MaxChArcsPs {
+		ps = conf.Conf.Rule.MaxChArcsPs
+	}
+	if guestStr != "" {
+		if isGuest, err = strconv.ParseBool(guestStr); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if !isGuest && vmid > 0 && mid != vmid {
+		isGuest = true
+		mid = vmid
+	}
+	if orderStr != "" {
+		if order, err = strconv.ParseBool(orderStr); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if channelDetail, err = spcSvc.ChannelVideos(c, mid, cid, pn, ps, isGuest, order); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	data := make(map[string]interface{}, 2)
+	page := map[string]int{
+		"num":   pn,
+		"size":  ps,
+		"count": channelDetail.Count,
+	}
+	data["page"] = page
+	data["list"] = channelDetail
+	c.JSON(data, nil)
+}
+
+func addChannelVideo(c *bm.Context) {
+	var (
+		mid, cid int64
+		aids     []int64
+		err      error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	cidStr := params.Get("cid")
+	if cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil || cid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	aidStr := params.Get("aids")
+	if aidStr == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if aids, err = xstr.SplitInts(aidStr); err != nil || len(aids) == 0 || len(aids) > conf.Conf.Rule.MaxChArcAddLimit {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	aidMap := make(map[int64]int64, len(aids))
+	for _, aid := range aids {
+		aidMap[aid] = aid
+	}
+	if len(aidMap) < len(aids) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(spcSvc.AddChannelArc(c, mid, cid, aids))
+}
+
+func delChannelVideo(c *bm.Context) {
+	var (
+		mid, cid, aid int64
+		err           error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	cidStr := params.Get("cid")
+	if cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil || cid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	aidStr := params.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, spcSvc.DelChannelArc(c, mid, cid, aid))
+}
+
+func sortChannelVideo(c *bm.Context) {
+	var (
+		mid, cid, aid int64
+		orderNum      int
+		err           error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	cidStr := params.Get("cid")
+	aidStr := params.Get("aid")
+	toStr := params.Get("to")
+	if cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil || cid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if orderNum, err = strconv.Atoi(toStr); err != nil || orderNum < 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, spcSvc.SortChannelArc(c, mid, cid, aid, orderNum))
+}
+
+func checkChannelVideo(c *bm.Context) {
+	var (
+		mid, cid int64
+		err      error
+	)
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	cidStr := c.Request.Form.Get("cid")
+	if cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil || cid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, spcSvc.CheckChannelVideo(c, mid, cid))
+}

app/interface/main/space/http/coin.go

@@ -0,0 +1,24 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func coinVideo(c *bm.Context) {
+	var (
+		mid, vmid int64
+		err       error
+	)
+	vmidStr := c.Request.Form.Get("vmid")
+	if vmid, err = strconv.ParseInt(vmidStr, 10, 64); err != nil || vmid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.CoinVideo(c, mid, vmid))
+}

app/interface/main/space/http/dynamic.go

@@ -0,0 +1,42 @@
+package http
+
+import (
+	"time"
+
+	"go-common/app/interface/main/space/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func setTopDynamic(c *bm.Context) {
+	v := new(struct {
+		DyID int64 `form:"dy_id" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(nil, spcSvc.SetTopDynamic(c, mid, v.DyID))
+}
+
+func cancelTopDynamic(c *bm.Context) {
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(nil, spcSvc.CancelTopDynamic(c, mid, time.Now()))
+}
+
+func dynamicList(c *bm.Context) {
+	v := new(model.DyListArg)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if v.Pn > 1 && v.LastTime == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		v.Mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.DynamicList(c, v))
+}

app/interface/main/space/http/fav.go

@@ -0,0 +1,32 @@
+package http
+
+import (
+	"go-common/app/interface/main/space/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func favNav(c *bm.Context) {
+	var mid int64
+	v := new(struct {
+		VMid int64 `form:"mid" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.FavNav(c, mid, v.VMid))
+}
+
+func favArc(c *bm.Context) {
+	var mid int64
+	v := new(model.FavArcArg)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.FavArchive(c, mid, v))
+}

app/interface/main/space/http/http.go

@@ -0,0 +1,164 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/interface/main/space/conf"
+	"go-common/app/interface/main/space/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/auth"
+	"go-common/library/net/http/blademaster/middleware/supervisor"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	authSvr *auth.Auth
+	spcSvc  *service.Service
+	spvSvc  *supervisor.Supervisor
+	vfySvc  *verify.Verify
+)
+
+// Init init http server
+func Init(c *conf.Config, s *service.Service) {
+	authSvr = auth.New(c.Auth)
+	spvSvc = supervisor.New(c.Supervisor)
+	vfySvc = verify.New(c.Verify)
+	spcSvc = s
+	// init http server
+	engine := bm.DefaultServer(c.HTTPServer)
+	outerRouter(engine)
+	internalRouter(engine)
+	// init Outer serve
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func outerRouter(e *bm.Engine) {
+	e.GET("/monitor/ping", ping)
+	group := e.Group("/x/space", bm.CORS())
+	{
+		chGroup := group.Group("/channel")
+		{
+			chGroup.GET("", authSvr.Guest, channel)
+			chGroup.GET("/index", authSvr.Guest, channelIndex)
+			chGroup.GET("/list", authSvr.Guest, channelList)
+			chGroup.POST("/add", spvSvc.ServeHTTP, authSvr.User, addChannel)
+			chGroup.POST("/del", authSvr.User, delChannel)
+			chGroup.POST("/edit", spvSvc.ServeHTTP, authSvr.User, editChannel)
+		}
+		chvGroup := group.Group("/channel/video")
+		{
+			chvGroup.GET("", authSvr.Guest, channelVideo)
+			chvGroup.POST("/add", authSvr.User, addChannelVideo)
+			chvGroup.POST("/del", authSvr.User, delChannelVideo)
+			chvGroup.POST("/sort", authSvr.User, sortChannelVideo)
+			chvGroup.GET("/check", authSvr.User, checkChannelVideo)
+		}
+		riderGroup := group.Group("/rider")
+		{
+			riderGroup.GET("/list", authSvr.User, riderList)
+			riderGroup.POST("/exit", authSvr.User, exitRider)
+		}
+		tagGroup := group.Group("/tag")
+		{
+			tagGroup.POST("/sub", authSvr.User, tagSub)
+			tagGroup.POST("/sub/cancel", authSvr.User, tagCancelSub)
+			tagGroup.GET("/sub/list", authSvr.Guest, tagSubList)
+		}
+		bgmGroup := group.Group("/bangumi")
+		{
+			bgmGroup.POST("/concern", authSvr.User, bangumiConcern)
+			bgmGroup.POST("/unconcern", authSvr.User, bangumiUnConcern)
+			bgmGroup.GET("/concern/list", authSvr.Guest, bangumiList)
+		}
+		topGroup := group.Group("/top")
+		{
+			topGroup.GET("/arc", authSvr.Guest, topArc)
+			topGroup.POST("/arc/set", authSvr.User, setTopArc)
+			topGroup.POST("/arc/cancel", authSvr.User, cancelTopArc)
+			topGroup.POST("/dynamic/set", authSvr.User, setTopDynamic)
+			topGroup.POST("/dynamic/cancel", authSvr.User, cancelTopDynamic)
+		}
+		mpGroup := group.Group("/masterpiece")
+		{
+			mpGroup.GET("", authSvr.Guest, masterpiece)
+			mpGroup.POST("/add", authSvr.User, addMasterpiece)
+			mpGroup.POST("/edit", authSvr.User, editMasterpiece)
+			mpGroup.POST("/cancel", authSvr.User, cancelMasterpiece)
+		}
+		noticeGroup := group.Group("/notice")
+		{
+			noticeGroup.GET("", notice)
+			noticeGroup.POST("/set", authSvr.User, setNotice)
+		}
+		accGroup := group.Group("/acc")
+		{
+			accGroup.GET("/info", authSvr.Guest, accInfo)
+			accGroup.GET("/tags", accTags)
+			accGroup.POST("/tags/set", authSvr.User, setAccTags)
+			accGroup.GET("/relation", authSvr.User, relation)
+		}
+		themeGroup := group.Group("theme")
+		{
+			themeGroup.GET("/list", authSvr.User, themeList)
+			themeGroup.POST("/active", authSvr.User, themeActive)
+		}
+		appGroup := group.Group("/app")
+		{
+			appGroup.GET("/index", authSvr.Guest, appIndex)
+			appGroup.GET("/dynamic/list", authSvr.Guest, dynamicList)
+			appGroup.GET("/played/game", authSvr.Guest, appPlayedGame)
+			appGroup.GET("/top/photo", authSvr.Guest, appTopPhoto)
+		}
+		arcGroup := group.Group("/arc")
+		{
+			arcGroup.GET("/search", arcSearch)
+			arcGroup.GET("/list", arcList)
+		}
+		group.GET("/setting", settingInfo)
+		group.GET("/article", article)
+		group.GET("/navnum", authSvr.Guest, navNum)
+		group.GET("/upstat", upStat)
+		group.GET("/shop", authSvr.User, shopInfo)
+		group.GET("/album/index", albumIndex)
+		group.GET("/fav/nav", authSvr.Guest, favNav)
+		group.GET("/fav/arc", authSvr.Guest, favArc)
+		group.GET("/coin/video", authSvr.Guest, coinVideo)
+		group.GET("/myinfo", authSvr.User, myInfo)
+		group.GET("/lastplaygame", authSvr.Guest, lastPlayGame)
+		group.POST("/privacy/modify", authSvr.User, privacyModify)
+		group.POST("/index/order/modify", authSvr.User, indexOrderModify)
+	}
+}
+
+func internalRouter(e *bm.Engine) {
+	group := e.Group("/x/internal/space")
+	{
+		group.GET("/setting", vfySvc.Verify, settingInfo)
+		group.GET("/myinfo", vfySvc.Verify, authSvr.User, myInfo)
+		group.POST("/privacy/modify", authSvr.User, privacyModify)
+		group.POST("/privacy/batch/modify", authSvr.User, privacyBatchModify)
+		group.POST("/index/order/modify", authSvr.User, indexOrderModify)
+		accGroup := group.Group("/acc")
+		{
+			accGroup.GET("/info", vfySvc.Verify, authSvr.Guest, accInfo)
+		}
+		appGroup := group.Group("/app")
+		{
+			appGroup.GET("/index", vfySvc.Verify, authSvr.Guest, appIndex)
+		}
+		group.GET("/web/index", vfySvc.Verify, authSvr.Guest, webIndex)
+		group.POST("/cache/clear", clearCache)
+		group.GET("/blacklist", vfySvc.Verify, blacklist)
+	}
+}
+
+func ping(c *bm.Context) {
+	if err := spcSvc.Ping(c); err != nil {
+		log.Error("space-interface ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

app/interface/main/space/http/setting.go

@@ -0,0 +1,104 @@
+package http
+
+import (
+	"strconv"
+	"strings"
+
+	"go-common/app/interface/main/space/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func settingInfo(c *bm.Context) {
+	var (
+		mid int64
+		err error
+	)
+	midStr := c.Request.Form.Get("mid")
+	if mid, err = strconv.ParseInt(midStr, 10, 64); err != nil || mid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(spcSvc.SettingInfo(c, mid))
+}
+
+func privacyModify(c *bm.Context) {
+	var (
+		mid        int64
+		field      string
+		value      int
+		fieldCheck bool
+		err        error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	if field = params.Get("field"); field == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	for _, v := range model.PrivacyFields {
+		if v == field {
+			fieldCheck = true
+			break
+		}
+	}
+	if !fieldCheck {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	valueStr := params.Get("value")
+	if value, err = strconv.Atoi(valueStr); err != nil || (value != 0 && value != 1) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, spcSvc.PrivacyModify(c, mid, field, value))
+}
+
+func privacyBatchModify(c *bm.Context) {
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	batch := make(map[string]int)
+	for _, v := range model.PrivacyFields {
+		if valueStr := params.Get(v); valueStr != "" {
+			if value, err := strconv.Atoi(params.Get(v)); err == nil && (value == 0 || value == 1) {
+				batch[v] = value
+			}
+		}
+	}
+	c.JSON(nil, spcSvc.PrivacyBatchModify(c, mid, batch))
+}
+
+func indexOrderModify(c *bm.Context) {
+	var (
+		mid           int64
+		indexOrderStr string
+		indexOrder    []string
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	if indexOrderStr = params.Get("index_order"); indexOrderStr == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	indexOrders := strings.Split(indexOrderStr, ",")
+	for _, v := range indexOrders {
+		i, err := strconv.Atoi(v)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if _, ok := model.IndexOrderMap[i]; !ok {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		indexOrder = append(indexOrder, v)
+	}
+	if len(indexOrder) != len(model.DefaultIndexOrder) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, spcSvc.IndexOrderModify(c, mid, indexOrder))
+}

app/interface/main/space/http/shop.go

@@ -0,0 +1,14 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func shopInfo(c *bm.Context) {
+	var (
+		mid int64
+	)
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	c.JSON(spcSvc.ShopInfo(c, mid))
+}

app/interface/main/space/http/tag.go

@@ -0,0 +1,59 @@
+package http
+
+import (
+	"go-common/app/interface/main/space/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func tagSub(c *bm.Context) {
+	v := new(struct {
+		TagID int64 `form:"tag_id" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(nil, spcSvc.TagSub(c, mid, v.TagID))
+}
+
+func tagCancelSub(c *bm.Context) {
+	v := new(struct {
+		TagID int64 `form:"tag_id" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(nil, spcSvc.TagCancelSub(c, mid, v.TagID))
+}
+
+func tagSubList(c *bm.Context) {
+	var (
+		mid   int64
+		tags  []*model.Tag
+		total int
+		err   error
+	)
+	v := new(struct {
+		Vmid int64 `form:"vmid" validate:"min=1"`
+		Pn   int   `form:"pn" default:"1" validate:"min=1"`
+		Ps   int   `form:"ps" default:"100" validate:"min=1"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	if tags, total, err = spcSvc.TagSubList(c, mid, v.Vmid, v.Pn, v.Ps); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	type data struct {
+		Tags []*model.Tag `json:"tags"`
+		*model.Page
+	}
+	c.JSON(&data{Tags: tags, Page: &model.Page{Pn: v.Pn, Ps: v.Ps, Total: total}}, nil)
+}

app/interface/main/space/http/web.go

@@ -0,0 +1,19 @@
+package http
+
+import bm "go-common/library/net/http/blademaster"
+
+func webIndex(c *bm.Context) {
+	var mid int64
+	v := new(struct {
+		VMid int64 `form:"mid" validate:"min=1"`
+		Pn   int32 `form:"pn" default:"1" validate:"min=1"`
+		Ps   int32 `form:"ps" default:"20" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(spcSvc.WebIndex(c, mid, v.VMid, v.Pn, v.Ps))
+}