Create & Init Project...

app/interface/main/tv/http/BUILD

@@ -0,0 +1,67 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "audit.go",
+        "auth.go",
+        "history.go",
+        "http.go",
+        "media.go",
+        "others.go",
+        "pages.go",
+        "recommend.go",
+        "search.go",
+        "tvvip.go",
+        "ugc.go",
+        "ugc_view.go",
+        "upgrade.go",
+        "wild.go",
+        "zone_index.go",
+    ],
+    importpath = "go-common/app/interface/main/tv/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/tv/conf:go_default_library",
+        "//app/interface/main/tv/dao/thirdp:go_default_library",
+        "//app/interface/main/tv/model:go_default_library",
+        "//app/interface/main/tv/model/search:go_default_library",
+        "//app/interface/main/tv/model/tvvip:go_default_library",
+        "//app/interface/main/tv/service/app:go_default_library",
+        "//app/interface/main/tv/service/audit:go_default_library",
+        "//app/interface/main/tv/service/favorite:go_default_library",
+        "//app/interface/main/tv/service/goblin:go_default_library",
+        "//app/interface/main/tv/service/history:go_default_library",
+        "//app/interface/main/tv/service/pgc:go_default_library",
+        "//app/interface/main/tv/service/search:go_default_library",
+        "//app/interface/main/tv/service/thirdp:go_default_library",
+        "//app/interface/main/tv/service/tvvip:go_default_library",
+        "//app/interface/main/tv/service/view:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/binding:go_default_library",
+        "//library/net/http/blademaster/middleware/auth:go_default_library",
+        "//library/net/http/blademaster/middleware/verify:go_default_library",
+        "//library/net/http/blademaster/render:go_default_library",
+        "//library/net/metadata: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/main/tv/http/audit.go

@@ -0,0 +1,111 @@
+package http
+
+import (
+	"crypto/md5"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"sort"
+
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// audit season with content
+func audit(c *bm.Context) {
+	if err := auditT(c); err != nil { // if some error, return it
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func auditT(c *bm.Context) (err error) {
+	var (
+		audit model.Audit
+		req   = c.Request
+	)
+	defer req.Body.Close()
+	body, _ := ioutil.ReadAll(req.Body)
+	if err = json.Unmarshal(body, &audit); err != nil {
+		log.Error("audit json(%s) error:(%v)", string(body), err)
+		err = ecode.RequestErr
+		return
+	}
+	if !validateJSONData(audit) {
+		log.Error("audit msg (%s), missing field", string(body))
+		err = ecode.RequestErr
+		return
+	}
+	if !checkSign(c, string(body)) {
+		log.Error("audit msg (%s), sign error", string(body))
+		err = ecode.RequestErr
+		return
+	}
+	return auditSvc.HandleAudits(c, audit.IDList)
+}
+
+// validateJSONData check json format whether valid
+func validateJSONData(a model.Audit) bool {
+	if a.OpType == "" {
+		return false
+	}
+	for _, v := range a.IDList {
+		if v.Type == "" || v.VID == "" || v.Action == "" {
+			return false
+		}
+	}
+	return a.Count > 0
+}
+
+// checkSign check sign whether valid
+func checkSign(c *bm.Context, body string) bool {
+	var (
+		req   = c.Request.Form
+		query = make(map[string]string)
+		ts    = req.Get("ts")
+		key   = req.Get("key")
+		sign  = req.Get("sign")
+	)
+	if key != signCfg.Key {
+		log.Error("The appkey not exists")
+		return false
+	}
+	if ts == "" {
+		log.Error("The timestamp not exists")
+		return false
+	}
+	query["ts"] = ts
+	query["body"] = body
+	query["appkey"] = key
+	if sign == "" {
+		log.Error("The sign not exists")
+		return false
+	}
+	getSign := signature(query)
+	if sign != getSign {
+		log.Error("The expected signature is :(%s)", getSign)
+		return false
+	}
+	return sign == getSign
+}
+
+func signature(query map[string]string) string {
+	secret := signCfg.Secret
+	var keys []string
+	for k := range query {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	var str string
+	for _, v := range keys {
+		str += string(v) + "=" + query[v] + "&"
+	}
+	str = str[:len(str)-1] + secret
+	hash := md5.New()
+	hash.Write([]byte(str))
+	sign := fmt.Sprintf("%x", hash.Sum(nil))
+	return sign
+}

app/interface/main/tv/http/auth.go

@@ -0,0 +1,44 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+func loadEP(c *bm.Context) {
+	// bind
+	v := new(struct {
+		EPID  int64 `form:"epid" validate:"required,min=1"`
+		Build int64 `form:"build"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	// take cache and distinguish the error msg
+	if isok, errMsg, err := tvSvc.EpMsg(v.EPID, v.Build); err != nil {
+		c.JSON(nil, err)
+	} else {
+		c.JSONMap(map[string]interface{}{
+			"data":    isok,
+			"message": errMsg,
+		}, nil)
+	}
+}
+
+func loadVideo(c *bm.Context) {
+	// bind
+	v := new(struct {
+		CID int64 `form:"cid" validate:"required,min=1"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	// take cache and distinguish the error msg
+	if isok, errMsg, err := viewSvc.VideoMsg(c, v.CID); err != nil {
+		c.JSON(nil, err)
+	} else {
+		c.JSONMap(map[string]interface{}{
+			"data":    isok,
+			"message": errMsg,
+		}, nil)
+	}
+}

app/interface/main/tv/http/history.go

@@ -0,0 +1,25 @@
+package http
+
+import (
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// get history
+func history(c *bm.Context) {
+	v := new(struct {
+		AccessKey string `form:"access_key"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if v.AccessKey == "" {
+		c.JSON(nil, ecode.NoLogin)
+		return
+	}
+	if mid, ok := c.Get("mid"); !ok { // if not login, we don't call follow data
+		c.JSON(nil, ecode.NoLogin)
+	} else {
+		c.JSON(hisSvc.GetHistory(c, mid.(int64)))
+	}
+}

app/interface/main/tv/http/http.go

@@ -0,0 +1,194 @@
+package http
+
+import (
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/tv/conf"
+	appsrv "go-common/app/interface/main/tv/service/app"
+	auditsrv "go-common/app/interface/main/tv/service/audit"
+	"go-common/app/interface/main/tv/service/favorite"
+	gobsrv "go-common/app/interface/main/tv/service/goblin"
+	hissrv "go-common/app/interface/main/tv/service/history"
+	"go-common/app/interface/main/tv/service/pgc"
+	secsrv "go-common/app/interface/main/tv/service/search"
+	"go-common/app/interface/main/tv/service/thirdp"
+	"go-common/app/interface/main/tv/service/tvvip"
+	viewsrv "go-common/app/interface/main/tv/service/view"
+	"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/verify"
+)
+
+var (
+	favSvc    *favorite.Service
+	tvSvc     *appsrv.Service
+	viewSvc   *viewsrv.Service
+	auditSvc  *auditsrv.Service
+	gobSvc    *gobsrv.Service
+	secSvc    *secsrv.Service
+	thirdpSvc *thirdp.Service
+	tvVipSvc  *tvvip.Service
+	authSvc   *auth.Auth
+	vfySvc    *verify.Verify
+	hisSvc    *hissrv.Service
+	pgcSvc    *pgc.Service
+	signCfg   *conf.AuditSign
+)
+
+// Init init http sever instance.
+func Init(c *conf.Config) {
+	signCfg = c.Cfg.AuditSign
+	initService(c)
+	// init outer router
+	engineOut := bm.NewServer(c.HTTPServer)
+	engineOut.Use(bm.Recovery(), bm.Trace(), bm.Logger(), bm.Mobile())
+	outerRouter(engineOut)
+	if err := engineOut.Start(); err != nil {
+		log.Error("engineOut.Start error(%v)", err)
+		panic(err)
+	}
+}
+
+func parseInt(value string) int64 {
+	intval, err := strconv.ParseInt(value, 10, 64)
+	if err != nil {
+		intval = 0
+	}
+	return intval
+}
+
+func takeBuild(req url.Values) {
+	buildStr := req.Get("build")
+	if buildStr != "" {
+		if tvSvc.TVAppInfo.Build != buildStr {
+			tvSvc.TVAppInfo.Build = buildStr
+		}
+	}
+	platStr := req.Get("platform")
+	if platStr != "" {
+		if tvSvc.TVAppInfo.Platform != platStr {
+			tvSvc.TVAppInfo.Platform = buildStr
+		}
+	}
+	mobiStr := req.Get("mobi_app")
+	if mobiStr != "" {
+		if tvSvc.TVAppInfo.MobiApp != mobiStr {
+			tvSvc.TVAppInfo.MobiApp = mobiStr
+		}
+	}
+}
+
+func outerRouter(e *bm.Engine) {
+	e.Ping(ping)
+	tv := e.Group("/x/tv", bm.CORS(), bm.CSRF())
+	e.GET("/x/tv/vip/order/guest_create", authSvc.User, createGuestOrder)
+	{
+		app := tv.Group("", authSvc.Guest) // the public group
+		{
+			// app pages
+			app.GET("/homepage", homepage)
+			app.GET("/zonepage", zonePage)
+			app.GET("/zone_index", zoneIdx)
+			app.GET("/media_detail", mediaDetail)
+			app.GET("/modpage", modpage)
+			// app functions
+			app.GET("/upgrade", upgrade)
+			app.GET("/splash", splash)
+			app.GET("/recommend", recommend)
+			app.GET("/suggest", searchSug)
+			app.GET("/hotword", hotword)
+			app.GET("/history", history)
+			// dangbei page
+			app.GET("/dangbei", dbeiPage)
+			// video audit status check
+			app.GET("/loadep", loadEP)
+			app.GET("/labels", labels)
+		}
+		aud := e.Group("/x/tv/audit", bm.CSRF()) // license owner audit related functions
+		{
+			aud.POST("", audit)
+			aud.POST("/transcode", vfySvc.Verify, transcode)
+			aud.POST("/apply/pgc", vfySvc.Verify, applyPGC)
+		}
+		pgc := e.Group("/x/tv/pgc", bm.CSRF(), authSvc.Guest)
+		{
+			pgc.GET("/view", mDetailV2)
+		}
+		ugc := e.Group("/x/tv/ugc", bm.CSRF(), authSvc.Guest) // the APIs dedicated for ugc
+		{
+			ugc.GET("/view", view)
+			ugc.GET("/load_video", loadVideo)
+			ugc.GET("/playurl", ugcPlayurl)
+		}
+		search := e.Group("/x/tv/search", bm.CSRF(), authSvc.Guest) // the APIs for search
+		{
+			search.GET("/types", searchTypes)
+			search.GET("", searchResult)
+			wild := search.Group("/wild")
+			{
+				wild.GET("", searchAll)      // 综合搜索
+				wild.GET("user", userSearch) // 按用户搜索
+				wild.GET("pgc", pgcSearch)   // pgc番剧影视
+			}
+		}
+		fav := e.Group("/x/tv/favorites", bm.CSRF(), authSvc.Guest)
+		{
+			fav.GET("", favorites)
+			fav.POST("/act", favAct)
+		}
+		mango := e.Group("/x/tv/mango", bm.CSRF())
+		{
+			mango.GET("/recom", mangoRecom)
+		}
+		third := e.Group("/x/tv/third", bm.CSRF())
+		{
+			third.GET("/pgc/season", mangoSnPage)
+			third.GET("/pgc/ep", mangoEpPage)
+			third.GET("/ugc/archive", mangoArcPage)
+			third.GET("/ugc/video", mangoVideoPage)
+		}
+		idx := e.Group("/x/tv/index", bm.CSRF(), authSvc.Guest)
+		{
+			idx.GET("/pgc", pgcIdx)
+			idx.GET("/ugc", ugcIdx)
+		}
+		tv.GET("/region", region) // all region info
+		vip := e.Group("/x/tv/vip", bm.CSRF())
+		{
+			vip.GET("/user/info", authSvc.UserMobile, vipInfo)
+			vip.GET("/user/yst_info", ystVipInfo)
+			vip.GET("/panel/user", authSvc.UserMobile, panelInfo)
+			vip.GET("/panel/guest", authSvc.Guest, guestPanelInfo)
+
+			vip.POST("/order/qr", authSvc.UserMobile, createQr)
+			vip.POST("/order/guest_qr", authSvc.Guest, createGuestQr)
+			vip.GET("/order/create", authSvc.Guest, createOrder)
+
+			vip.GET("/token/info", authSvc.UserMobile, tokenStatus)
+
+			vip.POST("/callback/pay", payCallback)
+			vip.POST("/callback/wx_contract", wxContractCallback)
+
+		}
+	}
+}
+
+// ping check db server ok.
+func ping(c *bm.Context) {}
+
+func initService(c *conf.Config) {
+	tvSvc = appsrv.New(c)
+	viewSvc = viewsrv.New(c)
+	favSvc = favorite.New(c)
+	auditSvc = auditsrv.New(c)
+	gobSvc = gobsrv.New(c)
+	secSvc = secsrv.New(c)
+	authSvc = auth.New(c.Auth)
+	vfySvc = verify.New(c.Verify)
+	hisSvc = hissrv.New(c)
+	thirdpSvc = thirdp.New(c)
+	pgcSvc = pgc.New(c)
+	tvVipSvc = tvvip.New(c)
+}

app/interface/main/tv/http/media.go

@@ -0,0 +1,66 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func atoi(param string) int {
+	if param == "" {
+		return 0
+	}
+	res, err := strconv.Atoi(param)
+	if err != nil {
+		return 0
+	}
+	return res
+}
+
+func mDetailParam(c *bm.Context, param *model.MediaParam) (err error) {
+	var msg string
+	if err = c.Bind(param); err != nil {
+		return
+	}
+	if param.EpID == 0 && param.SeasonID == 0 {
+		err = ecode.RequestErr
+		c.JSON(nil, err)
+		return
+	}
+	if param.EpID > 0 {
+		if param.SeasonID, msg, err = pgcSvc.EpControl(c, param.EpID); err != nil {
+			c.JSONMap(map[string]interface{}{"message": msg}, err)
+			return
+		}
+	}
+	return
+}
+
+// get ep/season detail
+func mediaDetail(c *bm.Context) {
+	var param = new(model.MediaParam)
+	if err := mDetailParam(c, param); err != nil {
+		return
+	}
+	detail, msg, err := pgcSvc.SnDetail(c, param)
+	if err != nil {
+		c.JSONMap(map[string]interface{}{"message": msg}, err)
+		return
+	}
+	c.JSONMap(map[string]interface{}{"result": detail, "message": "success"}, nil)
+}
+
+func mDetailV2(c *bm.Context) {
+	var param = new(model.MediaParam)
+	if err := mDetailParam(c, param); err != nil {
+		return
+	}
+	detail, msg, err := pgcSvc.SnDetailV2(c, param)
+	if err != nil {
+		c.JSONMap(map[string]interface{}{"message": msg}, err)
+		return
+	}
+	c.JSONMap(map[string]interface{}{"result": detail, "message": "success"}, nil)
+}

app/interface/main/tv/http/others.go

@@ -0,0 +1,103 @@
+package http
+
+import (
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// get splash
+func transcode(c *bm.Context) {
+	v := new(model.ReqTransode)
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	c.JSON(nil, auditSvc.Transcode(v))
+}
+
+// get splash
+func hotword(c *bm.Context) {
+	hotword := gobSvc.Hotword
+	if hotword == nil {
+		c.JSON(nil, ecode.ServiceUnavailable)
+		return
+	}
+	c.JSON(hotword, nil)
+}
+
+// get splash
+func splash(c *bm.Context) {
+	v := new(struct {
+		Channel string `form:"channel" validate:"required"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	c.JSON(gobSvc.PickSph(v.Channel))
+}
+
+func favorites(c *bm.Context) {
+	v := new(model.FormFav)
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	if v.AccessKey != "" {
+		if mid, ok := c.Get("mid"); ok { // if not logged in, not request follow
+			c.JSON(favSvc.Favorites(c, v.ToReq(mid.(int64))))
+			return
+		}
+	}
+	c.JSON(nil, ecode.NoLogin)
+}
+
+func favAct(c *bm.Context) {
+	v := new(model.FormFavAct)
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	if v.AccessKey != "" {
+		if mid, ok := c.Get("mid"); ok { // if not logged in, not request follow
+			c.JSON(nil, favSvc.FavAct(c, v.ToReq(mid.(int64))))
+			return
+		}
+	}
+	c.JSON(nil, ecode.NoLogin)
+}
+
+func applyPGC(c *bm.Context) {
+	v := new(model.ReqApply)
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	c.JSON(nil, auditSvc.ApplyPGC(c, v))
+}
+
+func labels(c *bm.Context) {
+	v := new(struct {
+		CatType  int `form:"cat_type" validate:"required,min=1,max=2"`
+		Category int `form:"category" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(gobSvc.Labels(c, v.CatType, v.Category))
+}
+
+func region(c *bm.Context) {
+	var (
+		err error
+		res []*model.Region
+		m   = make(map[string]interface{})
+	)
+	if res, err = tvSvc.Regions(c); err != nil {
+		return
+	}
+	m["mtime"] = tvSvc.MaxTime
+	m["data"] = res
+	c.JSONMap(m, nil)
+}

app/interface/main/tv/http/pages.go

@@ -0,0 +1,145 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/tv/dao/thirdp"
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func zonePage(c *bm.Context) {
+	var (
+		t   int
+		err error
+		req = c.Request.Form
+	)
+	takeBuild(req) // take build number
+	seasonType := req.Get("season_type")
+	if seasonType == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if t, err = strconv.Atoi(seasonType); err != nil || t < 1 {
+		t = 1
+	}
+	zone, ok := tvSvc.RankData[t]
+	if !ok {
+		c.JSON(nil, ecode.ServerErr)
+		return
+	}
+	c.JSON(zone, nil)
+}
+
+func homepage(c *bm.Context) {
+	var err error
+	params := c.Request.Form
+	accessKey := params.Get("access_key")
+	homeData := *tvSvc.HomeData
+	takeBuild(params) // take build number
+	if accessKey != "" {
+		_, ok := c.Get("mid")
+		if !ok { // if not login, we don't call follow data
+			err = ecode.NoLogin
+		} else {
+			homeData.Follow = tvSvc.FollowData(c, accessKey)
+		}
+	}
+	if tvSvc.HomeData == nil {
+		log.Error("HomeData is Nil")
+		c.JSON(nil, ecode.ServerErr)
+		return
+	}
+	c.JSON(homeData, err)
+}
+
+func modpage(c *bm.Context) {
+	var (
+		err    error
+		params = c.Request.Form
+	)
+	v := new(model.ReqPageFollow)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	takeBuild(params)
+	// check login
+	if v.AccessKey != "" {
+		_, ok := c.Get("mid")
+		if !ok { // if not logged in, not request follow
+			err = ecode.NoLogin
+			v.AccessKey = ""
+		}
+	}
+	c.JSON(tvSvc.PageFollow(c, v))
+}
+
+// get dangbei pgc data by page
+func dbeiPage(c *bm.Context) {
+	v := new(struct {
+		Page  int64  `form:"page" validate:"required"`
+		TypeC string `form:"type_c" validate:"required"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	// check the typeC ( type of the content ) value
+	if _, err = thirdp.KeyThirdp(v.TypeC); err != nil {
+		c.JSON(nil, ecode.TvDangbeiWrongType)
+		return
+	}
+	c.JSON(thirdpSvc.PickDBeiPage(v.Page, v.TypeC))
+}
+
+func mangoRecom(c *bm.Context) {
+	c.JSON(thirdpSvc.MangoRecom(), nil)
+}
+
+func mangoSnPage(c *bm.Context) {
+	v := new(struct {
+		Page int64 `form:"page" validate:"required"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	c.JSON(thirdpSvc.MangoSns(c, v.Page))
+}
+
+func mangoEpPage(c *bm.Context) {
+	v := new(struct {
+		SID  int64 `form:"sid" validate:"required"`
+		Page int   `form:"page" validate:"required"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	c.JSON(thirdpSvc.MangoEps(c, v.SID, v.Page))
+}
+
+func mangoArcPage(c *bm.Context) {
+	v := new(struct {
+		Page int64 `form:"page" validate:"required"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	c.JSON(thirdpSvc.MangoArcs(c, v.Page))
+}
+
+func mangoVideoPage(c *bm.Context) {
+	v := new(struct {
+		AVID int64 `form:"avid" validate:"required"`
+		Page int   `form:"page" validate:"required"`
+	})
+	err := c.Bind(v)
+	if err != nil {
+		return
+	}
+	c.JSON(thirdpSvc.MangoVideos(c, v.AVID, v.Page))
+}

app/interface/main/tv/http/recommend.go

@@ -0,0 +1,19 @@
+package http
+
+import (
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// get season's recommend data from pgc
+func recommend(c *bm.Context) {
+	req := c.Request.Form
+	sid := req.Get("season_id")
+	stype := req.Get("season_type")
+	// param check
+	if atoi(sid) == 0 || atoi(stype) == 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(tvSvc.RecomFilter(sid, stype))
+}

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

@@ -0,0 +1,64 @@
+package http
+
+import (
+	searchMdl "go-common/app/interface/main/tv/model/search"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+const (
+	_orderAll  = "totalrank"
+	_orderDate = "pubdate"
+)
+
+// searchTypes returns the ugc types
+func searchTypes(c *bm.Context) {
+	c.JSON(tvSvc.SearchTypes())
+}
+
+// searchResult returns the result of search
+func searchResult(c *bm.Context) {
+	v := new(searchMdl.ReqSearch)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if v.Order != "" && v.Order != _orderAll && v.Order != _orderDate {
+		c.JSON(nil, ecode.TvSearchOrderWrong)
+	}
+	c.JSON(secSvc.SearchRes(c, v))
+}
+
+// searchSug search suggestion words
+func searchSug(c *bm.Context) {
+	v := new(searchMdl.ReqSug)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	data, err := secSvc.SearchSug(c, v)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSONMap(map[string]interface{}{
+		"result":  data.Result,
+		"message": "success",
+		"cost":    data.Cost,
+		"stoken":  data.Stoken,
+	}, nil)
+}
+
+func pgcIdx(c *bm.Context) {
+	v := new(searchMdl.ReqPgcIdx)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(tvSvc.EsPgcIdx(c, v))
+}
+
+func ugcIdx(c *bm.Context) {
+	v := new(searchMdl.ReqUgcIdx)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	c.JSON(tvSvc.EsUgcIdx(c, v))
+}

app/interface/main/tv/http/tvvip.go

@@ -0,0 +1,338 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"go-common/app/interface/main/tv/conf"
+	tvmdl "go-common/app/interface/main/tv/model/tvvip"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+	"go-common/library/net/http/blademaster/render"
+	"go-common/library/net/metadata"
+)
+
+const (
+	userAgentWechat = "MicroMessenger"
+	userAgentAliPay = "AlipayClient"
+	userAgentIphone = "iPhone"
+	userAgentIpad   = "iPad"
+	agentAndroid    = "Android"
+
+	platformAndroid = 1
+	platformIos     = 3
+	platformOther   = 4
+
+	errPageURL = "https://www.bilibili.com/blackboard/activity-kWDq8R7f6R.html?code=%d"
+
+	errOrderInvalid        = 93018
+	errQrDeviceUnsupported = 93019
+	errOrderUnknownErr     = 93020
+	errPanelErr            = 93021
+	errBuyRateExceededErr  = 93022
+
+	ystErrBadRequest  = "93030"
+	ystErrNotFound    = "93031"
+	ystErrInternalErr = "93032"
+)
+
+func ystErrResp(result string, msg string) map[string]interface{} {
+	return map[string]interface{}{
+		"result": result,
+		"msg":    msg,
+	}
+}
+
+func ystRender(ctx *bm.Context, data map[string]interface{}) {
+	ctx.Render(http.StatusOK, render.MapJSON(data))
+}
+
+func errPage(err error) string {
+	if ecode.EqualError(ecode.TVIPQrDevideUnsupported, err) {
+		return fmt.Sprintf(errPageURL, errQrDeviceUnsupported)
+	}
+	if ecode.EqualError(ecode.TVIPTokenErr, err) {
+		return fmt.Sprintf(errPageURL, errOrderInvalid)
+	}
+	if ecode.EqualError(ecode.TVIPTokenExpire, err) {
+		return fmt.Sprintf(errPageURL, errOrderInvalid)
+	}
+	if ecode.EqualError(ecode.TVIPDupOrderNo, err) {
+		return fmt.Sprintf(errPageURL, errOrderInvalid)
+	}
+
+	if ecode.EqualError(ecode.TVIPPanelNotSuitalbe, err) {
+		return fmt.Sprintf(errPageURL, errPanelErr)
+	}
+	if ecode.EqualError(ecode.TVIPPanelNotFound, err) {
+		return fmt.Sprintf(errPageURL, errPanelErr)
+	}
+	if ecode.EqualError(ecode.TVIPBuyNumExceeded, err) {
+		return fmt.Sprintf(errPageURL, errPanelErr)
+	}
+	if ecode.EqualError(ecode.TVIPBuyRateExceeded, err) {
+		return fmt.Sprintf(errPageURL, errBuyRateExceededErr)
+	}
+	if ecode.EqualError(ecode.TVIPMVipRateExceeded, err) {
+		return fmt.Sprintf(errPageURL, errBuyRateExceededErr)
+	}
+	log.Error("errPage(%+v) err(UnExpectedErr)", err)
+	return fmt.Sprintf(errPageURL, errOrderUnknownErr)
+}
+
+func payTypeFromUA(ctx *bm.Context) (payType string, err error) {
+	ua := ctx.Request.UserAgent()
+	if strings.Contains(ua, userAgentWechat) {
+		return "", ecode.TVIPQrDevideUnsupported
+		//return "wechat", nil
+	} else if strings.Contains(ua, userAgentAliPay) {
+		return "alipay", nil
+	} else {
+		return "", ecode.TVIPQrDevideUnsupported
+	}
+}
+
+func platformFromUA(ctx *bm.Context) (platform int8, err error) {
+	ua := ctx.Request.UserAgent()
+	if strings.Contains(ua, userAgentIpad) {
+		return platformIos, nil
+	} else if strings.Contains(ua, userAgentIphone) {
+		return platformIos, nil
+	} else if strings.Contains(ua, agentAndroid) {
+		return platformAndroid, nil
+	}
+	return platformOther, nil
+}
+
+func isIpValid(ip string) bool {
+	log.Info("ip: %s ipWhiteList: %+v", ip, conf.Conf.IP.White.TvVip)
+	if len(conf.Conf.IP.White.TvVip) == 0 {
+		return true
+	}
+	for _, wip := range conf.Conf.IP.White.TvVip {
+		if wip == ip {
+			return true
+		}
+	}
+	return false
+}
+
+// VipInfo implementation
+func vipInfo(ctx *bm.Context) {
+	mid, ok := ctx.Get("mid")
+	if !ok {
+		ctx.JSON(nil, ecode.NoLogin)
+		return
+	}
+	ctx.JSON(tvVipSvc.VipInfo(ctx, mid.(int64)))
+}
+
+// ystVipInfo implementation
+func ystVipInfo(ctx *bm.Context) {
+	req := new(tvmdl.YstUserInfoReq)
+	if err := ctx.BindWith(req, binding.Query); err != nil {
+		ystRender(ctx, ystErrResp(ystErrBadRequest, err.Error()))
+		return
+	}
+	res, err := tvVipSvc.YstVipInfo(ctx, req.Mid, req.Sign)
+	if err != nil && ecode.EqualError(ecode.NothingFound, err) {
+		ystRender(ctx, ystErrResp(ystErrNotFound, err.Error()))
+		return
+	}
+	if err != nil && ecode.EqualError(ecode.TVIPSignErr, err) {
+		ystRender(ctx, ystErrResp(ystErrBadRequest, "SignErr"))
+		return
+	}
+	if err != nil {
+		ystRender(ctx, ystErrResp(ystErrInternalErr, err.Error()))
+		return
+	}
+	data := map[string]interface{}{
+		"mid":            res.Mid,
+		"status":         res.Status,
+		"overdue_time":   res.OverdueTime,
+		"pay_channel_id": res.PayChannelId,
+		"vip_type":       res.VipType,
+		"pay_type":       res.PayType,
+		"result":         res.Result,
+		"msg":            res.Msg,
+	}
+	ctx.Render(http.StatusOK, render.MapJSON(data))
+}
+
+// PanelInfo .
+func panelInfo(ctx *bm.Context) {
+	mid, ok := ctx.Get("mid")
+	if !ok {
+		ctx.JSON(nil, ecode.NoLogin)
+		return
+	}
+	res, err := tvVipSvc.PanelInfo(ctx, mid.(int64))
+	if err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	ctx.JSON(res.PriceConfigs, err)
+}
+
+func guestPanelInfo(ctx *bm.Context) {
+	res, err := tvVipSvc.GuestPanelInfo(ctx)
+	if err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	ctx.JSON(res.PriceConfigs, err)
+}
+
+func createQr(ctx *bm.Context) {
+	req := new(tvmdl.CreateQrReq)
+	if err := ctx.Bind(req); err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	if req.AppChannel == "" {
+		log.Warn("createQr(%+v), msg(EmptyAppChannel)", req)
+	}
+	buvid := ctx.Request.Header.Get("buvid")
+	if buvid == "" {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	req.Guid = buvid
+	res, err := tvVipSvc.CreateQr(ctx, req)
+	ctx.JSON(res, err)
+}
+
+func createGuestQr(ctx *bm.Context) {
+	req := new(tvmdl.CreateGuestQrReq)
+	if err := ctx.Bind(req); err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	if req.AppChannel == "" {
+		log.Warn("createQr(%+v), msg(EmptyAppChannel)", req)
+	}
+	buvid := ctx.Request.Header.Get("buvid")
+	if buvid == "" {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	req.Guid = buvid
+	res, err := tvVipSvc.CreateGuestQr(ctx, req)
+	ctx.JSON(res, err)
+}
+
+func createOrder(ctx *bm.Context) {
+	var (
+		err error
+	)
+	req := new(tvmdl.CreateOrderReq)
+	if err = ctx.Bind(req); err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	if req.Platform, err = platformFromUA(ctx); err != nil {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if req.PaymentType, err = payTypeFromUA(ctx); err != nil {
+		ctx.Redirect(302, errPage(err))
+		return
+	}
+	ip := metadata.String(ctx, metadata.RemoteIP)
+	if ip == "" {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	res, err := tvVipSvc.CreateOrder(ctx, ip, req)
+	if err != nil {
+		ctx.Redirect(302, errPage(err))
+		return
+	}
+	ctx.Redirect(302, res.CodeUrl)
+}
+
+func createGuestOrder(ctx *bm.Context) {
+	var (
+		err error
+	)
+	mid, ok := ctx.Get("mid")
+	if !ok {
+		ctx.JSON(nil, ecode.NoLogin)
+		return
+	}
+	req := new(tvmdl.CreateGuestOrderReq)
+	if err = ctx.Bind(req); err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	if req.Platform, err = platformFromUA(ctx); err != nil {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if req.PaymentType, err = payTypeFromUA(ctx); err != nil {
+		ctx.Redirect(302, errPage(err))
+		return
+	}
+	ip := metadata.String(ctx, metadata.RemoteIP)
+	if ip == "" {
+		ctx.JSON(nil, ecode.RequestErr)
+		return
+	}
+	res, err := tvVipSvc.CreateGuestOrder(ctx, mid.(int64), ip, req)
+	if err != nil {
+		ctx.Redirect(302, errPage(err))
+		return
+	}
+	ctx.Redirect(302, res.CodeUrl)
+}
+
+func tokenStatus(ctx *bm.Context) {
+	query := ctx.Request.URL.Query()
+	tokens := query["token"]
+	res, err := tvVipSvc.TokenInfo(ctx, tokens)
+	if err != nil {
+		ctx.JSON(nil, err)
+		return
+	}
+	ctx.JSON(res.Tokens, err)
+}
+
+func payCallback(ctx *bm.Context) {
+	ip := metadata.String(ctx, metadata.RemoteIP)
+	if !isIpValid(ip) {
+		log.Error("payCallback(%s) err(InvalidIP)", ip)
+		ystRender(ctx, ystErrResp(ystErrBadRequest, "InvalidIP"))
+		return
+	}
+	req := new(tvmdl.YstPayCallbackReq)
+	if err := ctx.BindWith(req, binding.JSON); err != nil {
+		ystRender(ctx, ystErrResp(ystErrBadRequest, err.Error()))
+		return
+	}
+	res := tvVipSvc.PayCallback(ctx, req)
+	data := map[string]interface{}{
+		"traceno": res.TraceNo,
+		"result":  res.Result,
+		"msg":     res.Msg,
+	}
+	ystRender(ctx, data)
+}
+
+func wxContractCallback(ctx *bm.Context) {
+	req := new(tvmdl.WxContractCallbackReq)
+	if err := ctx.BindWith(req, binding.JSON); err != nil {
+		ystRender(ctx, ystErrResp(ystErrBadRequest, err.Error()))
+		return
+	}
+	res := tvVipSvc.WxContractCallback(ctx, req)
+	data := map[string]interface{}{
+		"contract_id": res.ContractId,
+		"result":      res.Result,
+		"msg":         res.Msg,
+	}
+	ystRender(ctx, data)
+}

app/interface/main/tv/http/ugc.go

@@ -0,0 +1,24 @@
+package http
+
+import (
+	"go-common/app/interface/main/tv/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+//ugcPlayurl is used for getting ugc play url
+func ugcPlayurl(c *bm.Context) {
+	var (
+		err error
+		mid int64
+	)
+	param := new(model.PlayURLReq)
+	if err = c.Bind(param); err != nil {
+		return
+	}
+	if param.AccessKey != "" {
+		if cmid, ok := c.Get("mid"); ok {
+			mid = cmid.(int64)
+		}
+	}
+	c.JSONMap(gobSvc.UgcPlayurl(c, param, mid))
+}

app/interface/main/tv/http/ugc_view.go

@@ -0,0 +1,42 @@
+package http
+
+import (
+	"time"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/metadata"
+)
+
+// viewPage view page handler.
+func view(c *bm.Context) {
+	var (
+		v = new(struct {
+			AID       int64  `form:"aid" validate:"required,min=1"`
+			AccessKey string `form:"access_key"`
+		})
+		mid int64
+	)
+	if err := c.Bind(v); err != nil {
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	// view
+	now := time.Now()
+	view, isok, errMsg, err := viewSvc.View(c, mid, v.AID, v.AccessKey, metadata.String(c, metadata.RemoteIP), now)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	// err msg logic
+	if !isok {
+		c.JSONMap(map[string]interface{}{
+			"data":    isok,
+			"message": errMsg,
+		}, ecode.CopyrightLimit)
+		return
+	}
+	c.JSON(view, nil)
+}

app/interface/main/tv/http/upgrade.go

@@ -0,0 +1,64 @@
+package http
+
+import (
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+var (
+	getForm = map[string]bool{
+		"mobi_app": true,
+		"build":    true,
+		"channel":  true,
+		"seed":     true,
+		"sdkint":   false,
+		"model":    false,
+		"old_id":   false,
+	}
+)
+
+func validatePostData(c *bm.Context, params map[string]bool) bool {
+	for k, v := range params {
+		if v {
+			if c.Request.Form.Get(k) == "" {
+				log.Error("The field is required(%s)", k)
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func upgrade(c *bm.Context) {
+	var (
+		req = c.Request.Form
+		ver = &model.VerUpdate{
+			MobiApp: req.Get("mobi_app"),
+			Build:   int(parseInt(req.Get("build"))),
+			Channel: req.Get("channel"),
+			Seed:    int(parseInt(req.Get("seed"))),
+			Sdkint:  int(parseInt(req.Get("sdkint"))),
+			Model:   req.Get("model"),
+			OldID:   req.Get("old_id"),
+		}
+	)
+	if !validatePostData(c, getForm) {
+		c.JSONMap(map[string]interface{}{
+			"code":    ecode.RequestErr,
+			"message": "lack of fields",
+		}, nil)
+		return
+	}
+	result, errCode, err := gobSvc.VerUpdate(c, ver)
+	if err != nil {
+		log.Error("[VerUpdate] Load App Upgrade Data, Err: %v", err)
+		c.JSONMap(map[string]interface{}{
+			"code":    errCode,
+			"message": "load data fail",
+		}, nil)
+		return
+	}
+	c.JSON(result, nil)
+}

app/interface/main/tv/http/wild.go

@@ -0,0 +1,105 @@
+package http
+
+import (
+	mdlSearch "go-common/app/interface/main/tv/model/search"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+const (
+	_headerBuvid = "Buvid"
+	_keyWordLen  = 50
+)
+
+// searchAll all search .
+func searchAll(c *bm.Context) {
+	var (
+		err    error
+		v      = new(mdlSearch.UserSearch)
+		header = c.Request.Header
+	)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if v.Keyword == "" || len([]rune(v.Keyword)) > _keyWordLen {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if v.Order == "" {
+		v.Order = "totalrank"
+	}
+	if v.Page < 1 {
+		v.Page = 1
+	}
+	if v.Pagesize < 1 || v.Pagesize > 20 {
+		v.Pagesize = 20
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		v.MID = midInter.(int64)
+	}
+	v.Buvid = header.Get(_headerBuvid)
+	c.JSON(secSvc.SearchAll(c, v))
+}
+
+// userSearch search by user .
+func userSearch(c *bm.Context) {
+	var (
+		err    error
+		v      = new(mdlSearch.UserSearch)
+		header = c.Request.Header
+	)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if v.Order == "" {
+		v.Order = "totalrank"
+	}
+	if v.Order != "totalrank" && v.Order != "fans" && v.Order != "level" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if v.OrderSort != 1 {
+		v.OrderSort = 0
+	}
+	if v.FromSource == "" {
+		v.FromSource = "app_search"
+	}
+	if v.Page < 1 {
+		v.Page = 1
+	}
+	if v.Pagesize < 1 || v.Pagesize > 20 {
+		v.Pagesize = 20
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		v.MID = midInter.(int64)
+	}
+	v.Buvid = header.Get(_headerBuvid)
+	c.JSON(secSvc.UserSearch(c, v))
+}
+
+// pgcSearch search pgc opera and film .
+func pgcSearch(c *bm.Context) {
+	var (
+		err    error
+		v      = new(mdlSearch.UserSearch)
+		header = c.Request.Header
+	)
+	if err = c.Bind(v); err != nil {
+		return
+	}
+	if v.Keyword == "" || len([]rune(v.Keyword)) > _keyWordLen {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if v.Page < 1 {
+		v.Page = 1
+	}
+	if v.Pagesize < 1 || v.Pagesize > 20 {
+		v.Pagesize = 20
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		v.MID = midInter.(int64)
+	}
+	v.Buvid = header.Get(_headerBuvid)
+	c.JSON(secSvc.PgcSearch(c, v))
+}

app/interface/main/tv/http/zone_index.go

@@ -0,0 +1,37 @@
+package http
+
+import (
+	"go-common/app/interface/main/tv/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func zoneIdx(c *bm.Context) {
+	var (
+		req     = c.Request.Form
+		typeStr string
+		typeV   int
+		pageStr string
+		pageV   int
+	)
+	takeBuild(req) // take build number
+	if typeStr = req.Get("season_type"); typeStr == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	typeV = atoi(typeStr)
+	if pageStr = req.Get("page"); pageStr == "" {
+		pageV = 1
+	} else {
+		pageV = atoi(pageStr)
+	}
+	seasons, pager, err := tvSvc.LoadZoneIdx(pageV, typeV)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(model.IdxData{
+		List:  seasons,
+		Pager: pager,
+	}, nil)
+}