Create & Init Project...

app/interface/main/web/http/BUILD

@@ -0,0 +1,71 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "account.go",
+        "archive.go",
+        "article.go",
+        "bnj.go",
+        "broadcast.go",
+        "coin.go",
+        "dynamic.go",
+        "elec.go",
+        "feedback.go",
+        "help.go",
+        "http.go",
+        "icon.go",
+        "ip.go",
+        "like.go",
+        "nav.go",
+        "newlist.go",
+        "online.go",
+        "ranking.go",
+        "resource.go",
+        "search.go",
+        "tag.go",
+        "wechat.go",
+    ],
+    importpath = "go-common/app/interface/main/web/http",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/web/conf:go_default_library",
+        "//app/interface/main/web/model:go_default_library",
+        "//app/interface/main/web/service:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/log/infoc:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/auth:go_default_library",
+        "//library/net/http/blademaster/middleware/cache:go_default_library",
+        "//library/net/http/blademaster/middleware/cache/store: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/web/http/account.go

@@ -0,0 +1,29 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func attentions(c *bm.Context) {
+	var mid int64
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	c.JSON(webSvc.Attentions(c, mid))
+}
+
+func card(c *bm.Context) {
+	var loginID int64
+	v := new(struct {
+		Mid      int64 `form:"mid" validate:"min=1"`
+		TopPhoto bool  `form:"photo"`
+		Article  bool  `form:"article"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	// login mid
+	if loginIDStr, ok := c.Get("mid"); ok {
+		loginID = loginIDStr.(int64)
+	}
+	c.JSON(webSvc.Card(c, v.Mid, loginID, v.TopPhoto, v.Article))
+}

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

@@ -0,0 +1,240 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/web/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+const (
+	_buvid = "buvid3"
+)
+
+func view(c *bm.Context) {
+	var (
+		aid, mid, cid int64
+		cookieStr     string
+		err           error
+		rs            *model.View
+	)
+	cookieStr = c.Request.Header.Get("Cookie")
+	aidStr := c.Request.Form.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	// get mid
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	cidStr := c.Request.Form.Get("cid")
+	if cidStr != "" {
+		if cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil || cid < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	cdnIP := c.Request.Header.Get("X-Cache-Server-Addr")
+	if rs, err = webSvc.View(c, aid, cid, mid, cdnIP, cookieStr); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(rs, nil)
+}
+
+func archiveStat(c *bm.Context) {
+	var (
+		aid int64
+		err error
+	)
+	aidStr := c.Request.Form.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(webSvc.ArchiveStat(c, aid))
+}
+
+func addShare(c *bm.Context) {
+	var (
+		aid, mid   int64
+		err        error
+		buvid, sid string
+	)
+	aidStr := c.Request.Form.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	// get mid
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	if bdCookie, _ := c.Request.Cookie(_buvid); bdCookie != nil {
+		buvid = bdCookie.Value
+	}
+	if sidCookie, _ := c.Request.Cookie("sid"); sidCookie != nil {
+		sid = sidCookie.Value
+	}
+	c.JSON(webSvc.AddShare(c, aid, mid, c.Request.UserAgent(), c.Request.Referer(), c.Request.URL.Path, buvid, sid))
+}
+
+func description(c *bm.Context) {
+	var (
+		aid, page int64
+		err       error
+	)
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	pstr := params.Get("page")
+	if pstr != "" {
+		if page, err = strconv.ParseInt(pstr, 10, 64); err != nil || page < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	c.JSON(webSvc.Description(c, aid, page))
+}
+
+func arcReport(c *bm.Context) {
+	var (
+		aid, mid, tp int64
+		err          error
+		params       = c.Request.Form
+	)
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	aidStr := params.Get("aid")
+	tpStr := params.Get("type")
+	reason := params.Get("reason")
+	pics := params.Get("pics")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if tp, err = strconv.ParseInt(tpStr, 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, webSvc.ArcReport(c, mid, aid, tp, reason, pics))
+}
+
+func appealTags(c *bm.Context) {
+	c.JSON(webSvc.AppealTags(c))
+}
+
+func arcAppeal(c *bm.Context) {
+	var (
+		mid int64
+		err error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	data := make(map[string]string)
+	for name := range params {
+		switch name {
+		case "tid":
+			tidStr := params.Get("tid")
+			if _, err = strconv.ParseInt(tidStr, 10, 64); err != nil {
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+			data["tid"] = tidStr
+		case "aid":
+			aidStr := params.Get("aid")
+			if _, err = strconv.ParseInt(aidStr, 10, 64); err != nil {
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+			data["oid"] = aidStr
+		case "desc":
+			desc := params.Get("desc")
+			if desc == "" {
+				c.JSON(nil, ecode.RequestErr)
+				return
+			}
+			data["description"] = desc
+		default:
+			data[name] = params.Get(name)
+		}
+	}
+	c.JSON(nil, webSvc.ArcAppeal(c, mid, data))
+}
+
+func authorRecommend(c *bm.Context) {
+	var (
+		aid int64
+		err error
+	)
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(webSvc.AuthorRecommend(c, aid))
+}
+
+func relatedArcs(c *bm.Context) {
+	v := new(struct {
+		Aid int64 `form:"aid" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(webSvc.RelatedArcs(c, v.Aid))
+}
+
+func detail(c *bm.Context) {
+	var (
+		mid int64
+		err error
+		rs  *model.Detail
+	)
+	v := new(struct {
+		Aid int64 `form:"aid" validate:"min=1"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if midStr, ok := c.Get("mid"); ok {
+		mid = midStr.(int64)
+	}
+	cdnIP := c.Request.Header.Get("X-Cache-Server-Addr")
+	if rs, err = webSvc.Detail(c, v.Aid, mid, cdnIP, c.Request.Header.Get("Cookie")); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(rs, nil)
+}
+
+func arcUGCPay(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(webSvc.ArcUGCPay(c, mid, v.Aid))
+}
+
+func arcRelation(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(webSvc.ArcRelation(c, mid, v.Aid))
+}

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

@@ -0,0 +1,109 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/web/conf"
+	artmdl "go-common/app/interface/openplatform/article/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+)
+
+func articleList(c *bm.Context) {
+	var (
+		rid, mid     int64
+		pn, ps, sort int
+		aids         []int64
+		err          error
+	)
+	param := c.Request.Form
+	pnStr := param.Get("pn")
+	psStr := param.Get("ps")
+	ridStr := param.Get("rid")
+	aidsStr := param.Get("aids")
+	sortStr := param.Get("sort")
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	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.MaxArtPageSize {
+		ps = conf.Conf.Rule.MaxArtPageSize
+	}
+	if ridStr != "" {
+		if rid, err = strconv.ParseInt(ridStr, 10, 64); err != nil || rid < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if aidsStr != "" {
+		if aids, err = xstr.SplitInts(aidsStr); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if sortStr != "" {
+		if sort, err = strconv.Atoi(sortStr); err != nil || sort < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		sortCheck := false
+		for _, v := range artmdl.SortFields {
+			if sort == v {
+				sortCheck = true
+				break
+			}
+		}
+		if !sortCheck && sort != 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	c.JSON(webSvc.ArticleList(c, rid, mid, sort, pn, ps, aids))
+}
+
+func articleUpList(c *bm.Context) {
+	var mid int64
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(webSvc.ArticleUpList(c, mid))
+}
+
+func categories(c *bm.Context) {
+	c.JSON(webSvc.Categories(c))
+}
+
+func newCount(c *bm.Context) {
+	var (
+		count, pubTime int64
+		err            error
+	)
+	pubTimeStr := c.Request.Form.Get("pubtime")
+	if pubTime, err = strconv.ParseInt(pubTimeStr, 10, 64); err != nil || pubTime < 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if count, err = webSvc.NewCount(c, pubTime); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(struct {
+		NewCount int64 `json:"new_count"`
+	}{NewCount: count}, nil)
+}
+
+func upMoreArts(c *bm.Context) {
+	var (
+		aid int64
+		err error
+	)
+	aidStr := c.Request.Form.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(webSvc.UpMoreArts(c, aid))
+}

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

@@ -0,0 +1,32 @@
+package http
+
+import bm "go-common/library/net/http/blademaster"
+
+func bnj2019(c *bm.Context) {
+	var mid int64
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(webSvc.Bnj2019(c, mid))
+}
+
+func bnj2019Aids(c *bm.Context) {
+	data := make(map[string]interface{}, 1)
+	data["list"] = webSvc.Bnj2019Aids(c)
+	c.JSON(data, nil)
+}
+
+func timeline(c *bm.Context) {
+	var mid int64
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	list, err := webSvc.Timeline(c, mid)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	data := make(map[string]interface{}, 1)
+	data["list"] = list
+	c.JSON(data, nil)
+}

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

@@ -0,0 +1,15 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func broadServer(c *bm.Context) {
+	v := new(struct {
+		Platform string `form:"platform" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(webSvc.BroadServers(c, v.Platform))
+}

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

@@ -0,0 +1,135 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/web/model"
+	"go-common/library/ecode"
+	"go-common/library/log/infoc"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func coins(c *bm.Context) {
+	var (
+		mid, aid int64
+		err      error
+	)
+	params := c.Request.Form
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	aidStr := params.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(webSvc.Coins(c, mid, aid))
+}
+
+func addCoin(c *bm.Context) {
+	var (
+		mid, aid, multiply int64
+		err                error
+		like               bool
+		actLike            = "cointolike"
+	)
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	multiStr := params.Get("multiply")
+	avTypeStr := params.Get("avtype")
+	business := params.Get("business")
+	upIDStr := params.Get("upid")
+	selectLikeStr := params.Get("select_like")
+	selectLike, _ := strconv.Atoi(selectLikeStr)
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	ck := c.Request.Header.Get("Cookie")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if multiply, err = strconv.ParseInt(multiStr, 10, 64); err != nil || multiply <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	upID, _ := strconv.ParseInt(upIDStr, 10, 64)
+	avtype, _ := strconv.ParseInt(avTypeStr, 10, 64)
+	if avtype == 0 {
+		avtype = model.CoinAddArcType
+	}
+	if avtype != model.CoinAddArcType && avtype != model.CoinAddArtType {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if avtype == model.CoinAddArtType && upID == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if business != "" {
+		if business == model.CoinArcBusiness {
+			avtype = model.CoinAddArcType
+		} else if business == model.CoinArtBusiness {
+			avtype = model.CoinAddArtType
+		} else {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	} else {
+		switch avtype {
+		case model.CoinAddArcType:
+			business = model.CoinArcBusiness
+		case model.CoinAddArtType:
+			business = model.CoinArtBusiness
+		default:
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	ua := c.Request.UserAgent()
+	refer := c.Request.Referer()
+	if like, err = webSvc.AddCoin(c, aid, mid, upID, multiply, avtype, business, ck, ua, refer, time.Now(), selectLike); err == nil {
+		if webSvc.CheatInfoc != nil {
+			itemType := infoc.ItemTypeAv
+			if avtype == model.CoinAddArtType {
+				itemType = "article"
+			}
+			webSvc.CheatInfoc.InfoAntiCheat2(c, strconv.FormatInt(upID, 10), strconv.FormatInt(aid, 10), strconv.FormatInt(mid, 10), strconv.FormatInt(aid, 10), itemType, "coin", "")
+			if like {
+				webSvc.CheatInfoc.InfoAntiCheat2(c, strconv.FormatInt(upID, 10), strconv.FormatInt(aid, 10), strconv.FormatInt(mid, 10), strconv.FormatInt(aid, 10), "av", actLike, "")
+			}
+		}
+	}
+	c.JSON(struct {
+		Like bool `json:"like"`
+	}{Like: like}, err)
+}
+
+func coinExp(c *bm.Context) {
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	c.JSON(webSvc.CoinExp(c, mid))
+}
+
+func coinList(c *bm.Context) {
+	var (
+		ls    []*model.CoinArc
+		count int
+		err   error
+	)
+	v := new(struct {
+		Mid int64 `form:"mid" validate:"min=1"`
+		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 ls, count, err = webSvc.CoinList(c, v.Mid, v.Pn, v.Ps); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSONMap(map[string]interface{}{
+		"count": count,
+		"data":  ls,
+	}, err)
+}

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

@@ -0,0 +1,71 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/web/conf"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func dynamicRegion(c *bm.Context) {
+	var (
+		rid, pn, ps int
+		err         error
+	)
+	params := c.Request.Form
+	ridStr := params.Get("rid")
+	pnStr := params.Get("pn")
+	psStr := params.Get("ps")
+	if rid, err = strconv.Atoi(ridStr); err != nil {
+		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.DynamicNumArcs
+	} else if ps > conf.Conf.Rule.MaxArcsPageSize {
+		ps = conf.Conf.Rule.MaxArcsPageSize
+	}
+	c.JSON(webSvc.DynamicRegion(c, int32(rid), pn, ps))
+}
+
+func dynamicRegionTag(c *bm.Context) {
+	var (
+		tagID       int64
+		rid, pn, ps int
+		err         error
+	)
+	params := c.Request.Form
+	ridStr := params.Get("rid")
+	tagIDStr := params.Get("tag_id")
+	pnStr := params.Get("pn")
+	psStr := params.Get("ps")
+	if rid, err = strconv.Atoi(ridStr); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if tagID, err = strconv.ParseInt(tagIDStr, 10, 64); err != nil {
+		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.DynamicNumArcs
+	} else if ps > conf.Conf.Rule.MaxArcsPageSize {
+		ps = conf.Conf.Rule.MaxArcsPageSize
+	}
+	c.JSON(webSvc.DynamicRegionTag(c, tagID, int32(rid), pn, ps))
+}
+
+func dynamicRegionTotal(c *bm.Context) {
+	c.JSON(webSvc.DynamicRegionTotal(c))
+}
+
+func dynamicRegions(c *bm.Context) {
+	c.JSON(webSvc.DynamicRegions(c))
+}

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

@@ -0,0 +1,32 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func elecShow(c *bm.Context) {
+	var (
+		mid, loginID, aid int64
+		err               error
+	)
+
+	params := c.Request.Form
+	midStr := params.Get("mid")
+	if mid, err = strconv.ParseInt(midStr, 10, 64); err != nil || mid <= 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
+	}
+	// login mid
+	if loginIDStr, ok := c.Get("mid"); ok {
+		loginID = loginIDStr.(int64)
+	}
+	c.JSON(webSvc.ElecShow(c, mid, aid, loginID))
+}

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

@@ -0,0 +1,64 @@
+package http
+
+import (
+	"net/http"
+	"strconv"
+
+	"go-common/app/interface/main/web/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func feedback(c *bm.Context) {
+	var (
+		mid, aid, tagID int64
+		content, buvid  string
+		buvidCk         *http.Cookie
+		midStr          interface{}
+		ok              bool
+		err             error
+	)
+	params := c.Request.Form
+	content = params.Get("content")
+	aidStr := params.Get("aid")
+	if aidStr != "" {
+		if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil {
+			log.Warn("strconv.ParseInt(%s) err(%d)", aidStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	tagIDStr := params.Get("tag_id")
+	if tagID, err = strconv.ParseInt(tagIDStr, 10, 64); err != nil || tagID < 1 {
+		log.Warn("strconv.ParseInt(%s) error(%v)", tagIDStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if !model.CheckFeedTag(tagID) {
+		log.Warn("tag_id(%d) check fail", tagID)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if buvidCk, err = c.Request.Cookie("buvid3"); err != nil {
+		log.Warn("buvid3 is nil")
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if buvid = buvidCk.Value; buvid == "" {
+		log.Warn("buvid == nil")
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midStr, ok = c.Get("mid"); ok {
+		mid = midStr.(int64)
+	}
+	browser := params.Get("browser")
+	version := params.Get("version")
+	email := params.Get("email")
+	qq := params.Get("qq")
+	other := params.Get("other")
+	feedParams := &model.Feedback{Aid: aid, Mid: mid, TagID: tagID, Buvid: buvid, Browser: browser,
+		Version: version, Content: &model.Content{Reason: content}, Email: email, QQ: qq, Other: other}
+	c.JSON(nil, webSvc.Feedback(c, feedParams))
+}

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

@@ -0,0 +1,101 @@
+package http
+
+import (
+	"go-common/app/interface/main/web/conf"
+	"go-common/app/interface/main/web/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func helpList(c *bm.Context) {
+	var (
+		rs  []*model.HelpList
+		err error
+	)
+	v := new(struct {
+		PTypeID string `form:"parentTypeId" validate:"required"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if rs, err = webSvc.HelpList(c, v.PTypeID); err != nil {
+		c.JSON(nil, ecode.Degrade)
+		return
+	}
+	c.JSON(rs, nil)
+}
+
+func helpDetail(c *bm.Context) {
+	var (
+		total  int
+		detail []*model.HelpDeatil
+		list   []*model.HelpList
+		err    error
+	)
+	v := new(struct {
+		PTypeID string `form:"questionTypeId" validate:"required"`
+		KeyFlag int    `form:"keyFlag" default:"1" validate:"min=1"`
+		FID     string `form:"fId"`
+		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 v.Ps > conf.Conf.Rule.MaxHelpPageSize {
+		v.Ps = conf.Conf.Rule.MaxHelpPageSize
+	}
+	if detail, list, total, err = webSvc.HelpDetail(c, v.FID, v.PTypeID, v.KeyFlag, v.Pn, v.Ps); err != nil {
+		c.JSON(nil, ecode.Degrade)
+		log.Error("webSvc.HelpDetail(%s,%d,%d,%d) error(%v)", v.PTypeID, v.KeyFlag, v.Pn, v.Ps, err)
+		return
+	}
+	data := make(map[string]interface{}, 2)
+	rsDetail := make(map[string]interface{}, 2)
+	page := map[string]int{
+		"num":   v.Pn,
+		"size":  v.Ps,
+		"total": total,
+	}
+	rsDetail["items"] = detail
+	rsDetail["page"] = page
+	data["detail"] = rsDetail
+	data["list"] = list
+	c.JSON(data, nil)
+}
+
+func helpSearch(c *bm.Context) {
+	var (
+		total int
+		list  []*model.HelpDeatil
+		err   error
+	)
+	v := new(struct {
+		PTypeID  string `form:"questionTypeId" default:"-1"`
+		KeyWords string `form:"keyWords" validate:"required"`
+		KeyFlag  int    `form:"keyFlag" default:"1" 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 v.Ps > conf.Conf.Rule.MaxHelpPageSize {
+		v.Ps = conf.Conf.Rule.MaxHelpPageSize
+	}
+	if list, total, err = webSvc.HelpSearch(c, v.PTypeID, v.KeyWords, v.KeyFlag, v.Pn, v.Ps); err != nil {
+		c.JSON(nil, err)
+		log.Error("webSvc.HelpDetail(%s,%d,%d,%d) error(%v)", v.KeyWords, v.KeyFlag, v.Pn, v.Ps, err)
+		return
+	}
+	data := make(map[string]interface{}, 2)
+	page := map[string]int{
+		"num":   v.Pn,
+		"size":  v.Ps,
+		"total": total,
+	}
+	data["page"] = page
+	data["list"] = list
+	c.JSON(data, nil)
+}

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

@@ -0,0 +1,210 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/interface/main/web/conf"
+	"go-common/app/interface/main/web/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/cache"
+	"go-common/library/net/http/blademaster/middleware/cache/store"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	webSvc  *service.Service
+	authSvr *auth.Auth
+	vfySvr  *verify.Verify
+
+	// cache components
+	cacheSvr *cache.Cache
+	deg      *cache.Degrader
+)
+
+// Init init
+func Init(c *conf.Config, s *service.Service) {
+	authSvr = auth.New(c.Auth)
+	vfySvr = verify.New(c.Verify)
+	webSvc = s
+	cacheSvr = cache.New(store.NewMemcache(c.DegradeConfig.Memcache))
+	deg = cache.NewDegrader(c.DegradeConfig.Expire)
+	// init outer router
+	engine := bm.NewServer(c.HTTPServer)
+	engine.Use(bm.Recovery(), bm.Logger(), bm.Trace(), bm.Mobile())
+	outerRouter(engine)
+	internalRouter(engine)
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func outerRouter(e *bm.Engine) {
+	e.Ping(ping)
+	e.GET("/x/web-interface/view", authSvr.Guest, view)
+	group := e.Group("/x/web-interface", bm.CSRF(), bm.CORS())
+	{
+		arcGroup := group.Group("/archive")
+		{
+			arcGroup.GET("/coins", authSvr.User, coins)
+			arcGroup.GET("/stat", archiveStat)
+			arcGroup.GET("/desc", description)
+			arcGroup.POST("/report", authSvr.User, arcReport)
+			arcGroup.POST("/appeal", authSvr.User, arcAppeal)
+			arcGroup.GET("/appeal/tags", appealTags)
+			arcGroup.GET("/author/recommend", authorRecommend)
+			arcGroup.GET("/related", relatedArcs)
+			arcGroup.POST("/like", authSvr.User, like)
+			arcGroup.POST("/like/triple", authSvr.User, likeTriple)
+			arcGroup.GET("/has/like", authSvr.User, hasLike)
+			arcGroup.GET("/ugc/pay", authSvr.User, arcUGCPay)
+			arcGroup.GET("/relation", authSvr.User, arcRelation)
+		}
+		dyGroup := group.Group("/dynamic")
+		{
+			dyGroup.GET("/region", dynamicRegion)
+			dyGroup.GET("/index", dynamicRegions)
+			dyGroup.GET("/tag", dynamicRegionTag)
+			dyGroup.GET("/total", dynamicRegionTotal)
+		}
+		rankGroup := group.Group("/ranking")
+		{
+			rankGroup.GET("", ranking)
+			rankGroup.GET("/index", rankingIndex)
+			rankGroup.GET("/region", rankingRegion)
+			rankGroup.GET("/recommend", rankingRecommend)
+			rankGroup.GET("/tag", rankingTag)
+		}
+		tagGroup := group.Group("/tag")
+		{
+			tagGroup.GET("/top", tagAids)
+		}
+		artGroup := group.Group("/article")
+		{
+			artGroup.GET("/list", authSvr.Guest, articleList)
+			artGroup.GET("/up/list", authSvr.Guest, articleUpList)
+			artGroup.GET("/categories", categories)
+			artGroup.GET("/newcount", newCount)
+			artGroup.GET("/early", upMoreArts)
+		}
+		coinGroup := group.Group("/coin")
+		{
+			coinGroup.POST("/add", authSvr.User, addCoin)
+			coinGroup.GET("/today/exp", authSvr.User, coinExp)
+		}
+		onlineGroup := group.Group("/online")
+		{
+			onlineGroup.GET("", onlineInfo)
+			onlineGroup.GET("/list", onlineList)
+		}
+		helpGroup := group.Group("/help")
+		{
+			helpGroup.GET("/list", cacheSvr.Cache(deg.Args("parentTypeId"), nil), helpList)
+			helpGroup.GET("/detail", cacheSvr.Cache(deg.Args("pn", "ps", "fId", "questionTypeId"), nil), helpDetail)
+			helpGroup.GET("/search", helpSearch)
+		}
+		viewGroup := group.Group("/view")
+		{
+			viewGroup.GET("/detail", authSvr.Guest, detail)
+		}
+		searchGroup := group.Group("/search")
+		{
+			searchGroup.GET("/all", authSvr.Guest, searchAll)
+			searchGroup.GET("/type", authSvr.Guest, searchByType)
+			searchGroup.GET("/recommend", authSvr.Guest, searchRec)
+			searchGroup.GET("/default", authSvr.Guest, searchDefault)
+			searchGroup.GET("/egg", searchEgg)
+		}
+		wxGroup := group.Group("/wx")
+		{
+			wxGroup.GET("/hot", wxHot)
+			wxGroup.GET("/search/all", authSvr.Guest, wxSearchAll)
+		}
+		bnjGroup := group.Group("/bnj2019")
+		{
+			bnjGroup.GET("", authSvr.Guest, bnj2019)
+			bnjGroup.GET("/timeline", authSvr.Guest, timeline)
+		}
+		group.GET("/region/custom", regionCustom)
+		group.GET("/attentions", authSvr.User, attentions)
+		group.GET("/card", authSvr.Guest, card)
+		group.GET("/nav", authSvr.Guest, nav)
+		group.GET("/newlist", newList)
+		group.POST("/feedback", authSvr.Guest, feedback)
+		group.GET("/zone", ipZone)
+		group.POST("/share/add", authSvr.Guest, addShare)
+		group.GET("/elec/show", authSvr.Guest, elecShow)
+		group.GET("/index/icon", indexIcon)
+		group.GET("/baidu/kv", kv)
+		group.GET("/cmtbox", cmtbox)
+		group.GET("/abserver", authSvr.Guest, abServer)
+		group.GET("/up/rec", authSvr.User, upRec)
+		group.GET("/broadcast/servers", broadServer)
+	}
+	e.GET("/x/coin/list", coinList)
+}
+
+func internalRouter(e *bm.Engine) {
+	group := e.Group("/x/internal/web-interface")
+	{
+		dyGroup := group.Group("/dynamic")
+		{
+			dyGroup.GET("/region", vfySvr.Verify, dynamicRegion)
+			dyGroup.GET("/index", vfySvr.Verify, dynamicRegions)
+			dyGroup.GET("/tag", vfySvr.Verify, dynamicRegionTag)
+			dyGroup.GET("/total", vfySvr.Verify, dynamicRegionTotal)
+		}
+		rankGroup := group.Group("/ranking")
+		{
+			rankGroup.GET("", vfySvr.Verify, ranking)
+			rankGroup.GET("/index", vfySvr.Verify, rankingIndex)
+			rankGroup.GET("/region", vfySvr.Verify, rankingRegion)
+			rankGroup.GET("/recommend", vfySvr.Verify, rankingRecommend)
+			rankGroup.GET("/tag", vfySvr.Verify, rankingTag)
+		}
+		tagGroup := group.Group("/tag")
+		{
+			tagGroup.GET("/top", vfySvr.Verify, tagAids)
+			tagGroup.GET("/detail", vfySvr.Verify, tagDetail)
+		}
+		helpGroup := group.Group("/help")
+		{
+			helpGroup.GET("/list", vfySvr.Verify, helpList)
+			helpGroup.GET("/detail", vfySvr.Verify, helpDetail)
+			helpGroup.GET("/search", vfySvr.Verify, helpSearch)
+		}
+		onlineGroup := group.Group("/online")
+		{
+			onlineGroup.GET("", vfySvr.Verify, onlineInfo)
+			onlineGroup.GET("/list", vfySvr.Verify, onlineList)
+		}
+		viewGroup := group.Group("/view")
+		{
+			viewGroup.GET("", vfySvr.Verify, authSvr.Guest, view)
+			viewGroup.GET("/detail", vfySvr.Verify, authSvr.Guest, detail)
+		}
+		searchGroup := group.Group("/search")
+		{
+			searchGroup.GET("/all", vfySvr.Verify, authSvr.Guest, searchAll)
+			searchGroup.GET("/type", vfySvr.Verify, authSvr.Guest, searchByType)
+			searchGroup.GET("/recommend", vfySvr.Verify, authSvr.Guest, searchRec)
+		}
+		group.GET("/newlist", vfySvr.Verify, newList)
+		group.GET("/zone", vfySvr.Verify, ipZone)
+		group.GET("/region/custom", vfySvr.Verify, regionCustom)
+		group.GET("/baidu/kv", vfySvr.Verify, kv)
+		group.GET("/cmtbox", vfySvr.Verify, cmtbox)
+		group.GET("/broadcast/servers", vfySvr.Verify, broadServer)
+		group.GET("/bnj2019", vfySvr.Verify, authSvr.Guest, bnj2019)
+		group.GET("/bnj2019/aids", vfySvr.Verify, bnj2019Aids)
+	}
+}
+
+func ping(c *bm.Context) {
+	if err := webSvc.Ping(c); err != nil {
+		log.Error("web-interface  ping error")
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

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

@@ -0,0 +1,9 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func indexIcon(c *bm.Context) {
+	c.JSON(webSvc.IndexIcon(), nil)
+}

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

@@ -0,0 +1,9 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func ipZone(c *bm.Context) {
+	c.JSON(webSvc.IPZone(c))
+}

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

@@ -0,0 +1,68 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/web/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func like(c *bm.Context) {
+	var (
+		mid int64
+		err error
+	)
+	v := new(struct {
+		Aid  int64 `form:"aid" validate:"min=1,required"`
+		Like int8  `form:"like" validate:"min=1,max=4,required"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	upperID, err := webSvc.Like(c, v.Aid, mid, v.Like)
+	c.JSON(nil, err)
+	if err == nil && webSvc.CheatInfoc != nil {
+		webSvc.CheatInfoc.InfoAntiCheat2(c, strconv.FormatInt(upperID, 10), strconv.FormatInt(v.Aid, 10), strconv.FormatInt(mid, 10), strconv.FormatInt(v.Aid, 10), "av", model.LikeType[v.Like], "")
+	}
+}
+
+func likeTriple(c *bm.Context) {
+	var (
+		mid       int64
+		actTriple = "triplelike"
+		err       error
+	)
+	v := new(struct {
+		Aid int64 `form:"aid" validate:"min=1,required"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	triple, err := webSvc.LikeTriple(c, v.Aid, mid)
+	c.JSON(triple, err)
+	if err != nil {
+		return
+	}
+	if err == nil && webSvc.CheatInfoc != nil && triple.Anticheat {
+		webSvc.CheatInfoc.InfoAntiCheat2(c, strconv.FormatInt(triple.UpID, 10), strconv.FormatInt(v.Aid, 10), strconv.FormatInt(mid, 10), strconv.FormatInt(v.Aid, 10), "av", actTriple, "")
+	}
+}
+
+func hasLike(c *bm.Context) {
+	var (
+		mid int64
+	)
+	v := new(struct {
+		Aid int64 `form:"aid" validate:"min=1,required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid = midStr.(int64)
+	c.JSON(webSvc.HasLike(c, v.Aid, mid))
+}

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

@@ -0,0 +1,22 @@
+package http
+
+import (
+	"go-common/app/interface/main/web/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func nav(c *bm.Context) {
+	var (
+		rawMid interface{}
+		ok     bool
+	)
+
+	if rawMid, ok = c.Get("mid"); !ok {
+		// NOTE NoLogin here only for web
+		c.JSON(model.FailedNavResp{}, ecode.NoLogin)
+		return
+	}
+	mid := rawMid.(int64)
+	c.JSON(webSvc.Nav(c, mid, c.Request.Header.Get("Cookie")))
+}

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

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/web/conf"
+	"go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func newList(c *bm.Context) {
+	var (
+		rid, pn, ps, tp, count int
+		rs                     []*api.Arc
+		err                    error
+	)
+	params := c.Request.Form
+	ridStr := params.Get("rid")
+	pnStr := params.Get("pn")
+	psStr := params.Get("ps")
+	tpStr := params.Get("type")
+	if ridStr != "" {
+		if rid, err = strconv.Atoi(ridStr); err != nil || rid < 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.MaxArcsPageSize {
+		ps = conf.Conf.Rule.MaxArcsPageSize
+	}
+	if tpStr != "" {
+		if tp, err = strconv.Atoi(tpStr); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if rs, count, err = webSvc.NewList(c, int32(rid), int8(tp), pn, ps); err != nil {
+		c.JSON(nil, err)
+		log.Error("webSvc.Newlist(%d,%d,%d) error(%v)", rid, pn, ps, err)
+		return
+	}
+	data := make(map[string]interface{}, 2)
+	page := map[string]int{
+		"num":   pn,
+		"size":  ps,
+		"count": count,
+	}
+	data["page"] = page
+	data["archives"] = rs
+	c.JSON(data, nil)
+}

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

@@ -0,0 +1,13 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func onlineInfo(c *bm.Context) {
+	c.JSON(webSvc.OnlineArchiveCount(c), nil)
+}
+
+func onlineList(c *bm.Context) {
+	c.JSON(webSvc.OnlineList(c))
+}

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

@@ -0,0 +1,152 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/web/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func ranking(c *bm.Context) {
+	var (
+		rid                    int64
+		rankType, day, arcType int
+		err                    error
+	)
+	params := c.Request.Form
+	ridStr := params.Get("rid")
+	rankTypeStr := params.Get("type")
+	dayStr := params.Get("day")
+	arcTypeStr := params.Get("arc_type")
+	if rid, err = strconv.ParseInt(ridStr, 10, 64); err != nil || rid < 0 {
+		rid = 0
+	}
+	if rankType, err = strconv.Atoi(rankTypeStr); err != nil {
+		rankType = 1
+	}
+	if day, err = strconv.Atoi(dayStr); err != nil {
+		day = 3
+	}
+	if arcType, err = strconv.Atoi(arcTypeStr); err != nil {
+		arcType = 0
+	}
+	if err = checkType(rid, rankType, day, arcType); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(webSvc.Ranking(c, int16(rid), rankType, model.DayType[day], model.ArcType[arcType]))
+}
+
+func checkType(rid int64, rankType, day, arcType int) (err error) {
+	if _, ok := model.RankType[rankType]; !ok {
+		err = ecode.RequestErr
+		return
+	}
+	if _, ok := model.DayType[day]; !ok {
+		err = ecode.RequestErr
+		return
+	}
+	if _, ok := model.ArcType[arcType]; !ok {
+		err = ecode.RequestErr
+	}
+	// bangumi and rookie not have recent contribution
+	if (rid == 33 || rankType == 3) && arcType == 1 {
+		err = ecode.RequestErr
+	}
+	return
+}
+
+func rankingIndex(c *bm.Context) {
+	var (
+		day int
+		err error
+	)
+	params := c.Request.Form
+	dayStr := params.Get("day")
+	if day, err = strconv.Atoi(dayStr); err != nil {
+		day = 3
+	}
+	if err = checkIndexDay(day); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(webSvc.RankingIndex(c, day))
+}
+
+func rankingRegion(c *bm.Context) {
+	var (
+		day, original int
+		rid           int64
+		err           error
+	)
+	params := c.Request.Form
+	ridStr := params.Get("rid")
+	dayStr := params.Get("day")
+	originalStr := params.Get("original")
+	if rid, err = strconv.ParseInt(ridStr, 10, 64); err != nil || rid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if day, err = strconv.Atoi(dayStr); err != nil {
+		day = 3
+	}
+	if _, ok := model.DayType[day]; !ok {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if original, err = strconv.Atoi(originalStr); err != nil {
+		original = 0
+	} else if original != 1 && original != 0 {
+		original = 0
+	}
+	c.JSON(webSvc.RankingRegion(c, int16(rid), day, original))
+}
+
+func rankingRecommend(c *bm.Context) {
+	var (
+		rid int64
+		err error
+	)
+	params := c.Request.Form
+	ridStr := params.Get("rid")
+	if rid, err = strconv.ParseInt(ridStr, 10, 64); err != nil || rid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(webSvc.RankingRecommend(c, int16(rid)))
+}
+
+func rankingTag(c *bm.Context) {
+	var (
+		rid, tagID int64
+		err        error
+	)
+	params := c.Request.Form
+	ridStr := params.Get("rid")
+	tagIDStr := params.Get("tag_id")
+	if rid, err = strconv.ParseInt(ridStr, 10, 64); err != nil || rid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if tagID, err = strconv.ParseInt(tagIDStr, 10, 64); err != nil || tagID <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(webSvc.RankingTag(c, int16(rid), tagID))
+}
+
+func regionCustom(c *bm.Context) {
+	c.JSON(webSvc.RegionCustom(c))
+}
+
+func checkIndexDay(day int) (err error) {
+	err = ecode.RequestErr
+	for _, dayItem := range model.IndexDayType {
+		if day == dayItem {
+			err = nil
+			return
+		}
+	}
+	return
+}

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

@@ -0,0 +1,51 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func kv(c *bm.Context) {
+	c.JSON(webSvc.Kv(c))
+}
+
+func cmtbox(c *bm.Context) {
+	var (
+		id  int64
+		err error
+	)
+	params := c.Request.Form
+	idStr := params.Get("id")
+	if id, err = strconv.ParseInt(idStr, 10, 64); err != nil || id <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(webSvc.CmtBox(c, id))
+}
+
+func abServer(c *bm.Context) {
+	var (
+		mid   int64
+		buvid string
+	)
+	v := new(struct {
+		Channel  string `form:"channel"`
+		Platform int    `form:"platform"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if ck, err := c.Request.Cookie("buvid3"); err == nil {
+		buvid = ck.Value
+	}
+	if buvid == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(webSvc.AbServer(c, mid, v.Platform, v.Channel, buvid))
+}

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

@@ -0,0 +1,126 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/web/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func searchAll(c *bm.Context) {
+	var (
+		mid   int64
+		buvid string
+		err   error
+	)
+	v := new(model.SearchAllArg)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if v.Pn <= 0 {
+		v.Pn = 1
+	}
+	singleColumnStr := c.Request.Form.Get("single_column")
+	if v.SingleColumn, err = strconv.Atoi(singleColumnStr); err != nil {
+		v.SingleColumn = -1
+	}
+	if ck, err := c.Request.Cookie("buvid3"); err == nil {
+		buvid = ck.Value
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(webSvc.SearchAll(c, mid, v, buvid, c.Request.Header.Get("User-Agent"), ""))
+}
+
+func searchByType(c *bm.Context) {
+	var (
+		mid   int64
+		buvid string
+		err   error
+	)
+	v := new(model.SearchTypeArg)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	singleColumnStr := c.Request.Form.Get("single_column")
+	if v.SingleColumn, err = strconv.Atoi(singleColumnStr); err != nil {
+		v.SingleColumn = -1
+	}
+	if ck, err := c.Request.Cookie("buvid3"); err == nil {
+		buvid = ck.Value
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(webSvc.SearchByType(c, mid, v, buvid, c.Request.Header.Get("User-Agent")))
+}
+
+func searchRec(c *bm.Context) {
+	var (
+		mid   int64
+		buvid string
+		err   error
+	)
+	v := new(struct {
+		Pn         int    `form:"page" default:"1" validate:"min=1"`
+		Ps         int    `form:"pagesize" default:"5" validate:"min=1"`
+		Keyword    string `form:"keyword"`
+		FromSource string `form:"from_source"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if ck, err := c.Request.Cookie("buvid3"); err == nil {
+		buvid = ck.Value
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(webSvc.SearchRec(c, mid, v.Pn, v.Ps, v.Keyword, v.FromSource, buvid, c.Request.Header.Get("User-Agent")))
+}
+
+func searchDefault(c *bm.Context) {
+	var (
+		mid   int64
+		buvid string
+		err   error
+	)
+	v := new(struct {
+		FromSource string `form:"from_source"`
+	})
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if ck, err := c.Request.Cookie("buvid3"); err == nil {
+		buvid = ck.Value
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(webSvc.SearchDefault(c, mid, v.FromSource, buvid, c.Request.Header.Get("User-Agent")))
+}
+
+func upRec(c *bm.Context) {
+	var buvid string
+	v := new(model.SearchUpRecArg)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	midStr, _ := c.Get("mid")
+	mid := midStr.(int64)
+	if ck, err := c.Request.Cookie("buvid3"); err == nil {
+		buvid = ck.Value
+	}
+	c.JSON(webSvc.UpRec(c, mid, v, buvid))
+}
+
+func searchEgg(c *bm.Context) {
+	v := new(struct {
+		EggID int64 `form:"egg_id" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(webSvc.SearchEgg(c, v.EggID))
+}

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

@@ -0,0 +1,54 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/web/conf"
+	v1 "go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// tagAids gets aids via tag
+func tagAids(c *bm.Context) {
+	var (
+		err           error
+		tid           int64
+		pn, ps, total int
+		arcs          []*v1.Arc
+		params        = c.Request.Form
+		tidStr        = params.Get("tid") // tag id
+		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.Tag.MaxSize {
+		ps = conf.Conf.Tag.MaxSize
+	}
+	if tid, err = strconv.ParseInt(tidStr, 10, 64); err != nil || tid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if total, arcs, err = webSvc.TagAids(c, tid, pn, ps); err != nil {
+		log.Error("webSvc.TagAids(%d, %d, %d) error(%v)", tid, pn, ps, err)
+		return
+	}
+	c.JSONMap(map[string]interface{}{
+		"data":  arcs,
+		"total": total,
+	}, nil)
+}
+
+func tagDetail(c *bm.Context) {
+	v := new(struct {
+		TagID int64 `form:"tag_id" validate:"min=1"`
+		Ps    int   `form:"ps" default:"20" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(webSvc.TagDetail(c, v.TagID, v.Ps))
+}

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

@@ -0,0 +1,52 @@
+package http
+
+import (
+	"go-common/app/interface/main/web/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func wxHot(c *bm.Context) {
+	v := new(struct {
+		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
+	}
+	list, count, err := webSvc.WxHot(c, 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["data"] = list
+	data["page"] = page
+	c.JSONMap(data, nil)
+}
+
+func wxSearchAll(c *bm.Context) {
+	var (
+		mid   int64
+		buvid string
+		err   error
+	)
+	v := new(model.SearchAllArg)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if v.Pn <= 0 {
+		v.Pn = 1
+	}
+	if ck, err := c.Request.Cookie("buvid3"); err == nil {
+		buvid = ck.Value
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(webSvc.SearchAll(c, mid, v, buvid, c.Request.Header.Get("User-Agent"), model.WxSearchType))
+}