Create & Init Project...

app/service/live/userexp/http/BUILD

@@ -0,0 +1,54 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "exp.go",
+        "http.go",
+    ],
+    importpath = "go-common/app/service/live/userexp/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/userexp/conf:go_default_library",
+        "//app/service/live/userexp/model:go_default_library",
+        "//app/service/live/userexp/service:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/xstr:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["http_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/live/userexp/conf:go_default_library",
+        "//app/service/live/userexp/model:go_default_library",
+        "//app/service/live/userexp/service:go_default_library",
+        "//library/net/http/blademaster: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/service/live/userexp/http/exp.go

@@ -0,0 +1,112 @@
+package http
+
+import (
+	"go-common/app/service/live/userexp/conf"
+	"go-common/app/service/live/userexp/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/xstr"
+	"strconv"
+)
+
+func level(c *bm.Context) {
+	uidStr := c.Request.Form.Get("uid")
+	// check params
+	uid, err := strconv.ParseInt(uidStr, 10, 64)
+	if err != nil || uid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(expSvr.Level(c, uid))
+}
+
+func multiGetLevel(c *bm.Context) {
+	uidsStr := c.Request.Form.Get("uids")
+	// check params
+	uids, err := xstr.SplitInts(uidsStr)
+	if err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	levels, err := expSvr.MultiGetLevel(c, uids)
+	if err != nil {
+		log.Error("[http.exp|multiGetLevel] expSvr.MultiGetLevel(%v) error(%v)", uids, err)
+		c.JSON(nil, err)
+		return
+	}
+	levelInfo := make(map[string]*model.Level, len(levels))
+	for _, v := range levels {
+		levelInfo[strconv.FormatInt(v.Uid, 10)] = v
+	}
+	c.JSON(levelInfo, nil)
+}
+
+func addUexp(c *bm.Context) {
+	uidStr := c.Request.Form.Get("uid")
+	uexpStr := c.Request.Form.Get("uexp")
+	var exp *model.Exp
+	// check params
+	uid, err := strconv.ParseInt(uidStr, 10, 64)
+	if err != nil || uid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	uexp, err := strconv.ParseInt(uexpStr, 10, 64)
+	if err != nil || uexp <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	ric := infocArg(c)
+	err = expSvr.AddUexp(c, uid, uexp, ric)
+	if err != nil {
+		log.Error("[http.exp|addUexp] expSvr.AddUexp1(%u) error(%v)", uid, err)
+	}
+	LogSwitch := conf.Conf.Switch
+	if LogSwitch != nil {
+		var QueryConfig = conf.Conf.Switch.QueryExp
+		if QueryConfig == 1 {
+			exp, err = expSvr.Exp(c, uid)
+			log.Info("addUexpUpdate uid:%d,Uexp:%d,Uexp:%d,delta:%d", exp.Uid, exp.Uexp, exp.Rexp, uexp)
+		}
+	}
+	err = expSvr.AddUExpLog(c, uid, uexp, exp.Uexp, exp.Rexp, ric)
+
+	c.JSON(nil, err)
+}
+
+func addRexp(c *bm.Context) {
+	uidStr := c.Request.Form.Get("uid")
+	rexpStr := c.Request.Form.Get("rexp")
+	var exp *model.Exp
+	// check params
+	uid, err := strconv.ParseInt(uidStr, 10, 64)
+	if err != nil || uid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	rexp, err := strconv.ParseInt(rexpStr, 10, 64)
+	if err != nil || rexp <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	ric := infocArg(c)
+	err = expSvr.AddRexp(c, uid, rexp, ric)
+	if err != nil {
+		log.Error("[http.exp|addRexp] expSvr.AddRexp(%u) error(%v)", uid, err)
+	}
+	LogSwitch := conf.Conf.Switch
+	if LogSwitch != nil {
+		var QueryConfig = conf.Conf.Switch.QueryExp
+		if QueryConfig == 1 {
+			exp, err = expSvr.Exp(c, uid)
+			log.Info("addRexpUpdate   uid:%d,Uexp:%d,Rexp:%d,delta:%d", exp.Uid, exp.Uexp, exp.Rexp, rexp)
+		}
+	}
+	err = expSvr.AddRExpLog(c, uid, rexp, exp.Uexp, exp.Rexp, ric)
+
+	c.JSON(nil, err)
+}

app/service/live/userexp/http/http.go

@@ -0,0 +1,101 @@
+package http
+
+import (
+	"go-common/library/net/metadata"
+	"net/http"
+
+	"go-common/app/service/live/userexp/conf"
+	"go-common/app/service/live/userexp/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+var (
+	expSvr *service.Service
+)
+
+// Init init account service.
+func Init(c *conf.Config, s *service.Service) {
+	// init service
+	expSvr = s
+	// init external router
+	engineOut := bm.DefaultServer(c.BM.Inner)
+	innerRouter(engineOut)
+	// init Inner serve
+	if err := engineOut.Start(); err != nil {
+		log.Error("bm.DefaultServer error(%v)", err)
+		panic(err)
+	}
+	engineLocal := bm.DefaultServer(c.BM.Local)
+	localRouter(engineLocal)
+	// init Local serve
+	if err := engineLocal.Start(); err != nil {
+		log.Error("bm.DefaultServer error(%v)", err)
+		panic(err)
+	}
+}
+
+// outerRouter init outer router api path.
+func innerRouter(e *bm.Engine) {
+	// init api
+	e.GET("/monitor/ping", ping)
+	group := e.Group("/x/internal/liveexp")
+	{
+		group.GET("/level/get", level)
+		group.GET("/level/mulGet", multiGetLevel)
+		group.GET("/level/addUexp", addUexp)
+		group.GET("/level/addRexp", addRexp)
+	}
+}
+
+// localRouter init local router.
+func localRouter(e *bm.Engine) {
+}
+
+// ping check server ok.
+func ping(c *bm.Context) {
+	if err := expSvr.Ping(c); err != nil {
+		log.Error("live-userexp  http service ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}
+
+func infocArg(c *bm.Context) (arg map[string]string) {
+	var (
+		ua      string
+		referer string
+		sid     string
+		req     = c.Request
+	)
+	ua = req.Header.Get(service.RelInfocUA)
+	referer = req.Header.Get(service.RelInfocReferer)
+	sidCookie, err := req.Cookie(service.RelInfocSid)
+	if err != nil {
+		//log.Warn("live-userexo infoc get sid failed error(%v)", err)
+	} else {
+		sid = sidCookie.Value
+	}
+	buvid := req.Header.Get(service.RelInfocHeaderBuvid)
+	if buvid == "" {
+		buvidCookie, _ := req.Cookie(service.RelInfocCookieBuvid)
+		if buvidCookie != nil {
+			buvid = buvidCookie.Value
+		}
+	}
+	arg = map[string]string{
+		service.RelInfocIP:      metadata.String(c, metadata.RemoteIP),
+		service.RelInfocReferer: referer,
+		service.RelInfocSid:     sid,
+		service.RelInfocBuvid:   buvid,
+		service.RelInfocUA:      ua,
+	}
+	return
+}
+
+//func checkHealth(c wctx.Context) {
+//	_, err := os.Stat(conf.Conf.CheckFile)
+//	if os.IsNotExist(err) {
+//		http.Error(c.Response(), http.StatusText(http.StatusServiceUnavailable), http.StatusServiceUnavailable)
+//	}
+//	c.Cancel()
+//}

app/service/live/userexp/http/http_test.go

@@ -0,0 +1,135 @@
+package http
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"sync"
+	"testing"
+
+	"go-common/app/service/live/userexp/conf"
+	"go-common/app/service/live/userexp/model"
+	"go-common/app/service/live/userexp/service"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+const (
+	_getLevelURL      = "http://localhost:8801/x/internal/liveexp/level/get"
+	_multiGetLevelURL = "http://localhost:8801/x/internal/liveexp/level/mulGet"
+	_addUexpURL       = "http://localhost:8801/x/internal/liveexp/level/addUexp"
+	_addRexpURL       = "http://localhost:8801/x/internal/liveexp/level/addRexp"
+)
+
+var (
+	once   sync.Once
+	client *httpx.Client
+)
+
+func startHTTP() {
+	if err := conf.Init(); err != nil {
+		panic(fmt.Errorf("conf.Init() error(%v)", err))
+	}
+	svr := service.New(conf.Conf)
+	client = httpx.NewClient(conf.Conf.HTTPClient.Read)
+	Init(conf.Conf, svr)
+}
+
+func TestGetLevel(t *testing.T) {
+	once.Do(startHTTP)
+	params := url.Values{}
+	params.Set("uid", "10001")
+	var err error
+	var req *http.Request
+	if req, err = client.NewRequest("GET", _getLevelURL, "127.0.0.1", params); err != nil {
+		t.Errorf("http.NewRequest(GET, %s) error(%v)", _getLevelURL, err)
+		t.FailNow()
+	}
+	reqURI := req.URL.String()
+	t.Logf("req uri: %s\n", reqURI)
+	var res struct {
+		Code int          `json:"code"`
+		Data *model.Level `json:"data"`
+	}
+	if err = client.Do(context.TODO(), req, &res); err != nil {
+		t.Errorf("client.Do() error(%v)", err)
+		t.FailNow()
+	}
+	str, _ := json.Marshal(res)
+	t.Logf("res: %+v", string(str))
+}
+
+func TestMultiGetLevel(t *testing.T) {
+	once.Do(startHTTP)
+	params := url.Values{}
+	params.Set("uids", "10001,10002,10003")
+	var err error
+	var req *http.Request
+	if req, err = client.NewRequest("GET", _multiGetLevelURL, "127.0.0.1", params); err != nil {
+		t.Errorf("http.NewRequest(GET, %s) error(%v)", _multiGetLevelURL, err)
+		t.FailNow()
+	}
+	reqURI := req.URL.String()
+	t.Logf("req uri: %s\n", reqURI)
+	var res struct {
+		Code int                     `json:"code"`
+		Data map[string]*model.Level `json:"data"`
+	}
+	if err = client.Do(context.TODO(), req, &res); err != nil {
+		t.Errorf("client.Do() error(%v)", err)
+		t.FailNow()
+	}
+	str, _ := json.Marshal(res)
+	t.Logf("res: %+v", string(str))
+}
+
+func TestAddUexp(t *testing.T) {
+	once.Do(startHTTP)
+	params := url.Values{}
+	params.Set("uid", "10001")
+	params.Set("uexp", "1234")
+	var err error
+	var req *http.Request
+	if req, err = client.NewRequest("GET", _addUexpURL, "127.0.0.1", params); err != nil {
+		t.Errorf("http.NewRequest(GET, %s) error(%v)", _addUexpURL, err)
+		t.FailNow()
+	}
+	reqURI := req.URL.String()
+	t.Logf("req uri: %s\n", reqURI)
+	var res struct {
+		Code int    `json:"code"`
+		Data string `json:"data"`
+	}
+	if err = client.Do(context.TODO(), req, &res); err != nil {
+		t.Errorf("client.Do() error(%v)", err)
+		t.FailNow()
+	}
+	str, _ := json.Marshal(res)
+	t.Logf("res: %+v", string(str))
+}
+
+func TestAddRexp(t *testing.T) {
+	once.Do(startHTTP)
+	params := url.Values{}
+	params.Set("uid", "10001")
+	params.Set("rexp", "4321")
+	var err error
+	var req *http.Request
+	if req, err = client.NewRequest("GET", _addRexpURL, "127.0.0.1", params); err != nil {
+		t.Errorf("http.NewRequest(GET, %s) error(%v)", _addRexpURL, err)
+		t.FailNow()
+	}
+	reqURI := req.URL.String()
+	t.Logf("req uri: %s\n", reqURI)
+	var res struct {
+		Code int    `json:"code"`
+		Data string `json:"data"`
+	}
+	if err = client.Do(context.TODO(), req, &res); err != nil {
+		t.Errorf("client.Do() error(%v)", err)
+		t.FailNow()
+	}
+	str, _ := json.Marshal(res)
+	t.Logf("res: %+v", string(str))
+}