Create & Init Project...

app/interface/main/app-resource/http/BUILD

@@ -0,0 +1,73 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "abtest.go",
+        "audit.go",
+        "broadcast.go",
+        "domain.go",
+        "http.go",
+        "interest.go",
+        "local.go",
+        "module.go",
+        "notice.go",
+        "param.go",
+        "plugin.go",
+        "show.go",
+        "sidebar.go",
+        "splash.go",
+        "static.go",
+        "version.go",
+        "white.go",
+    ],
+    importpath = "go-common/app/interface/main/app-resource/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-resource/conf:go_default_library",
+        "//app/interface/main/app-resource/model:go_default_library",
+        "//app/interface/main/app-resource/model/module:go_default_library",
+        "//app/interface/main/app-resource/model/version:go_default_library",
+        "//app/interface/main/app-resource/service/abtest:go_default_library",
+        "//app/interface/main/app-resource/service/audit:go_default_library",
+        "//app/interface/main/app-resource/service/broadcast:go_default_library",
+        "//app/interface/main/app-resource/service/domain:go_default_library",
+        "//app/interface/main/app-resource/service/guide:go_default_library",
+        "//app/interface/main/app-resource/service/module:go_default_library",
+        "//app/interface/main/app-resource/service/notice:go_default_library",
+        "//app/interface/main/app-resource/service/param:go_default_library",
+        "//app/interface/main/app-resource/service/ping:go_default_library",
+        "//app/interface/main/app-resource/service/plugin:go_default_library",
+        "//app/interface/main/app-resource/service/show:go_default_library",
+        "//app/interface/main/app-resource/service/sidebar:go_default_library",
+        "//app/interface/main/app-resource/service/splash:go_default_library",
+        "//app/interface/main/app-resource/service/static:go_default_library",
+        "//app/interface/main/app-resource/service/version:go_default_library",
+        "//app/interface/main/app-resource/service/white:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/auth:go_default_library",
+        "@com_github_golang_protobuf//proto: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/app-resource/http/abtest.go

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func abTest(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(abSvc.Experiment(c, plat, build), nil)
+}
+
+func abTestV2(c *bm.Context) {
+	params := c.Request.Form
+	buvid := params.Get("buvid")
+	if buvid == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(abSvc.TemporaryABTests(c, buvid), nil)
+}
+
+func abserver(c *bm.Context) {
+	params := c.Request.Form
+	buvid := params.Get("buvid")
+	device := params.Get("device")
+	mobiAPP := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	filteredStr := params.Get("filtered")
+	if buvid == "" || device == "" || mobiAPP == "" || buildStr == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var mid int64
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	c.JSON(abSvc.AbServer(c, buvid, device, mobiAPP, filteredStr, build, mid))
+}

app/interface/main/app-resource/http/audit.go

@@ -0,0 +1,22 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func audit(c *bm.Context) {
+	params := c.Request.Form
+	buildStr := params.Get("build")
+	mobiApp := params.Get("mobi_app")
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		log.Error("stronv.ParseInt(%s) error(%v)", buildStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, auditSvc.Audit(c, mobiApp, build))
+}

app/interface/main/app-resource/http/broadcast.go

@@ -0,0 +1,14 @@
+package http
+
+import (
+	"go-common/app/interface/main/app-resource/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func serverList(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	c.JSON(broadcastSvc.ServerList(c, plat))
+}

app/interface/main/app-resource/http/domain.go

@@ -0,0 +1,7 @@
+package http
+
+import bm "go-common/library/net/http/blademaster"
+
+func domain(c *bm.Context) {
+	c.JSON(domainSvc.Domain(), nil)
+}

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

@@ -0,0 +1,158 @@
+package http
+
+import (
+	"go-common/app/interface/main/app-resource/conf"
+	absvr "go-common/app/interface/main/app-resource/service/abtest"
+	auditsvr "go-common/app/interface/main/app-resource/service/audit"
+	broadcastsvr "go-common/app/interface/main/app-resource/service/broadcast"
+	domainsvr "go-common/app/interface/main/app-resource/service/domain"
+	guidesvc "go-common/app/interface/main/app-resource/service/guide"
+	modulesvr "go-common/app/interface/main/app-resource/service/module"
+	"go-common/app/interface/main/app-resource/service/notice"
+	"go-common/app/interface/main/app-resource/service/param"
+	pingsvr "go-common/app/interface/main/app-resource/service/ping"
+	pluginsvr "go-common/app/interface/main/app-resource/service/plugin"
+	showsvr "go-common/app/interface/main/app-resource/service/show"
+	sidesvr "go-common/app/interface/main/app-resource/service/sidebar"
+	"go-common/app/interface/main/app-resource/service/splash"
+	staticsvr "go-common/app/interface/main/app-resource/service/static"
+	"go-common/app/interface/main/app-resource/service/version"
+	whitesvr "go-common/app/interface/main/app-resource/service/white"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/auth"
+)
+
+var (
+	// depend service
+	authSvc *auth.Auth
+	// self service
+	pgSvr        *pluginsvr.Service
+	pingSvr      *pingsvr.Service
+	sideSvr      *sidesvr.Service
+	verSvc       *version.Service
+	paramSvc     *param.Service
+	ntcSvc       *notice.Service
+	splashSvc    *splash.Service
+	auditSvc     *auditsvr.Service
+	abSvc        *absvr.Service
+	moduleSvc    *modulesvr.Service
+	guideSvc     *guidesvc.Service
+	staticSvc    *staticsvr.Service
+	domainSvc    *domainsvr.Service
+	whiteSvc     *whitesvr.Service
+	showSvc      *showsvr.Service
+	broadcastSvc *broadcastsvr.Service
+)
+
+type Server struct {
+	// depend service
+	AuthSvc *auth.Auth
+	// self service
+	PgSvr        *pluginsvr.Service
+	PingSvr      *pingsvr.Service
+	SideSvr      *sidesvr.Service
+	VerSvc       *version.Service
+	ParamSvc     *param.Service
+	NtcSvc       *notice.Service
+	SplashSvc    *splash.Service
+	AuditSvc     *auditsvr.Service
+	AbSvc        *absvr.Service
+	ModuleSvc    *modulesvr.Service
+	GuideSvc     *guidesvc.Service
+	StaticSvc    *staticsvr.Service
+	DomainSvc    *domainsvr.Service
+	WhiteSvc     *whitesvr.Service
+	ShowSvc      *showsvr.Service
+	BroadcastSvc *broadcastsvr.Service
+}
+
+// Init is
+func Init(c *conf.Config, svr *Server) {
+	initService(c, svr)
+	// init external router
+	engineOut := bm.DefaultServer(c.BM.Outer)
+	outerRouter(engineOut)
+	// init Outer server
+	if err := engineOut.Start(); err != nil {
+		log.Error("engineOut.Start() error(%v) | config(%v)", err, c)
+		panic(err)
+	}
+}
+
+// initService init services.
+func initService(c *conf.Config, svr *Server) {
+	// init self service
+	authSvc = svr.AuthSvc
+	pgSvr = svr.PgSvr
+	pingSvr = svr.PingSvr
+	sideSvr = svr.SideSvr
+	verSvc = svr.VerSvc
+	paramSvc = svr.ParamSvc
+	ntcSvc = svr.NtcSvc
+	splashSvc = svr.SplashSvc
+	auditSvc = svr.AuditSvc
+	abSvc = svr.AbSvc
+	moduleSvc = svr.ModuleSvc
+	guideSvc = svr.GuideSvc
+	staticSvc = svr.StaticSvc
+	domainSvc = svr.DomainSvc
+	broadcastSvc = svr.BroadcastSvc
+	whiteSvc = svr.WhiteSvc
+	showSvc = svr.ShowSvc
+}
+
+// outerRouter init outer router api path.
+func outerRouter(e *bm.Engine) {
+	e.Ping(ping)
+	r := e.Group("/x/resource")
+	{
+		r.GET("/plugin", plugin)
+		r.GET("/sidebar", authSvc.GuestMobile, sidebar)
+		r.GET("/topbar", topbar)
+		r.GET("/abtest", abTest)
+		r.GET("/abtest/v2", abTestV2)
+		r.GET("/abtest/abserver", authSvc.GuestMobile, abserver)
+		m := r.Group("/module")
+		{
+			m.POST("", module)
+			m.POST("/list", list)
+		}
+		g := r.Group("/guide", authSvc.GuestMobile)
+		{
+			g.GET("/interest", interest)
+			g.GET("/interest2", interest2)
+		}
+		r.GET("/static", getStatic)
+		r.GET("/domain", domain)
+		r.GET("/broadcast/servers", serverList)
+		r.GET("/white/list", whiteList)
+		r.GET("/show/tab", authSvc.GuestMobile, tabs)
+	}
+	v := e.Group("/x/v2/version")
+	{
+		v.GET("", getVersion)
+		v.GET("/update", versionUpdate)
+		v.GET("/update.pb", versionUpdatePb)
+		v.GET("/so", versionSo)
+		v.GET("/rn/update", versionRn)
+	}
+	p := e.Group("/x/v2/param", authSvc.GuestMobile)
+	{
+		p.GET("", getParam)
+	}
+	n := e.Group("/x/v2/notice", authSvc.GuestMobile)
+	{
+		n.GET("", getNotice)
+	}
+	s := e.Group("/x/v2/splash")
+	{
+		s.GET("", splashs)
+		s.GET("/birthday", birthSplash)
+		s.GET("/list", authSvc.GuestMobile, splashList)
+	}
+	a := e.Group("/x/v2/audit")
+	{
+		a.GET("", audit)
+	}
+}

app/interface/main/app-resource/http/interest.go

@@ -0,0 +1,48 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+const (
+	_headerBuvid    = "Buvid"
+	_headerDeviceID = "Device-ID"
+)
+
+// interest get interest list
+func interest(c *bm.Context) {
+	var (
+		header = c.Request.Header
+		params = c.Request.Form
+	)
+	mobiApp := params.Get("mobi_app")
+	buvid := header.Get(_headerBuvid)
+	c.JSON(guideSvc.Interest(mobiApp, buvid, time.Now()), nil)
+}
+
+// interest2 get interest list
+func interest2(c *bm.Context) {
+	var (
+		header = c.Request.Header
+		params = c.Request.Form
+	)
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	buildStr := params.Get("build")
+	buvid := header.Get(_headerBuvid)
+	if buvid == "" || len(buvid) <= 5 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	dvcid := header.Get(_headerDeviceID)
+	c.JSON(guideSvc.Interest2(mobiApp, device, dvcid, buvid, build, time.Now()), nil)
+}

app/interface/main/app-resource/http/local.go

@@ -0,0 +1,17 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// ping check server ok.
+func ping(c *bm.Context) {
+	var err error
+	if err = pingSvr.Ping(c); err != nil {
+		log.Error("app-resource service ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

app/interface/main/app-resource/http/module.go

@@ -0,0 +1,83 @@
+package http
+
+import (
+	"encoding/json"
+	"strconv"
+	"time"
+
+	mdl "go-common/app/interface/main/app-resource/model/module"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func list(c *bm.Context) {
+	var (
+		params                            = c.Request.Form
+		build, sysver, level, scale, arch int
+		err                               error
+		env                               string
+	)
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	platform := params.Get("platform")
+	env = params.Get("env")
+	if env != mdl.EnvRelease && env != mdl.EnvTest && env != mdl.EnvDefault {
+		env = mdl.EnvRelease
+	}
+	build, _ = strconv.Atoi(params.Get("build"))
+	sysver, _ = strconv.Atoi(params.Get("sysver"))
+	level, _ = strconv.Atoi(params.Get("level"))
+	scale, _ = strconv.Atoi(params.Get("scale"))
+	arch, _ = strconv.Atoi(params.Get("arch"))
+	rPoolName := params.Get("resource_pool_name")
+	// NOTE: don't ask way rPoolName coded "pink", idiot demand! fuck!!!
+	// rPoolName := "pink"
+	// params
+	verlist := params.Get("verlist")
+	var versions []*mdl.Versions
+	if verlist != "" {
+		if err = json.Unmarshal([]byte(verlist), &versions); err != nil {
+			log.Error("http list() json.Unmarshal(%s) mobile_app(%s) device(%s) build(%d) error(%v)", verlist, mobiApp, device, build, err)
+		}
+	}
+	data := moduleSvc.List(c, mobiApp, device, platform, rPoolName, env, build, sysver, level, scale, arch, versions, time.Now())
+	c.JSON(data, nil)
+}
+
+func module(c *bm.Context) {
+	var (
+		params                            = c.Request.Form
+		build, sysver, level, scale, arch int
+		err                               error
+		env                               string
+	)
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	platform := params.Get("platform")
+	env = params.Get("env")
+	if env != mdl.EnvRelease && env != mdl.EnvTest && env != mdl.EnvDefault {
+		env = mdl.EnvRelease
+	}
+	build, _ = strconv.Atoi(params.Get("build"))
+	sysver, _ = strconv.Atoi(params.Get("sysver"))
+	level, _ = strconv.Atoi(params.Get("level"))
+	scale, _ = strconv.Atoi(params.Get("scale"))
+	arch, _ = strconv.Atoi(params.Get("arch"))
+	rPoolName := params.Get("resource_pool_name")
+	// NOTE: don't ask way rPoolName coded "pink", idiot demand! fuck!!!
+	// rPoolName := "pink"
+	rName := params.Get("resource_name")
+	verStr := params.Get("ver")
+	ver, _ := strconv.Atoi(verStr)
+	if rPoolName == "" || rName == "" {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	data, err := moduleSvc.Resource(c, mobiApp, device, platform, rPoolName, rName, env, ver, build, sysver, level, scale, arch, time.Now())
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(data, nil)
+}

app/interface/main/app-resource/http/notice.go

@@ -0,0 +1,37 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// getNotice get notice data.
+func getNotice(c *bm.Context) {
+	params := c.Request.Form
+	ver := params.Get("ver")
+	buildStr := params.Get("build")
+	mobiApp := params.Get("mobi_app")
+	mobiApp = model.MobiAPPBuleChange(mobiApp)
+	typeStr := params.Get("type")
+	// check params
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		log.Error("stronv.ParseInt(%s) error(%v)", buildStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	typeInt, _ := strconv.Atoi(typeStr)
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	// get
+	data, version, err := ntcSvc.Notice(c, plat, build, typeInt, ver)
+	res := map[string]interface{}{
+		"data": data,
+		"ver":  version,
+	}
+	c.JSONMap(res, err)
+}

app/interface/main/app-resource/http/param.go

@@ -0,0 +1,47 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// getParam get param data.
+func getParam(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	platStr := params.Get("plat")
+	ver := params.Get("ver")
+	buildStr := params.Get("build")
+	// check params
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		log.Error("stronv.ParseInt(%s) error(%v)", buildStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var plat int8
+	if mobiApp != "" {
+		device := params.Get("device")
+		plat = model.Plat(mobiApp, device)
+	} else if platStr != "" { // android have not mobi_app when 4.18
+		var platInt int64
+		platInt, err = strconv.ParseInt(platStr, 10, 64)
+		if err != nil {
+			log.Error("stronv.ParseInt(%s) error(%v)", platStr, err)
+			c.JSON(nil, ecode.RequestErr)
+			return
+		}
+		plat = int8(platInt)
+	}
+	// service
+	data, version, err := paramSvc.Param(plat, build, ver)
+	res := map[string]interface{}{
+		"data": data,
+		"ver":  version,
+	}
+	c.JSONMap(res, err)
+}

app/interface/main/app-resource/http/plugin.go

@@ -0,0 +1,40 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func plugin(c *bm.Context) {
+	var (
+		params   = c.Request.Form
+		build    int
+		baseCode int
+		seed     int
+		err      error
+	)
+	name := params.Get("name")
+	buildStr := params.Get("build")
+	baseCodeStr := params.Get("base_code")
+	seedStr := params.Get("seed")
+	if build, err = strconv.Atoi(buildStr); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if seed, err = strconv.Atoi(seedStr); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if baseCode, err = strconv.Atoi(baseCodeStr); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if pg := pgSvr.Plugin(build, baseCode, seed, name); pg != nil {
+		c.JSON(pg, nil)
+	} else {
+		c.JSON(struct{}{}, nil)
+	}
+
+}

app/interface/main/app-resource/http/show.go

@@ -0,0 +1,40 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func tabs(c *bm.Context) {
+	var (
+		params = c.Request.Form
+		header = c.Request.Header
+		res    = map[string]interface{}{}
+	)
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	buvid := header.Get(_headerBuvid)
+	device := params.Get("device")
+	verStr := params.Get("ver")
+	language := params.Get("lang")
+	plat := model.Plat(mobiApp, device)
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	var mid int64
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	data, version, ab, err := showSvc.Tabs(c, plat, build, buvid, verStr, mobiApp, language, mid)
+	if ab != nil {
+		res["abtest"] = ab
+	}
+	res["data"] = data
+	res["ver"] = version
+	c.JSONMap(res, err)
+}

app/interface/main/app-resource/http/sidebar.go

@@ -0,0 +1,67 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func sidebar(c *bm.Context) {
+	var (
+		params = c.Request.Form
+		module int
+		mid    int64
+	)
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	device := params.Get("device")
+	language := params.Get("lang")
+	plat := model.Plat(mobiApp, device)
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	switch plat {
+	case model.PlatAndroid, model.PlatAndroidG, model.PlatAndroidB, model.PlatAndroidI:
+		module = 1
+	case model.PlatIPhone, model.PlatIPhoneI, model.PlatIPhoneB:
+		module = 3
+	}
+	c.JSON(sideSvr.SideBar(c, plat, build, module, mid, language), nil)
+}
+
+func topbar(c *bm.Context) {
+	var (
+		params = c.Request.Form
+		module int
+		mid    int64
+	)
+	mobiApp := params.Get("mobi_app")
+	buildStr := params.Get("build")
+	device := params.Get("device")
+	language := params.Get("lang")
+	plat := model.Plat(mobiApp, device)
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	switch plat {
+	case model.PlatAndroid, model.PlatAndroidG, model.PlatAndroidB, model.PlatAndroidI:
+		module = 2
+	case model.PlatIPhone, model.PlatIPhoneI, model.PlatIPhoneB:
+		module = 4
+	case model.PlatIPad, model.PlatIPadI:
+		module = 5
+	}
+	c.JSON(sideSvr.SideBar(c, plat, build, module, mid, language), nil)
+}

app/interface/main/app-resource/http/splash.go

@@ -0,0 +1,120 @@
+package http
+
+import (
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// splashs splash handler
+func splashs(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	mobiApp = model.MobiAPPBuleChange(mobiApp)
+	widthStr := params.Get("width")
+	heightStr := params.Get("height")
+	buildStr := params.Get("build")
+	channel := params.Get("channel")
+	ver := params.Get("ver")
+	// check params
+	width, err := strconv.Atoi(widthStr)
+	if err != nil {
+		log.Error("width(%s) is invalid", widthStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	height, err := strconv.Atoi(heightStr)
+	if err != nil {
+		log.Error("height(%s) is invalid", heightStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	build, _ := strconv.Atoi(buildStr)
+	device := params.Get("device")
+	var plat int8
+	if mobiApp != "" {
+		plat = model.Plat(mobiApp, device)
+	} else {
+		plat = model.PlatAndroid
+	}
+	result, version, err := splashSvc.Display(c, plat, width, height, int(build), channel, ver, time.Now())
+	res := map[string]interface{}{
+		"data": result,
+		"ver":  version,
+	}
+	c.JSONMap(res, err)
+}
+
+func birthSplash(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	mobiApp = model.MobiAPPBuleChange(mobiApp)
+	widthStr := params.Get("width")
+	heightStr := params.Get("height")
+	year := params.Get("year")
+	birth := params.Get("birth")
+	if year == "1930" && birth == "0101" {
+		log.Error("birth day is empty(%s,%s)", year, birth)
+		c.JSON(nil, ecode.NothingFound)
+		return
+	}
+	// check params
+	width, err := strconv.Atoi(widthStr)
+	if err != nil {
+		log.Error("width(%s) is invalid", widthStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	height, err := strconv.Atoi(heightStr)
+	if err != nil {
+		log.Error("height(%s) is invalid", heightStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	result, err := splashSvc.Birthday(c, plat, width, height, birth)
+	c.JSON(result, err)
+}
+
+// splashList ad splash handler
+func splashList(c *bm.Context) {
+	var (
+		header = c.Request.Header
+		params = c.Request.Form
+	)
+	mobiApp := params.Get("mobi_app")
+	mobiApp = model.MobiAPPBuleChange(mobiApp)
+	widthStr := params.Get("width")
+	heightStr := params.Get("height")
+	buildStr := params.Get("build")
+	birth := params.Get("birth")
+	adExtra := params.Get("ad_extra")
+	device := params.Get("device")
+	// check params
+	width, err := strconv.Atoi(widthStr)
+	if err != nil {
+		log.Error("width(%s) is invalid", widthStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	height, err := strconv.Atoi(heightStr)
+	if err != nil {
+		log.Error("height(%s) is invalid", heightStr)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	build, _ := strconv.Atoi(buildStr)
+	var mid int64
+	if midInter, ok := c.Get("mid"); ok {
+		mid = midInter.(int64)
+	}
+	buvid := header.Get(_headerBuvid)
+	plat := model.Plat(mobiApp, device)
+	result, err := splashSvc.AdList(c, plat, mobiApp, device, buvid, birth, adExtra, height, width, build, mid)
+	c.JSON(result, err)
+}

app/interface/main/app-resource/http/static.go

@@ -0,0 +1,32 @@
+package http
+
+import (
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"strconv"
+	"time"
+)
+
+// getStatic get static
+func getStatic(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	ver := params.Get("ver")
+	buildStr := params.Get("build")
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		log.Error("build(%s) error(%v)", buildStr, err)
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	plat := model.Plat(mobiApp, device)
+	data, version, err := staticSvc.Static(plat, build, ver, time.Now())
+	res := map[string]interface{}{
+		"data": data,
+		"ver":  version,
+	}
+	c.JSONMap(res, err)
+}

app/interface/main/app-resource/http/version.go

@@ -0,0 +1,137 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/interface/main/app-resource/model"
+	"go-common/app/interface/main/app-resource/model/version"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+
+	"github.com/golang/protobuf/proto"
+)
+
+// getVersion get version
+func getVersion(c *bm.Context) {
+	params := c.Request.Form
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	data, err := verSvc.Version(plat)
+	c.JSON(data, err)
+}
+
+// versionUpdate get versionUpdate
+func versionUpdate(c *bm.Context) {
+	var (
+		params = c.Request.Form
+		header = c.Request.Header
+	)
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	buildStr := params.Get("build")
+	channel := params.Get("channel")
+	sdkStr := params.Get("sdkint")
+	platModel := params.Get("model")
+	oldID := params.Get("old_id")
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	buvid := header.Get(_headerBuvid)
+	// mobiApp not equal to android or mobiApp is null,default android
+	if !model.IsAndroid(plat) {
+		plat = model.PlatAndroid
+	}
+	if (plat == model.PlatAndroid) && (build >= 591000 && build <= 599000) {
+		plat = model.PlatAndroidB
+	}
+	data, err := verSvc.VersionUpdate(build, plat, buvid, sdkStr, channel, platModel, oldID)
+	if err != nil {
+		c.JSON(nil, ecode.NotModified)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+// versionUpdate get versionUpdate
+func versionUpdatePb(c *bm.Context) {
+	var (
+		params = c.Request.Form
+		header = c.Request.Header
+	)
+	mobiApp := params.Get("mobi_app")
+	device := params.Get("device")
+	plat := model.Plat(mobiApp, device)
+	buildStr := params.Get("build")
+	channel := params.Get("channel")
+	sdkStr := params.Get("sdkint")
+	platModel := params.Get("model")
+	oldID := params.Get("old_id")
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	buvid := header.Get(_headerBuvid)
+	// mobiApp not equal to android or mobiApp is null,default android
+	if !model.IsAndroid(plat) {
+		plat = model.PlatAndroid
+	}
+	data, err := verSvc.VersionUpdate(build, plat, buvid, sdkStr, channel, platModel, oldID)
+	if err != nil {
+		c.JSON(nil, ecode.NotModified)
+		return
+	}
+	size, _ := strconv.Atoi(data.Size)
+	resPb := &version.VerUpdate{
+		Ver:     *proto.String(data.Version),
+		Build:   *proto.Int(data.Build),
+		Info:    *proto.String(data.Desc),
+		Size:    *proto.Int(size),
+		Url:     *proto.String(data.Url),
+		Hash:    *proto.String(data.MD5),
+		Policy:  *proto.Int(data.Policy),
+		IsForce: *proto.Int(data.IsForce),
+		Mtime:   *proto.Int64(data.Mtime.Time().Unix()),
+	}
+	c.JSON(resPb, nil)
+}
+
+func versionSo(c *bm.Context) {
+	params := c.Request.Form
+	name := params.Get("name")
+	seedStr := params.Get("seed")
+	buildStr := params.Get("build")
+	sdkStr := params.Get("sdkint")
+	model := params.Get("model")
+	seed, err := strconv.Atoi(seedStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	build, err := strconv.Atoi(buildStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	sdkint, _ := strconv.Atoi(sdkStr)
+	data, err := verSvc.VersionSo(build, seed, sdkint, name, model)
+	if err != nil {
+		c.JSON(nil, ecode.NotModified)
+		return
+	}
+	c.JSON(data, nil)
+}
+
+// versionRn get versionUpdate
+func versionRn(c *bm.Context) {
+	params := c.Request.Form
+	deploymentKey := params.Get("deployment_key")
+	bundleID := params.Get("bundle_id")
+	version := params.Get("base_version")
+	data, err := verSvc.VersionRn(version, deploymentKey, bundleID)
+	c.JSON(data, err)
+}

app/interface/main/app-resource/http/white.go

@@ -0,0 +1,7 @@
+package http
+
+import bm "go-common/library/net/http/blademaster"
+
+func whiteList(c *bm.Context) {
+	c.JSON(whiteSvc.List(), nil)
+}