Initial commit

app/interface/openplatform/article/http/BUILD

@@ -0,0 +1,69 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "anniversary.go",
+        "apply.go",
+        "archive.go",
+        "article.go",
+        "author.go",
+        "cards.go",
+        "categories.go",
+        "complaint.go",
+        "creative.go",
+        "favorite.go",
+        "hotspots.go",
+        "http.go",
+        "like.go",
+        "list.go",
+        "notice.go",
+        "rank.go",
+        "read.go",
+        "recommends.go",
+        "search.go",
+        "sentinel.go",
+        "share.go",
+        "users.go",
+        "view.go",
+    ],
+    importpath = "go-common/app/interface/openplatform/article/http",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/openplatform/article/conf:go_default_library",
+        "//app/interface/openplatform/article/dao:go_default_library",
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/interface/openplatform/article/service: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/antispam: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/net/metadata: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/interface/openplatform/article/http/anniversary.go

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

app/interface/openplatform/article/http/apply.go

@@ -0,0 +1,91 @@
+package http
+
+import (
+	"go-common/app/interface/openplatform/article/conf"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"strconv"
+)
+
+func applyInfo(c *bm.Context) {
+	var (
+		mid int64
+	)
+	// get mid
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(artSrv.ApplyInfo(c, mid))
+}
+
+func apply(c *bm.Context) {
+	var (
+		mid               int64
+		request           = c.Request
+		params            = request.Form
+		content, category string
+	)
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	content = params.Get("content")
+	if int64(len([]rune(content))) > conf.Conf.Article.MaxApplyContentLimit {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	category = params.Get("category")
+	if int64(len([]rune(category))) > conf.Conf.Article.MaxApplyCategoryLimit {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, artSrv.Apply(c, mid, content, category))
+}
+
+func isAuthor(c *bm.Context) {
+	var (
+		mid, mediaID   int64
+		err            error
+		author, forbid bool
+		id             int64
+		level          = true
+		canEdit        = true
+	)
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	mediaIDStr := c.Request.Form.Get("media_id")
+	if mediaIDStr != "" {
+		mediaID, err = strconv.ParseInt(mediaIDStr, 10, 64)
+		if err != nil || mediaID < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if mediaID > 0 {
+		if level, err = artSrv.LevelRequired(c, mid); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if id, err = artSrv.MediaArticle(c, mediaID, mid); err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if id > 0 && artSrv.EditTimes(c, id) <= 0 {
+			canEdit = false
+		}
+	}
+	if author, forbid, err = artSrv.IsAuthor(c, mid); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]interface{}{"is_author": author, "forbid": forbid, "level": level, "id": id, "can_edit": canEdit}, nil)
+}
+
+func addAuthor(c *bm.Context) {
+	var (
+		mid int64
+	)
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	c.JSON(nil, artSrv.AddAuthor(c, mid))
+}

app/interface/openplatform/article/http/archive.go

@@ -0,0 +1,34 @@
+package http
+
+import (
+	"go-common/app/interface/openplatform/article/conf"
+	"go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+)
+
+func archives(c *bm.Context) {
+	var (
+		err    error
+		aids   []int64
+		arcs   map[int64]*api.Arc
+		params = c.Request.Form
+		ip     = metadata.String(c, metadata.RemoteIP)
+	)
+	idsStr := params.Get("ids")
+	if aids, err = xstr.SplitInts(idsStr); err != nil || len(aids) < 1 || len(aids) > conf.Conf.Article.MaxArchives {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if arcs, err = artSrv.Archives(c, aids, ip); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if len(arcs) == 0 {
+		c.JSON(nil, ecode.NothingFound)
+		return
+	}
+	c.JSON(arcs, err)
+}

app/interface/openplatform/article/http/article.go

@@ -0,0 +1,106 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/openplatform/article/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 meta(c *bm.Context) {
+	var (
+		err    error
+		aid    int64
+		am     *artmdl.Meta
+		params = c.Request.Form
+	)
+	idStr := params.Get("id")
+	if aid, err = strconv.ParseInt(idStr, 10, 64); err != nil || aid < 1 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if am, err = artSrv.ArticleMeta(c, aid); err != nil {
+		c.JSON(nil, err)
+		return
+	} else if am == nil {
+		c.JSON(nil, ecode.NothingFound)
+		return
+	}
+	c.JSON(am, nil)
+}
+
+func metas(c *bm.Context) {
+	var (
+		err    error
+		aids   []int64
+		ams    map[int64]*artmdl.Meta
+		params = c.Request.Form
+		mid    int64
+		resIDs []int64
+	)
+	idsStr := params.Get("ids")
+	midStr := params.Get("mid")
+	mid, _ = strconv.ParseInt(midStr, 10, 64)
+	if aids, err = xstr.SplitInts(idsStr); err != nil || len(aids) < 1 || len(aids) > conf.Conf.Article.MaxArticleMetas {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if ams, err = artSrv.ArticleMetas(c, aids); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if len(ams) == 0 {
+		c.JSON(nil, ecode.NothingFound)
+		return
+	}
+	if mid > 0 {
+		for _, artm := range ams {
+			resIDs = append(resIDs, artm.ID)
+		}
+		likeRes, _ := artSrv.HadLikesByMid(c, mid, resIDs)
+		for _, art := range ams {
+			isLike := likeRes[art.ID]
+			if isLike > 0 {
+				art.IsLike = true
+			}
+		}
+	}
+	c.JSON(ams, nil)
+}
+
+func addCheatFilter(c *bm.Context) {
+	var (
+		err    error
+		aid    int64
+		lv     int
+		params = c.Request.Form
+	)
+	idStr := params.Get("id")
+	if aid, err = strconv.ParseInt(idStr, 10, 64); err != nil || aid < 1 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	lv, err = strconv.Atoi(params.Get("lv"))
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, artSrv.AddCheatFilter(c, aid, lv))
+}
+
+func delCheatFilter(c *bm.Context) {
+	var (
+		err    error
+		aid    int64
+		params = c.Request.Form
+	)
+	idStr := params.Get("id")
+	if aid, err = strconv.ParseInt(idStr, 10, 64); err != nil || aid < 1 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, artSrv.DelCheatFilter(c, aid))
+}

app/interface/openplatform/article/http/author.go

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"strconv"
+
+	bm "go-common/library/net/http/blademaster"
+)
+
+func authors(c *bm.Context) {
+	var (
+		mid    int64
+		author int64
+		params = c.Request.Form
+	)
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	author, _ = strconv.ParseInt(params.Get("author"), 10, 64)
+	authors := artSrv.Authors(c, mid, author)
+	c.JSONMap(map[string]interface{}{"authors": authors}, nil)
+}
+
+// func authors(c *bm.Context) {
+// 	var (
+// 		mid      int64
+// 		userID   int64
+// 		request  = c.Request
+// 		params   = request.Form
+// 		clientIP = metadata.String(c, metadata.RemoteIP)
+// 		err      error
+// 		authors  *artmdl.RecommendAuthors
+// 	)
+// 	author := params.Get("author")
+// 	if author == "" {
+// 		err = ecode.RequestErr
+// 		c.JSON(nil, err)
+// 		return
+// 	}
+// 	if mid, err = strconv.ParseInt(author, 10, 64); err != nil {
+// 		c.JSON(nil, err)
+// 		return
+// 	}
+// 	mobiApp := params.Get("mobi_app")
+// 	device := params.Get("device")
+// 	plat := artmdl.Plat(mobiApp, device)
+// 	platform := artmdl.Client(plat)
+// 	buildStr := params.Get("build")
+// 	build, _ := strconv.Atoi(buildStr)
+// 	buvid := buvid(c)
+// 	if midInter, ok := c.Get("mid"); ok {
+// 		userID = midInter.(int64)
+// 	}
+
+// 	authors, err = artSrv.RecommendAuthors(c, platform, mobiApp, device, build, clientIP, userID, buvid, mid)
+// 	c.JSON(authors, err)
+// }

app/interface/openplatform/article/http/cards.go

@@ -0,0 +1,23 @@
+package http
+
+import (
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"strings"
+)
+
+func card(c *bm.Context) {
+	c.JSON(artSrv.FindCard(c, c.Request.Form.Get("id")))
+}
+
+func cards(c *bm.Context) {
+	var (
+		params = c.Request.Form
+	)
+	ids := strings.Split(params.Get("ids"), ",")
+	if len(ids) > 100 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(artSrv.FindCards(c, ids))
+}

app/interface/openplatform/article/http/categories.go

@@ -0,0 +1,19 @@
+package http
+
+import (
+	artmdl "go-common/app/interface/openplatform/article/model"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+func categories(c *bm.Context) {
+	data, err := artSrv.ListCategories(c, metadata.String(c, metadata.RemoteIP))
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if data == nil {
+		data = artmdl.Categories{}
+	}
+	c.JSON(data, nil)
+}

app/interface/openplatform/article/http/complaint.go

@@ -0,0 +1,45 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/openplatform/article/conf"
+	"go-common/app/interface/openplatform/article/dao"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+func addComplaint(c *bm.Context) {
+	var (
+		err               error
+		mid, aid, cid     int64
+		params            = c.Request.Form
+		ip                = metadata.String(c, metadata.RemoteIP)
+		reason, imageUrls string
+	)
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	aidStr := params.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	cidStr := params.Get("cid")
+	if cid, err = strconv.ParseInt(cidStr, 10, 64); err != nil || cid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	reason = params.Get("reason")
+	if int64(len([]rune(reason))) > conf.Conf.Article.MaxComplaintReasonLimit {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	imageUrls = params.Get("images")
+	if err = artSrv.AddComplaint(c, aid, mid, cid, reason, imageUrls, ip); err != nil {
+		dao.PromError("新增投诉")
+		log.Error("artSrv.AddComplaint(%d,%d,%d, %s, %s) error(%+v)", mid, aid, cid, reason, imageUrls, err)
+	}
+	c.JSON(nil, err)
+}

app/interface/openplatform/article/http/creative.go

@@ -0,0 +1,762 @@
+package http
+
+import (
+	"encoding/base64"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"go-common/app/interface/openplatform/article/conf"
+	"go-common/app/interface/openplatform/article/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+func lists(c *bm.Context) {
+	var (
+		mid   int64
+		err   error
+		novel bool
+		list  []*model.CreativeList
+	)
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	if novel, list, err = artSrv.CreativeUpLists(c, mid); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]interface{}{
+		"novel": novel,
+		"lists": list,
+		"total": len(list),
+		"limit": conf.Conf.Article.ListLimit,
+	}, nil)
+}
+
+func addList(c *bm.Context) {
+	var (
+		mid int64
+		err error
+	)
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	req := new(struct {
+		Name     string `form:"name" validate:"required"`
+		Summary  string `form:"summary" validate:"min=0,max=233"`
+		ImageURL string `form:"image_url"`
+	})
+	if err = c.Bind(req); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if req.ImageURL != "" && !model.CheckBFSImage(req.ImageURL) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(artSrv.CreativeAddList(c, mid, req.Name, req.Summary, req.ImageURL))
+}
+
+func delList(c *bm.Context) {
+	var (
+		mid, id int64
+	)
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	id, _ = strconv.ParseInt(c.Request.Form.Get("id"), 10, 64)
+	if id <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, artSrv.CreativeDelList(c, mid, id))
+}
+
+func updateArticleList(c *bm.Context) {
+	var (
+		mid int64
+	)
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	listID, _ := strconv.ParseInt(c.Request.Form.Get("list_id"), 10, 64)
+	if listID < 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	articleID, _ := strconv.ParseInt(c.Request.Form.Get("article_id"), 10, 64)
+	if articleID <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, artSrv.CreativeUpdateArticleList(c, mid, articleID, listID, true))
+}
+
+func listAllArticles(c *bm.Context) {
+	var (
+		mid, id int64
+		err     error
+		list    *model.List
+		arts    []*model.ListArtMeta
+	)
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	id, _ = strconv.ParseInt(c.Request.Form.Get("id"), 10, 64)
+	if id <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if list, arts, err = artSrv.CreativeListAllArticles(c, mid, id); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]interface{}{
+		"list":     list,
+		"articles": arts,
+		"total":    len(arts),
+		"limit":    conf.Conf.Article.ListArtsLimit,
+	}, nil)
+}
+
+func updateListArticles(c *bm.Context) {
+	var (
+		mid  int64
+		list *model.List
+		err  error
+	)
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	req := new(struct {
+		ListID   int64   `form:"list_id" validate:"min=0"`
+		Name     string  `form:"name" validate:"required"`
+		Summary  string  `form:"summary" validate:"min=0,max=233"`
+		ImageURL string  `form:"image_url"`
+		OnlyList bool    `form:"only_list"`
+		IDs      []int64 `form:"ids,split"`
+	})
+	if err = c.Bind(req); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if req.ImageURL != "" && !model.CheckBFSImage(req.ImageURL) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if list, err = artSrv.CreativeUpdateListArticles(c, req.ListID, req.Name, req.ImageURL, req.Summary, req.OnlyList, mid, req.IDs); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]interface{}{"list": list}, nil)
+}
+
+func canAddArts(c *bm.Context) {
+	var (
+		mid  int64
+		err  error
+		arts []*model.ListArtMeta
+	)
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	if arts, err = artSrv.CreativeCanAddArticles(c, mid); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]interface{}{"articles": arts}, nil)
+}
+
+func webSubArticle(c *bm.Context) {
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	title := params.Get("title")
+	content := params.Get("content")
+	summary := params.Get("summary")
+	bannerURL := params.Get("banner_url")
+	tidStr := params.Get("tid")
+	categoryStr := params.Get("category")
+	reprintStr := params.Get("reprint")
+	tags := params.Get("tags")
+	imageURLs := params.Get("image_urls")
+	wordsStr := params.Get("words")
+	actIDStr := params.Get("act_id")
+	scoreStr := params.Get("score")
+	mediaIDStr := params.Get("media_id")
+	spoilerStr := params.Get("spoiler")
+	dynamicIntrosStr := params.Get("dynamic_intro")
+	originImageURLs := params.Get("origin_image_urls")
+	ip := metadata.String(c, metadata.RemoteIP)
+	ck := c.Request.Header.Get("cookie")
+	// check params
+	midI, _ := c.Get("mid")
+	mid, _ := midI.(int64)
+	var (
+		spoiler          int64
+		aid              int64
+		actID            int64
+		mediaID          int64
+		score            int64
+		err1, err2, err3 error
+	)
+	if aidStr != "" {
+		id, err := strconv.ParseInt(aidStr, 10, 64)
+		if err != nil || id <= 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		aid = id
+	}
+	if actIDStr != "" {
+		actid, err := strconv.ParseInt(actIDStr, 10, 64)
+		if err != nil || actid <= 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		actID = actid
+	}
+	listIDStr := params.Get("list_id")
+	var listID int64
+	if listIDStr != "" {
+		lid, err := strconv.ParseInt(listIDStr, 10, 64)
+		if err != nil || lid < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		listID = lid
+	}
+	if mediaIDStr != "" {
+		mediaID, err1 = strconv.ParseInt(mediaIDStr, 10, 64)
+		if err1 != nil || mediaID < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if mediaID > 0 {
+		score, err2 = strconv.ParseInt(scoreStr, 10, 64)
+		spoiler, err3 = strconv.ParseInt(spoilerStr, 10, 32)
+		if err2 != nil || err3 != nil || spoiler < 0 || (score < 1 || score > 10 || score%2 != 0) {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if ok, err := artSrv.LevelRequired(c, mid); err != nil || !ok {
+			c.JSON(nil, ecode.ArtLevelFailedErr)
+			return
+		}
+		if id, err := artSrv.MediaArticle(c, mediaID, mid); err != nil || id > 0 {
+			c.JSON(nil, ecode.ArtMediaExistedErr)
+			return
+		}
+	}
+	words, _ := strconv.ParseInt(wordsStr, 10, 64)
+	artParam, err := artSrv.ParseParam(c, categoryStr, reprintStr, tidStr, imageURLs, originImageURLs)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	// params
+	art := &model.ArtParam{
+		AID:             aid,
+		MID:             mid,
+		Title:           title,
+		Content:         content,
+		Summary:         summary,
+		BannerURL:       bannerURL,
+		Tags:            tags,
+		ImageURLs:       artParam.ImageURLs,
+		OriginImageURLs: artParam.OriginImageURLs,
+		RealIP:          ip,
+		Category:        artParam.Category,
+		TemplateID:      artParam.TemplateID,
+		Reprint:         artParam.Reprint,
+		Words:           words,
+		DynamicIntro:    dynamicIntrosStr,
+		ActivityID:      actID,
+		ListID:          listID,
+		MediaID:         mediaID,
+		Spoiler:         int32(spoiler),
+	}
+	// submit
+	id, err := artSrv.CreativeSubArticle(c, mid, art, "", ck, metadata.String(c, metadata.RemoteIP))
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	// 番剧评分
+	if mediaID > 0 {
+		artSrv.SetMediaScore(c, score, id, mediaID, mid)
+	}
+	c.JSON(map[string]int64{"aid": id}, nil)
+}
+
+func webUpdateArticle(c *bm.Context) {
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	title := params.Get("title")
+	content := params.Get("content")
+	summary := params.Get("summary")
+	bannerURL := params.Get("banner_url")
+	tidStr := params.Get("tid")
+	categoryStr := params.Get("category")
+	reprintStr := params.Get("reprint")
+	tags := params.Get("tags")
+	imageURLs := params.Get("image_urls")
+	wordsStr := params.Get("words")
+	spoilerStr := params.Get("spoiler")
+	dynamicIntrosStr := params.Get("dynamic_intro")
+	originImageURLs := params.Get("origin_image_urls")
+	scoreStr := params.Get("score")
+	mediaIDStr := params.Get("media_id")
+	ip := metadata.String(c, metadata.RemoteIP)
+	ck := c.Request.Header.Get("cookie")
+	// check params
+	midI, _ := c.Get("mid")
+	mid, _ := midI.(int64)
+	aid, err := strconv.ParseInt(aidStr, 10, 64)
+	if err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	words, _ := strconv.ParseInt(wordsStr, 10, 64)
+	artParam, err := artSrv.ParseParam(c, categoryStr, reprintStr, tidStr, imageURLs, originImageURLs)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	listIDStr := params.Get("list_id")
+	var listID int64
+	if listIDStr != "" {
+		lid, err := strconv.ParseInt(listIDStr, 10, 64)
+		if err != nil || lid < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		listID = lid
+	}
+	var (
+		spoiler          int64
+		mediaID          int64
+		score            int64
+		err1, err2, err3 error
+	)
+	if mediaIDStr != "" {
+		mediaID, err1 = strconv.ParseInt(mediaIDStr, 10, 64)
+		if err1 != nil || mediaID < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if mediaID > 0 {
+		score, err2 = strconv.ParseInt(scoreStr, 10, 64)
+		spoiler, err3 = strconv.ParseInt(spoilerStr, 10, 32)
+		if err2 != nil || err3 != nil || spoiler < 0 || (score < 1 || score > 10 || score%2 != 0) {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		if mediaid, err := artSrv.MediaIDByID(c, aid); err != nil || mediaid != mediaID {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	// params
+	art := &model.ArtParam{
+		AID:             aid,
+		MID:             mid,
+		Title:           title,
+		Content:         content,
+		Summary:         summary,
+		BannerURL:       bannerURL,
+		Tags:            tags,
+		ImageURLs:       artParam.ImageURLs,
+		OriginImageURLs: artParam.OriginImageURLs,
+		RealIP:          ip,
+		Category:        artParam.Category,
+		TemplateID:      artParam.TemplateID,
+		Reprint:         artParam.Reprint,
+		Words:           words,
+		DynamicIntro:    dynamicIntrosStr,
+		ListID:          listID,
+		Spoiler:         int32(spoiler),
+		MediaID:         mediaID,
+	}
+	if err = artSrv.CreativeUpdateArticle(c, mid, art, "", ck, ip); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	// 番剧评分
+	if mediaID > 0 {
+		artSrv.SetMediaScore(c, score, aid, mediaID, mid)
+	}
+	c.JSON(nil, nil)
+}
+
+func webSubmitDraft(c *bm.Context) {
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	title := params.Get("title")
+	content := params.Get("content")
+	summary := params.Get("summary")
+	bannerURL := params.Get("banner_url")
+	tidStr := params.Get("tid")
+	categoryStr := params.Get("category")
+	reprintStr := params.Get("reprint")
+	tags := params.Get("tags")
+	imageURLs := params.Get("image_urls")
+	wordsStr := params.Get("words")
+	mediaIDStr := params.Get("media_id")
+	spoilerStr := params.Get("spoiler")
+	dynamicIntrosStr := params.Get("dynamic_intro")
+	originImageURLs := params.Get("origin_image_urls")
+	ip := metadata.String(c, metadata.RemoteIP)
+	// check params
+	midI, _ := c.Get("mid")
+	mid, _ := midI.(int64)
+	var (
+		did        int64
+		mediaID    int64
+		spoiler    int64
+		err1, err2 error
+	)
+	if aidStr != "" {
+		var err error
+		did, err = strconv.ParseInt(aidStr, 10, 64)
+		if err != nil || did <= 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	words, _ := strconv.ParseInt(wordsStr, 10, 64)
+	artParam, err := artSrv.ParseDraftParam(c, categoryStr, reprintStr, tidStr, imageURLs, originImageURLs)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	listIDStr := params.Get("list_id")
+	var listID int64
+	if listIDStr != "" {
+		var lid int64
+		lid, err = strconv.ParseInt(listIDStr, 10, 64)
+		if err != nil || lid < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		listID = lid
+	}
+	if mediaIDStr != "" {
+		mediaID, err1 = strconv.ParseInt(mediaIDStr, 10, 64)
+		spoiler, err2 = strconv.ParseInt(spoilerStr, 10, 32)
+		if err1 != nil || err2 != nil || mediaID < 0 || spoiler < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	// params
+	art := &model.ArtParam{
+		AID:             did,
+		MID:             mid,
+		Title:           title,
+		Content:         content,
+		Summary:         summary,
+		BannerURL:       bannerURL,
+		Tags:            tags,
+		ImageURLs:       artParam.ImageURLs,
+		OriginImageURLs: artParam.OriginImageURLs,
+		RealIP:          ip,
+		Category:        artParam.Category,
+		TemplateID:      artParam.TemplateID,
+		Reprint:         artParam.Reprint,
+		Words:           words,
+		DynamicIntro:    dynamicIntrosStr,
+		ListID:          listID,
+		MediaID:         mediaID,
+		Spoiler:         int32(spoiler),
+	}
+	// add draft
+	id, err := artSrv.CreativeAddDraft(c, mid, art)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]int64{"aid": id}, nil)
+}
+
+func webArticleList(c *bm.Context) {
+	params := c.Request.Form
+	pnStr := params.Get("pn")
+	psStr := params.Get("ps")
+	sortStr := params.Get("sort")
+	groupStr := params.Get("group")
+	categoryStr := params.Get("category")
+	ip := metadata.String(c, metadata.RemoteIP)
+	// check
+	midI, _ := c.Get("mid")
+	mid, _ := midI.(int64)
+	pn, err := strconv.Atoi(pnStr)
+	if err != nil || pn < 1 {
+		pn = 1
+	}
+	ps, err := strconv.Atoi(psStr)
+	if err != nil || ps <= 10 {
+		ps = 20
+	}
+	sort, err := strconv.Atoi(sortStr)
+	if err != nil || sort < 0 {
+		sort = 0
+	}
+	group, err := strconv.Atoi(groupStr)
+	if err != nil || group < 0 {
+		group = 0
+	}
+	category, err := strconv.Atoi(categoryStr)
+	if err != nil || category < 0 {
+		category = 0
+	}
+	arts, err := artSrv.CreativeArticles(c, mid, int(pn), int(ps), sort, group, category, ip)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSONMap(map[string]interface{}{"artlist": arts}, nil)
+}
+
+func webDraftList(c *bm.Context) {
+	params := c.Request.Form
+	pnStr := params.Get("pn")
+	psStr := params.Get("ps")
+	ip := metadata.String(c, metadata.RemoteIP)
+	// check
+	midI, _ := c.Get("mid")
+	mid, _ := midI.(int64)
+	pn, err := strconv.Atoi(pnStr)
+	if err != nil || pn < 1 {
+		pn = 1
+	}
+	ps, err := strconv.Atoi(psStr)
+	if err != nil || ps <= 10 {
+		ps = 20
+	}
+	arts, err := artSrv.CreativeDrafts(c, mid, pn, ps, ip)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSONMap(map[string]interface{}{"artlist": arts}, nil)
+}
+
+func webDraft(c *bm.Context) {
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	ip := metadata.String(c, metadata.RemoteIP)
+	// check params
+	midI, _ := c.Get("mid")
+	mid, _ := midI.(int64)
+	aid, err := strconv.ParseInt(aidStr, 10, 64)
+	if err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(artSrv.CreativeDraft(c, aid, mid, ip))
+}
+
+func webArticle(c *bm.Context) {
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	ip := metadata.String(c, metadata.RemoteIP)
+	// check params
+	midI, _ := c.Get("mid")
+	mid, _ := midI.(int64)
+	aid, err := strconv.ParseInt(aidStr, 10, 64)
+	if err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(artSrv.CreativeView(c, aid, mid, ip))
+}
+
+func creatorArticlePre(c *bm.Context) {
+	var (
+		isAuthor int
+		url      string
+		mid      int64
+	)
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	ia, _, err := artSrv.IsAuthor(c, mid)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if ia {
+		isAuthor = 1
+		url = "https://member.bilibili.com/article-text/mobile"
+	} else {
+		isAuthor = 0
+		url = "https://www.bilibili.com/read/apply/"
+	}
+	c.JSON(map[string]interface{}{
+		"is_author":  isAuthor,
+		"reason":     "", // 保持接口不变
+		"submit_url": url,
+	}, nil)
+}
+
+func uploadImage(c *bm.Context) {
+	var (
+		bs  []byte
+		mid int64
+	)
+	midI, _ := c.Get("mid")
+	mid = midI.(int64)
+	log.Infov(c, log.KV("log", "creative: upload image"), log.KV("mid", mid))
+	dataURI := c.Request.FormValue("file")
+	if dataURI != "" {
+		dataURI = strings.Split(dataURI, ",")[1]
+		bs, _ = base64.StdEncoding.DecodeString(dataURI)
+	} else {
+		file, _, err := c.Request.FormFile("file")
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		defer file.Close()
+		bs, err = ioutil.ReadAll(file)
+		if err != nil {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	ftype := http.DetectContentType(bs)
+	if ftype != "image/jpeg" && ftype != "image/jpg" && ftype != "image/png" && ftype != "image/gif" {
+		log.Error("creative: file type not allow file type(%s, mid: %v)", ftype, mid)
+		c.JSON(nil, ecode.CreativeArticleImageTypeErr)
+		return
+	}
+	url, err := artSrv.ArticleUpCover(c, ftype, bs)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]interface{}{
+		"url":  url,
+		"size": len(bs),
+	}, nil)
+}
+
+func deleteDraft(c *bm.Context) {
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	// check params
+	midI, ok := c.Get("mid")
+	if !ok {
+		c.JSON(nil, ecode.NoLogin)
+		return
+	}
+	mid, ok := midI.(int64)
+	if !ok || mid <= 0 {
+		c.JSON(nil, ecode.NoLogin)
+		return
+	}
+	aid, err := strconv.ParseInt(aidStr, 10, 64)
+	if err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, artSrv.DelArtDraft(c, aid, mid))
+}
+
+func delArticle(c *bm.Context) {
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	// check params
+	midI, ok := c.Get("mid")
+	if !ok {
+		c.JSON(nil, ecode.NoLogin)
+		return
+	}
+	mid, ok := midI.(int64)
+	if !ok || mid <= 0 {
+		c.JSON(nil, ecode.NoLogin)
+		return
+	}
+	aid, err := strconv.ParseInt(aidStr, 10, 64)
+	if err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, artSrv.DelArticle(c, aid, mid))
+}
+
+func withdrawArticle(c *bm.Context) {
+	params := c.Request.Form
+	aidStr := params.Get("aid")
+	// check params
+	midI, ok := c.Get("mid")
+	if !ok {
+		c.JSON(nil, ecode.NoLogin)
+		return
+	}
+	mid, ok := midI.(int64)
+	if !ok || mid <= 0 {
+		c.JSON(nil, ecode.NoLogin)
+		return
+	}
+	aid, err := strconv.ParseInt(aidStr, 10, 64)
+	if err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, artSrv.CreationWithdrawArticle(c, mid, aid))
+}
+
+func draftCount(c *bm.Context) {
+	midI, _ := c.Get("mid")
+	mid, _ := midI.(int64)
+	count := artSrv.CreativeDraftCount(c, mid)
+	c.JSONMap(map[string]interface{}{"count": count}, nil)
+}
+
+func articleCapture(c *bm.Context) {
+	params := c.Request.Form
+	originURL := params.Get("url")
+	// check params
+	midI, ok := c.Get("mid")
+	if !ok {
+		c.JSON(nil, ecode.NoLogin)
+		return
+	}
+	mid, ok := midI.(int64)
+	if !ok || mid <= 0 {
+		c.JSON(nil, ecode.NoLogin)
+		return
+	}
+	if originURL == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	log.Info("capture mid(%d) origin imageURL (%s)", mid, originURL)
+	_, err := url.ParseRequestURI(originURL)
+	if err != nil {
+		log.Error("capture check url(%s) format error(%v)", originURL, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	imgURL, size, err := artSrv.ArticleCapture(c, originURL)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]interface{}{
+		"url":  imgURL,
+		"size": size,
+	}, nil)
+}

app/interface/openplatform/article/http/favorite.go

@@ -0,0 +1,163 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/openplatform/article/conf"
+	"go-common/app/interface/openplatform/article/dao"
+	artmdl "go-common/app/interface/openplatform/article/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/log/infoc"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+func addFavorite(c *bm.Context) {
+	var (
+		err           error
+		mid, aid, fid int64
+		params        = c.Request.Form
+		ip            = metadata.String(c, metadata.RemoteIP)
+	)
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	aidStr := params.Get("id")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	fidStr := params.Get("fid")
+	if fidStr != "" {
+		if fid, err = strconv.ParseInt(fidStr, 10, 64); err != nil || fid < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	meta, err := artSrv.ArticleMeta(c, aid)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if meta == nil {
+		c.JSON(nil, ecode.NothingFound)
+		return
+	}
+	err = artSrv.AddFavorite(c, mid, aid, fid, ip)
+	artSrv.CheatInfoc.InfoAntiCheat2(c, strconv.FormatInt(meta.Author.Mid, 10), "", strconv.FormatInt(mid, 10), aidStr, "article", infoc.ActionFav, fidStr)
+	c.JSON(nil, err)
+}
+
+func delFavorite(c *bm.Context) {
+	var (
+		err           error
+		mid, aid, fid int64
+		params        = c.Request.Form
+		ip            = metadata.String(c, metadata.RemoteIP)
+	)
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	aidStr := params.Get("id")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil || aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	fidStr := params.Get("fid")
+	if fidStr != "" {
+		if fid, err = strconv.ParseInt(fidStr, 10, 64); err != nil || fid < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	if err = artSrv.DelFavorite(c, mid, aid, fid, ip); err != nil {
+		dao.PromError("删除收藏")
+		log.Error("artSrv.DelFavorite(%d,%d,%d) error(%+v)", mid, aid, fid, err)
+	}
+	c.JSON(nil, err)
+}
+
+func favorites(c *bm.Context) {
+	var (
+		err      error
+		mid, fid int64
+		pn, ps   int
+		favs     []*artmdl.Favorite
+		page     *artmdl.Page
+		params   = c.Request.Form
+		ip       = metadata.String(c, metadata.RemoteIP)
+	)
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	fidStr := params.Get("fid")
+	if fidStr != "" {
+		if fid, err = strconv.ParseInt(fidStr, 10, 64); err != nil || fid < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	pnStr := params.Get("pn")
+	if pn, err = strconv.Atoi(pnStr); err != nil || pn < 1 {
+		pn = 1
+	}
+	psStr := params.Get("ps")
+	if ps, err = strconv.Atoi(psStr); err != nil || ps < 1 {
+		ps = conf.Conf.Article.CreationDefaultSize
+	} else if ps > conf.Conf.Article.CreationMaxSize {
+		ps = conf.Conf.Article.CreationMaxSize
+	}
+	if favs, page, err = artSrv.ValidFavs(c, mid, fid, pn, ps, ip); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	type data struct {
+		Favorites []*artmdl.Favorite `json:"favorites"`
+		Page      *artmdl.Page       `json:"page"`
+	}
+	c.JSON(&data{
+		Favorites: favs,
+		Page:      page,
+	}, nil)
+}
+
+func allFavorites(c *bm.Context) {
+	var (
+		err      error
+		mid, fid int64
+		pn, ps   int
+		favs     []*artmdl.Favorite
+		page     *artmdl.Page
+		params   = c.Request.Form
+		ip       = metadata.String(c, metadata.RemoteIP)
+	)
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	fidStr := params.Get("fid")
+	if fidStr != "" {
+		if fid, err = strconv.ParseInt(fidStr, 10, 64); err != nil || fid < 0 {
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+	}
+	pnStr := params.Get("pn")
+	if pn, err = strconv.Atoi(pnStr); err != nil || pn < 1 {
+		pn = 1
+	}
+	psStr := params.Get("ps")
+	if ps, err = strconv.Atoi(psStr); err != nil || ps < 1 {
+		ps = conf.Conf.Article.CreationDefaultSize
+	} else if ps > conf.Conf.Article.CreationMaxSize {
+		ps = conf.Conf.Article.CreationMaxSize
+	}
+	if favs, page, err = artSrv.Favs(c, mid, fid, pn, ps, ip); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	type data struct {
+		Favorites []*artmdl.Favorite `json:"favorites"`
+		Page      *artmdl.Page       `json:"page"`
+	}
+	c.JSON(&data{
+		Favorites: favs,
+		Page:      page,
+	}, nil)
+}

app/interface/openplatform/article/http/hotspots.go

@@ -0,0 +1,63 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/openplatform/article/conf"
+	"go-common/app/interface/openplatform/article/dao"
+	"go-common/app/interface/openplatform/article/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func hotspotArts(c *bm.Context) {
+	var (
+		mid    int64
+		rs     []*model.MetaWithLike
+		hot    *model.Hotspot
+		err    error
+		params = c.Request.Form
+		aids   []int64
+	)
+	cid, _ := strconv.ParseInt(params.Get("id"), 10, 64)
+	sort, _ := strconv.Atoi(params.Get("sort"))
+	pn, _ := strconv.ParseInt(params.Get("pn"), 10, 64)
+	ps, _ := strconv.ParseInt(params.Get("ps"), 10, 64)
+	if cid == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if pn <= 0 {
+		pn = 1
+	}
+	if pn > conf.Conf.Article.MaxRecommendPnSize {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if ps <= 0 {
+		ps = 20
+	} else if ps > conf.Conf.Article.MaxRecommendPsSize {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	if hot, rs, err = artSrv.HotspotArts(c, cid, int(pn), int(ps), aids, int8(sort), mid); err != nil {
+		c.JSON(nil, err)
+		dao.PromError("热点运营接口")
+		log.Error("service.HotspotArts(%d) error(%+v)", mid, err)
+		return
+	}
+	res := make(map[string]interface{})
+	res["aids_len"] = conf.Conf.Article.RecommendAidLen
+	if rs == nil {
+		rs = []*model.MetaWithLike{}
+	}
+	res["data"] = &model.HotspotResp{
+		Hotspot:  hot,
+		Articles: rs,
+	}
+	c.JSONMap(res, nil)
+}

app/interface/openplatform/article/http/http.go

@@ -0,0 +1,166 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/interface/openplatform/article/conf"
+	"go-common/app/interface/openplatform/article/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/antispam"
+	"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 (
+	artSrv    *service.Service
+	authSvr   *auth.Auth
+	vfySvr    *verify.Verify
+	antispamM *antispam.Antispam
+	// 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)
+	artSrv = s
+	antispamM = antispam.New(c.Antispam)
+	cacheSvr = cache.New(store.NewMemcache(c.DegradeConfig.Memcache))
+	deg = cache.NewDegrader(c.DegradeConfig.Expire)
+	// init outer router
+	engine := bm.DefaultServer(c.BM)
+	outerRouter(engine)
+	if err := engine.Start(); err != nil {
+		log.Error("engine.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+// outerRouter init outer router
+func outerRouter(r *bm.Engine) {
+	r.Ping(ping)
+	r.Register(register)
+	cr := r.Group("/x/article")
+	{
+		cr.GET("/recommends", authSvr.Guest, recommends)
+		cr.GET("/recommends/plus", authSvr.Guest, recommendsPlus)
+		cr.GET("/home", authSvr.Guest, cacheSvr.Cache(deg.Args("pn", "ps", "device", "mobi_app", "build"), nil), home)
+		cr.GET("/view", authSvr.Guest, view)
+		cr.GET("/metas", metas)
+		cr.GET("/card", card)
+		cr.GET("/cards", cards)
+		cr.GET("/notice", notice)
+		cr.GET("/addview", authSvr.Guest, addView)
+		cr.POST("/addshare", authSvr.Guest, addShare)
+		cr.GET("/viewinfo", authSvr.Guest, viewInfo)
+		cr.GET("/actinfo", actInfo)
+		cr.POST("/like", authSvr.User, like)
+		cr.GET("/applyinfo", authSvr.Guest, applyInfo)
+		cr.GET("/is_author", authSvr.User, isAuthor)
+		cr.POST("/author/add", authSvr.User, addAuthor)
+		cr.POST("/apply", authSvr.User, apply)
+		cr.POST("/complaints", authSvr.User, addComplaint)
+		cr.GET("/list", list)
+		cr.GET("/categories", categories)
+		cr.GET("/anniversary", authSvr.User, anniversaryInfo)
+		cr.GET("/sentinel/config", authSvr.Guest, sentinel)
+		ccr := cr.Group("/favorites", authSvr.User)
+		{
+			ccr.POST("/add", addFavorite)
+			ccr.POST("/del", delFavorite)
+			ccr.GET("/list", favorites)
+			ccr.GET("/list/all", allFavorites)
+		}
+		cr.GET("/archives", archives)
+		cr.GET("/early", earlyArticles)
+		cr.GET("/more", authSvr.Guest, moreArts)
+		ccr = cr.Group("/rank")
+		{
+			ccr.GET("/categories", rankCategories)
+			ccr.GET("/list", authSvr.Guest, ranks)
+		}
+		ccr = cr.Group("/user", authSvr.User)
+		{
+			ccr.GET("/notice", userNotice)
+			ccr.POST("/notice/update", updateUserNotice)
+		}
+		// read list
+		cr.GET("/list/articles", authSvr.Guest, listArticles)
+		cr.GET("/list/web/articles", authSvr.Guest, webListArticles)
+		cr.GET("/listinfo", listInfo)
+		cr.GET("/up/lists", upLists)
+		cr.GET("/hotspots", authSvr.Guest, hotspotArts)
+		cr.GET("/authors", authSvr.User, authors)
+		ccr = cr.Group("/creative", authSvr.User)
+		{
+			cr1 := ccr.Group("/list")
+			{
+				cr1.GET("/all", lists)
+				cr1.POST("/add", addList)
+				cr1.POST("/del", delList)
+				cr1.POST("/update", updateListArticles)
+				cr1.GET("/articles/all", listAllArticles)
+				cr1.GET("/articles/can_add", canAddArts)
+				cr1.POST("/articles/update", updateArticleList)
+			}
+			// creative article
+			ccr.POST("/article/submit", webSubArticle)
+			ccr.POST("/article/update", webUpdateArticle)
+			ccr.POST("/draft/addupdate", webSubmitDraft)
+			ccr.GET("/draft/view", webDraft)
+			ccr.GET("/draft/list", webDraftList)
+			ccr.GET("/draft/count", draftCount)
+			ccr.GET("/article/view", webArticle)
+			ccr.GET("/article/list", webArticleList)
+			ccr.GET("/app/pre", creatorArticlePre)
+			ccr.POST("/upload/image", antispamM.ServeHTTP, uploadImage)
+			ccr.POST("/draft/delete", deleteDraft)
+			ccr.POST("/article/delete", delArticle)
+			ccr.POST("/article/withdraw", withdrawArticle)
+			ccr.POST("/article/capture", antispamM.ServeHTTP, articleCapture)
+			ccr.POST("/segment", segment)
+		}
+		// article read ping for timing
+		cr.GET("/read/ping", authSvr.Guest, readPing)
+	}
+
+	cr = r.Group("/x/internal/article", vfySvr.Verify)
+	{
+		cr.GET("/meta", meta)
+		cr.GET("/metas", metas)
+		cr.GET("/list", list)
+		cr.GET("/view", view)
+		cr.GET("/recommends/all", allRecommends)
+		cr.POST("/refresh_list", refreshLists)
+		cr.POST("/rebuild_allrc", rebuildAllListReadCount)
+		cr.POST("/lock", addCheatFilter)
+		cr.POST("/unlock", delCheatFilter)
+	}
+}
+
+func ping(c *bm.Context) {
+	if err := artSrv.Ping(c); err != nil {
+		log.Error("ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}
+
+func register(c *bm.Context) {
+	c.JSON(map[string]interface{}{}, nil)
+}
+
+func buvid(c *bm.Context) string {
+	buvid := c.Request.Header.Get(_headerBuvid)
+	if buvid == "" {
+		cookie, _ := c.Request.Cookie(_buvid)
+		if cookie != nil {
+			buvid = cookie.Value
+		}
+	}
+	return buvid
+}

app/interface/openplatform/article/http/like.go

@@ -0,0 +1,47 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func like(c *bm.Context) {
+	var (
+		id, mid, likeType  int64
+		params             = c.Request.Form
+		idStr, likeTypeStr string
+	)
+	idStr = params.Get("id")
+	likeTypeStr = params.Get("type")
+	id, _ = strconv.ParseInt(idStr, 10, 64)
+	likeType, _ = strconv.ParseInt(likeTypeStr, 10, 64)
+	if (id <= 0) || (likeType == 0) {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	// get mid
+	midInter, _ := c.Get("mid")
+	mid = midInter.(int64)
+	meta, err := artSrv.ArticleMeta(c, id)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if meta == nil {
+		c.JSON(nil, ecode.NothingFound)
+		return
+	}
+	err = artSrv.Like(c, mid, id, int(likeType))
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	likeStr := "like"
+	if likeType == 2 {
+		likeStr = "like_cancel"
+	}
+	artSrv.CheatInfoc.InfoAntiCheat2(c, strconv.FormatInt(meta.Author.Mid, 10), "", strconv.FormatInt(mid, 10), idStr, "article", likeStr, "")
+	c.JSON(nil, nil)
+}

app/interface/openplatform/article/http/list.go

@@ -0,0 +1,91 @@
+package http
+
+import (
+	"go-common/app/interface/openplatform/article/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"strconv"
+)
+
+func listArticles(c *bm.Context) {
+	var (
+		id, mid int64
+	)
+	id, _ = strconv.ParseInt(c.Request.Form.Get("id"), 10, 64)
+	if id <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	// get mid
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(artSrv.ListArticles(c, id, mid))
+}
+
+func webListArticles(c *bm.Context) {
+	var (
+		id, mid int64
+	)
+	id, _ = strconv.ParseInt(c.Request.Form.Get("id"), 10, 64)
+	if id <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	// get mid
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(artSrv.WebListArticles(c, id, mid))
+}
+
+func listInfo(c *bm.Context) {
+	var (
+		aid int64
+	)
+	aid, _ = strconv.ParseInt(c.Request.Form.Get("id"), 10, 64)
+	if aid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(artSrv.ListInfo(c, aid))
+}
+
+func upLists(c *bm.Context) {
+	var (
+		upMid, sort int64
+		err         error
+		lists       model.UpLists
+	)
+	upMid, _ = strconv.ParseInt(c.Request.Form.Get("mid"), 10, 64)
+	if upMid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	sort, _ = strconv.ParseInt(c.Request.Form.Get("sort"), 10, 64)
+	if lists, err = artSrv.UpLists(c, upMid, int8(sort)); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if lists.Lists == nil {
+		lists.Lists = []*model.List{}
+	}
+	c.JSON(lists, err)
+}
+
+func refreshLists(c *bm.Context) {
+	var (
+		id int64
+	)
+	id, _ = strconv.ParseInt(c.Request.Form.Get("id"), 10, 64)
+	if id <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, artSrv.RefreshList(c, id))
+}
+
+func rebuildAllListReadCount(c *bm.Context) {
+	artSrv.RebuildAllListReadCount(c)
+	c.JSON(nil, nil)
+}

app/interface/openplatform/article/http/notice.go

@@ -0,0 +1,13 @@
+package http
+
+import (
+	"strconv"
+
+	bm "go-common/library/net/http/blademaster"
+)
+
+func notice(c *bm.Context) {
+	params := c.Request.Form
+	build, _ := strconv.Atoi(params.Get("build"))
+	c.JSON(artSrv.Notice(params.Get("platform"), build), nil)
+}

app/interface/openplatform/article/http/rank.go

@@ -0,0 +1,38 @@
+package http
+
+import (
+	"strconv"
+
+	artmdl "go-common/app/interface/openplatform/article/model"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+func rankCategories(c *bm.Context) {
+	c.JSON(artSrv.RankCategories(c), nil)
+}
+
+func ranks(c *bm.Context) {
+	var (
+		request  = c.Request
+		params   = request.Form
+		cid, mid int64
+	)
+	cid, _ = strconv.ParseInt(params.Get("cid"), 10, 64)
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	data, note, err := artSrv.Ranks(c, cid, mid, metadata.String(c, metadata.RemoteIP))
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if data == nil {
+		data = []*artmdl.RankMeta{}
+	}
+	res := make(map[string]interface{})
+	res["data"] = data
+	res["note"] = note
+	res["message"] = "ok"
+	c.JSONMap(res, nil)
+}

app/interface/openplatform/article/http/read.go

@@ -0,0 +1,32 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+func readPing(c *bm.Context) {
+	var (
+		buvid  = buvid(c)
+		aid    int64
+		mid    int64
+		ip     = metadata.String(c, metadata.RemoteIP)
+		cur    = time.Now().Unix()
+		source = c.Request.Form.Get("source")
+		err    error
+	)
+	if aid, err = strconv.ParseInt(c.Request.Form.Get("aid"), 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if i, ok := c.Get("mid"); ok {
+		mid = i.(int64)
+	} else {
+		mid = 0
+	}
+	c.JSON(nil, artSrv.ReadPing(c, buvid, aid, mid, ip, cur, source))
+}

app/interface/openplatform/article/http/recommends.go

@@ -0,0 +1,232 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/interface/openplatform/article/conf"
+	"go-common/app/interface/openplatform/article/dao"
+	"go-common/app/interface/openplatform/article/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+)
+
+const (
+	_headerBuvid     = "Buvid"
+	_buvid           = "buvid3"
+	_recommendRegion = 0
+	_rankPage        = 9
+)
+
+func recommends(c *bm.Context) {
+	var (
+		mid    int64
+		rs     []*model.RecommendArtWithLike
+		err    error
+		params = c.Request.Form
+		aids   []int64
+		sky    *model.SkyHorseResp
+	)
+	if aids, _ = xstr.SplitInts(params.Get("aids")); len(aids) == 0 {
+		aids, _ = xstr.SplitInts(params.Get("adis")) //兼容ios客户端bug
+	}
+	cid, _ := strconv.ParseInt(params.Get("cid"), 10, 64)
+	sort, _ := strconv.Atoi(params.Get("sort"))
+	pn, _ := strconv.ParseInt(params.Get("pn"), 10, 64)
+	ps, _ := strconv.ParseInt(params.Get("ps"), 10, 64)
+	if pn <= 0 {
+		pn = 1
+	}
+	if pn > conf.Conf.Article.MaxRecommendPnSize {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if ps <= 0 {
+		ps = 20
+	} else if ps > conf.Conf.Article.MaxRecommendPsSize {
+		ps = conf.Conf.Article.MaxRecommendPsSize
+	}
+	device := params.Get("device")
+	mobiApp := params.Get("mobi_app")
+	plat := model.Plat(mobiApp, device)
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	pageType, _ := strconv.Atoi(params.Get("from"))
+	if pageType == 0 {
+		// 分区页
+		pageType = 2
+	}
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	buvid := buvid(c)
+	if rs, sky, err = artSrv.SkyHorse(c, cid, int(pn), int(ps), aids, sort, mid, build, buvid, plat); err != nil {
+		dao.PromError("推荐接口")
+		log.Error("service.Recommends(%d) error(%+v)", mid, err)
+		c.JSON(nil, err)
+		return
+	}
+	var as []*model.Meta
+	for _, r := range rs {
+		as = append(as, &r.Meta)
+	}
+	artSrv.RecommendInfoc(mid, plat, pageType, int(cid), build, buvid, metadata.String(c, metadata.RemoteIP), as, false, time.Now(), pn, sky)
+	if rs == nil {
+		rs = []*model.RecommendArtWithLike{}
+	}
+	res := make(map[string]interface{})
+	res["aids_len"] = conf.Conf.Article.RecommendAidLen
+	res["data"] = rs
+	c.JSONMap(res, nil)
+}
+
+func home(c *bm.Context) {
+	var (
+		mid    int64
+		rs     *model.RecommendHome
+		err    error
+		params = c.Request.Form
+		ip     = metadata.String(c, metadata.RemoteIP)
+		aids   []int64
+		sky    *model.SkyHorseResp
+	)
+	aids, _ = xstr.SplitInts(params.Get("aids"))
+	pn, _ := strconv.ParseInt(params.Get("pn"), 10, 64)
+	ps, _ := strconv.ParseInt(params.Get("ps"), 10, 64)
+	if pn <= 0 {
+		pn = 1
+	}
+	if pn > conf.Conf.Article.MaxRecommendPnSize {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if ps <= 0 {
+		ps = 20
+	} else if ps > conf.Conf.Article.MaxRecommendPsSize {
+		ps = conf.Conf.Article.MaxRecommendPsSize
+	}
+	device := params.Get("device")
+	mobiApp := params.Get("mobi_app")
+	plat := model.Plat(mobiApp, device)
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	pageType, _ := strconv.Atoi(params.Get("from"))
+	if pageType == 0 {
+		// 首页tab
+		pageType = 8
+	}
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	buvid := buvid(c)
+	if rs, sky, err = artSrv.RecommendHome(c, int8(plat), build, int(pn), int(ps), aids, mid, ip, time.Now(), buvid); err != nil {
+		dao.PromError("推荐接口")
+		log.Error("service.Recommends(%d) error(%+v)", mid, err)
+		c.JSON(nil, ecode.Degrade)
+		return
+	}
+	var as []*model.Meta
+	for _, r := range rs.Articles {
+		as = append(as, &r.Meta)
+	}
+	artSrv.RecommendInfoc(mid, plat, pageType, _recommendRegion, build, buvid, metadata.String(c, metadata.RemoteIP), as, false, time.Now(), pn, sky)
+	if len(rs.Ranks) > 0 && pn == 1 {
+		var as []*model.Meta
+		for _, r := range rs.Ranks {
+			as = append(as, r.Meta)
+		}
+		artSrv.RecommendInfoc(mid, plat, _rankPage, 0, build, buvid, metadata.String(c, metadata.RemoteIP), as, false, time.Now(), pn, nil)
+	}
+	res := make(map[string]interface{})
+	res["aids_len"] = conf.Conf.Article.RecommendAidLen
+	res["data"] = rs
+	c.JSONMap(res, nil)
+}
+
+func recommendsPlus(c *bm.Context) {
+	var (
+		mid    int64
+		rs     *model.RecommendPlus
+		err    error
+		params = c.Request.Form
+		aids   []int64
+		sky    *model.SkyHorseResp
+	)
+	if aids, _ = xstr.SplitInts(params.Get("aids")); len(aids) == 0 {
+		aids, _ = xstr.SplitInts(params.Get("adis")) //兼容ios客户端bug
+	}
+	cid, _ := strconv.ParseInt(params.Get("cid"), 10, 64)
+	sort, _ := strconv.Atoi(params.Get("sort"))
+	pn, _ := strconv.ParseInt(params.Get("pn"), 10, 64)
+	ps, _ := strconv.ParseInt(params.Get("ps"), 10, 64)
+	if pn <= 0 {
+		pn = 1
+	}
+	if pn > conf.Conf.Article.MaxRecommendPnSize {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if ps <= 0 {
+		ps = 20
+	} else if ps > conf.Conf.Article.MaxRecommendPsSize {
+		ps = conf.Conf.Article.MaxRecommendPsSize
+	}
+	device := params.Get("device")
+	mobiApp := params.Get("mobi_app")
+	plat := model.Plat(mobiApp, device)
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	pageType, _ := strconv.Atoi(params.Get("from"))
+	if pageType == 0 {
+		// 分区页
+		pageType = 2
+	}
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	buvid := buvid(c)
+	if rs, sky, err = artSrv.RecommendPlus(c, cid, int8(plat), build, int(pn), int(ps), aids, mid, time.Now(), sort, buvid); err != nil {
+		c.JSON(nil, err)
+		dao.PromError("推荐接口")
+		log.Error("service.Recommends(%d) error(%+v)", mid, err)
+		return
+	}
+	var as []*model.Meta
+	for _, r := range rs.Articles {
+		as = append(as, &r.Meta)
+	}
+	artSrv.RecommendInfoc(mid, plat, pageType, int(cid), build, buvid, metadata.String(c, metadata.RemoteIP), as, false, time.Now(), pn, sky)
+	if len(rs.Ranks) > 0 && pn == 1 {
+		var as []*model.Meta
+		for _, r := range rs.Ranks {
+			as = append(as, r.Meta)
+		}
+		artSrv.RecommendInfoc(mid, plat, _rankPage, 0, build, buvid, metadata.String(c, metadata.RemoteIP), as, false, time.Now(), pn, nil)
+	}
+	if rs.Articles == nil {
+		rs.Articles = []*model.RecommendArtWithLike{}
+	}
+	res := make(map[string]interface{})
+	res["aids_len"] = conf.Conf.Article.RecommendAidLen
+	res["data"] = rs
+	c.JSONMap(res, nil)
+}
+
+func allRecommends(c *bm.Context) {
+	v := new(struct {
+		Pn int `form:"pn" validate:"min=1"`
+		Ps int `form:"ps" validate:"min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	count, recommends, err := artSrv.AllRecommends(c, v.Pn, v.Ps)
+	c.JSON(map[string]interface{}{
+		"total": count,
+		"list":  recommends,
+	}, err)
+}

app/interface/openplatform/article/http/search.go

@@ -0,0 +1,23 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func segment(c *bm.Context) {
+	var params = c.Request.Form
+	idStr := params.Get("id")
+	content := params.Get("content")
+	withTagStr := params.Get("with_tag")
+
+	id, _ := strconv.Atoi(idStr)
+	withTag, _ := strconv.Atoi(withTagStr)
+	if id == 0 || content == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(artSrv.Segment(c, int32(id), content, withTag, "draft"))
+}

app/interface/openplatform/article/http/sentinel.go

@@ -0,0 +1,7 @@
+package http
+
+import bm "go-common/library/net/http/blademaster"
+
+func sentinel(c *bm.Context) {
+	c.JSON(map[string]interface{}{"sentinel": artSrv.Sentinel(c)}, nil)
+}

app/interface/openplatform/article/http/share.go

@@ -0,0 +1,26 @@
+package http
+
+import (
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+	"strconv"
+)
+
+func addShare(c *bm.Context) {
+	var (
+		id     int64
+		mid    int64
+		params = c.Request.Form
+	)
+	idStr := params.Get("id")
+	id, _ = strconv.ParseInt(idStr, 10, 64)
+	if id <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(nil, artSrv.AddShare(c, id, mid, metadata.String(c, metadata.RemoteIP)))
+}

app/interface/openplatform/article/http/users.go

@@ -0,0 +1,18 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func userNotice(c *bm.Context) {
+	midInter, _ := c.Get("mid")
+	mid := midInter.(int64)
+	c.JSON(artSrv.UserNoticeState(c, mid))
+}
+
+func updateUserNotice(c *bm.Context) {
+	midInter, _ := c.Get("mid")
+	mid := midInter.(int64)
+	typ := c.Request.Form.Get("type")
+	c.JSON(nil, artSrv.UpdateUserNoticeState(c, mid, typ))
+}

app/interface/openplatform/article/http/view.go

@@ -0,0 +1,222 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/interface/openplatform/article/conf"
+	artmdl "go-common/app/interface/openplatform/article/model"
+	"go-common/library/ecode"
+	"go-common/library/log/infoc"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+func view(c *bm.Context) {
+	var (
+		id     int64
+		err    error
+		art    *artmdl.Article
+		params = c.Request.Form
+	)
+	idStr := params.Get("id")
+	id, _ = strconv.ParseInt(idStr, 10, 64)
+	if id <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if art, err = artSrv.Article(c, id); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if art == nil {
+		c.JSON(nil, ecode.NothingFound)
+		return
+	}
+	c.JSON(art, err)
+}
+
+func addView(c *bm.Context) {
+	var (
+		mid    int64
+		params = c.Request.Form
+		page   = params.Get("page")
+		from   = params.Get("from")
+		ip     = metadata.String(c, metadata.RemoteIP)
+	)
+	if page == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if from == "" {
+		from = "unknow"
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	device := params.Get("device")
+	mobiApp := params.Get("mobi_app")
+	plat := artmdl.Plat(mobiApp, device)
+	build := params.Get("build")
+	buvid := buvid(c)
+	// for tianma mainCard -> 7
+	if from == "mainCard" {
+		from = "7"
+	}
+	ua := c.Request.Header.Get("User-Agent")
+	referer := c.Request.Header.Get("Referer")
+	artSrv.ShowInfoc(ip, time.Now(), buvid, mid, plat, page, from, build, ua, referer)
+	c.JSON(nil, nil)
+}
+
+func viewInfo(c *bm.Context) {
+	var (
+		id      int64
+		mid     int64
+		data    *artmdl.ViewInfo
+		request = c.Request
+		params  = request.Form
+		ip      = metadata.String(c, metadata.RemoteIP)
+		err     error
+	)
+	idStr := params.Get("id")
+	id, _ = strconv.ParseInt(idStr, 10, 64)
+	if id == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	cheat := cheatInfo(c, mid, id)
+	device := params.Get("device")
+	mobiApp := params.Get("mobi_app")
+	plat := artmdl.Plat(mobiApp, device)
+	from := params.Get("from")
+	if data, err = artSrv.ViewInfo(c, mid, id, ip, cheat, plat, from); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	buildStr := params.Get("build")
+	build, _ := strconv.Atoi(buildStr)
+	buvid := buvid(c)
+	if from == "articleSlideShow" {
+		data.Pre, data.Next = artSrv.ViewList(c, id, buvid, "articleSlide", ip, build, plat, mid)
+	} else {
+		data.Pre, data.Next = artSrv.ViewList(c, id, buvid, from, ip, build, plat, mid)
+	}
+	// for tianma mainCard -> 7
+	if from == "mainCard" {
+		from = "7"
+	}
+	if from != "articleSlide" {
+		ua := c.Request.Header.Get("User-Agent")
+		artSrv.ViewInfoc(mid, plat, build, "doc", from, buvid, id, time.Now(), ua)
+		artSrv.AIViewInfoc(mid, plat, build, "doc", from, buvid, id, time.Now(), ua)
+	}
+	c.JSON(data, nil)
+}
+
+func list(c *bm.Context) {
+	var (
+		mid     int64
+		request = c.Request
+		params  = request.Form
+		pn, ps  int64
+	)
+	midStr := params.Get("mid")
+	mid, _ = strconv.ParseInt(midStr, 10, 64)
+	if mid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	pnStr := params.Get("pn")
+	pn, _ = strconv.ParseInt(pnStr, 10, 64)
+	if pn <= 0 {
+		pn = 1
+	}
+	psStr := params.Get("ps")
+	ps, _ = strconv.ParseInt(psStr, 10, 64)
+	if ps <= 0 {
+		ps = 20
+	} else if ps > conf.Conf.Article.MaxUpperListPsSize {
+		ps = conf.Conf.Article.MaxUpperListPsSize
+	}
+	c.JSON(artSrv.UpArtMetasAndLists(c, mid, int(pn), int(ps), artmdl.FieldDefault))
+}
+
+func earlyArticles(c *bm.Context) {
+	var (
+		err    error
+		aid    int64
+		params = c.Request.Form
+	)
+	aidStr := params.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(artSrv.MoreArts(c, aid))
+}
+
+func moreArts(c *bm.Context) {
+	var (
+		err      error
+		aid, mid int64
+		params   = c.Request.Form
+	)
+	aidStr := params.Get("aid")
+	if aid, err = strconv.ParseInt(aidStr, 10, 64); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(artSrv.Mores(c, aid, mid))
+}
+
+func cheatInfo(c *bm.Context, mid, id int64) (res *artmdl.CheatInfo) {
+	req := c.Request
+	params := req.Form
+	res = &artmdl.CheatInfo{
+		Mid:   strconv.FormatInt(mid, 10),
+		Cvid:  strconv.FormatInt(id, 10),
+		Refer: req.Header.Get("Referer"),
+		UA:    req.Header.Get("User-Agent"),
+		Ts:    strconv.FormatInt(time.Now().Unix(), 10),
+		IP:    metadata.String(c, metadata.RemoteIP),
+	}
+	if csid, err := req.Cookie("sid"); err == nil {
+		res.Sid = csid.Value
+	}
+	if params.Get("access_key") == "" {
+		res.Client = infoc.ClientWeb
+		if ck, err := req.Cookie("buvid3"); err == nil {
+			res.Buvid = ck.Value
+		}
+	} else {
+		if params.Get("platform") == "ios" {
+			if params.Get("device") == "pad" {
+				res.Client = infoc.ClientIpad
+			} else {
+				res.Client = infoc.ClientIphone
+			}
+		} else if params.Get("platform") == "android" {
+			res.Client = infoc.ClientAndroid
+		}
+		res.Buvid = req.Header.Get("buvid")
+		res.Build = params.Get("build")
+	}
+	return
+}
+
+func actInfo(c *bm.Context) {
+	var (
+		request = c.Request
+		params  = request.Form
+	)
+	mobiApp := params.Get("mobi_app")
+	plat := artmdl.Plat(mobiApp, "")
+	c.JSON(artSrv.ActInfo(c, plat))
+}