Create & Init Project...

app/service/main/point/server/grpc/BUILD

@@ -0,0 +1,34 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["server.go"],
+    importpath = "go-common/app/service/main/point/server/grpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/point/api:go_default_library",
+        "//app/service/main/point/model:go_default_library",
+        "//app/service/main/point/service:go_default_library",
+        "//library/net/rpc/warden: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/main/point/server/grpc/server.go

@@ -0,0 +1,169 @@
+// Package server generate by warden_gen
+package server
+
+import (
+	"context"
+
+	pb "go-common/app/service/main/point/api"
+	"go-common/app/service/main/point/model"
+	service "go-common/app/service/main/point/service"
+	"go-common/library/net/rpc/warden"
+)
+
+// New Point warden rpc server
+func New(c *warden.ServerConfig, svr *service.Service) *warden.Server {
+	ws := warden.NewServer(c)
+	pb.RegisterPointServer(ws.Server(), &server{svr})
+	ws, err := ws.Start()
+	if err != nil {
+		panic(err)
+	}
+	return ws
+}
+
+type server struct {
+	svr *service.Service
+}
+
+var _ pb.PointServer = &server{}
+
+// Config get point config.
+func (s *server) Config(ctx context.Context, req *pb.ConfigReq) (*pb.ConfigReply, error) {
+	p, err := s.svr.Config(ctx, int(req.ChangeType), req.Mid, req.Bp)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.ConfigReply{Point: p}, err
+}
+
+// AllConfig all point config
+func (s *server) AllConfig(ctx context.Context, req *pb.AllConfigReq) (*pb.AllConfigReply, error) {
+	ac := s.svr.AllConfig(ctx)
+	return &pb.AllConfigReply{Data_0: ac}, nil
+}
+
+// Ping Service
+func (s *server) Ping(ctx context.Context, req *pb.PingReq) (*pb.PingReply, error) {
+	return &pb.PingReply{}, nil
+}
+
+// Close Service
+func (s *server) Close(ctx context.Context, req *pb.CloseReq) (*pb.CloseReply, error) {
+	return &pb.CloseReply{}, nil
+}
+
+// PointInfo .
+func (s *server) PointInfo(ctx context.Context, req *pb.PointInfoReq) (*pb.PointInfoReply, error) {
+	p, err := s.svr.PointInfo(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.PointInfoReply{Pi: &pb.ModelPointInfo{
+		Mid:          p.Mid,
+		PointBalance: p.PointBalance,
+		Ver:          p.Ver,
+	}}, err
+}
+
+// PointHistory .
+func (s *server) PointHistory(ctx context.Context, req *pb.PointHistoryReq) (*pb.PointHistoryReply, error) {
+	phs, t, nc, err := s.svr.PointHistory(ctx, req.Mid, int(req.Cursor), int(req.Ps))
+	if err != nil {
+		return nil, err
+	}
+	var mph []*pb.ModelPointHistory
+	for _, v := range phs {
+		p := &pb.ModelPointHistory{
+			Id:           v.ID,
+			Mid:          v.Mid,
+			Point:        v.Point,
+			OrderId:      v.OrderID,
+			ChangeType:   int32(v.ChangeType),
+			ChangeTime:   v.ChangeTime.Time().Unix(),
+			RelationId:   v.RelationID,
+			PointBalance: v.PointBalance,
+			Remark:       v.Remark,
+			Operator:     v.Operator,
+		}
+		mph = append(mph, p)
+	}
+	return &pb.PointHistoryReply{
+		Phs:     mph,
+		Total:   int32(t),
+		Ncursor: int32(nc),
+	}, err
+}
+
+// OldPointHistory old point history .
+func (s *server) OldPointHistory(ctx context.Context, req *pb.OldPointHistoryReq) (*pb.OldPointHistoryReply, error) {
+	phs, t, err := s.svr.OldPointHistory(ctx, req.Mid, int(req.Pn), int(req.Ps))
+	if err != nil {
+		return nil, err
+	}
+	var mop []*pb.ModelOldPointHistory
+	for _, v := range phs {
+		p := &pb.ModelOldPointHistory{
+			Id:           v.ID,
+			Mid:          v.Mid,
+			Point:        v.Point,
+			OrderId:      v.OrderID,
+			ChangeType:   int32(v.ChangeType),
+			ChangeTime:   v.ChangeTime,
+			RelationId:   v.RelationID,
+			PointBalance: v.PointBalance,
+			Remark:       v.Remark,
+			Operator:     v.Operator,
+		}
+		mop = append(mop, p)
+	}
+	return &pb.OldPointHistoryReply{Phs: mop, Total: int32(t)}, err
+}
+
+// PointAddByBp by bp.
+func (s *server) PointAddByBp(ctx context.Context, req *pb.PointAddByBpReq) (*pb.PointAddByBpReply, error) {
+	arg := &model.ArgPointAdd{
+		Mid:        req.Pa.Mid,
+		ChangeType: int(req.Pa.ChangeType),
+		RelationID: req.Pa.RelationId,
+		Bcoin:      req.Pa.Bcoin,
+		Remark:     req.Pa.Remark,
+		OrderID:    req.Pa.OrderId,
+	}
+	p, err := s.svr.PointAddByBp(ctx, arg)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.PointAddByBpReply{P: p}, err
+}
+
+// ConsumePoint .
+func (s *server) ConsumePoint(ctx context.Context, req *pb.ConsumePointReq) (*pb.ConsumePointReply, error) {
+	arg := &model.ArgPointConsume{
+		Mid:        req.Pc.Mid,
+		ChangeType: req.Pc.ChangeType,
+		RelationID: req.Pc.RelationId,
+		Point:      req.Pc.Point,
+		Remark:     req.Pc.Remark,
+	}
+	status, err := s.svr.ConsumePoint(ctx, arg)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.ConsumePointReply{Status: int32(status)}, err
+}
+
+// AddPoint .
+func (s *server) AddPoint(ctx context.Context, req *pb.AddPointReq) (*pb.AddPointReply, error) {
+	pc := &model.ArgPoint{
+		Mid:        req.Pc.Mid,
+		ChangeType: req.Pc.ChangeType,
+		Point:      req.Pc.Point,
+		Remark:     req.Pc.Remark,
+		Operator:   req.Pc.Operator,
+	}
+	status, err := s.svr.AddPoint(ctx, pc)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.AddPointReply{Status: int32(status)}, err
+}

app/service/main/point/server/http/BUILD

@@ -0,0 +1,43 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "http.go",
+        "inner.go",
+        "outer.go",
+        "point.go",
+    ],
+    importpath = "go-common/app/service/main/point/server/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/point/conf:go_default_library",
+        "//app/service/main/point/model:go_default_library",
+        "//app/service/main/point/service: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",
+        "//library/net/http/blademaster/middleware/verify: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/main/point/server/http/http.go

@@ -0,0 +1,52 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/service/main/point/conf"
+	"go-common/app/service/main/point/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/auth"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	svc          *service.Service
+	verSvc       *verify.Verify
+	authSvc      *auth.Auth
+	whiteAppkeys string
+)
+
+// Init init.
+func Init(s *service.Service) {
+	initService(s)
+	// init router.
+	engineInner := bm.DefaultServer(conf.Conf.BM)
+	innerRouter(engineInner)
+	outerRouter(engineInner)
+	if err := engineInner.Start(); err != nil {
+		log.Error("engineInner.Start() error(%v)", err)
+		panic(err)
+	}
+	whiteAppkeys = conf.Conf.Property.PointWhiteAppkeys
+}
+
+func initService(s *service.Service) {
+	svc = s
+	verSvc = verify.New(conf.Conf.Verify)
+	authSvc = auth.New(conf.Conf.Auth)
+}
+
+// ping check server ok.
+func ping(c *bm.Context) {
+	if err := svc.Ping(c); err != nil {
+		log.Error("point http service ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}
+
+// register check server ok.
+func register(c *bm.Context) {
+	c.JSON(map[string]interface{}{}, nil)
+}

app/service/main/point/server/http/inner.go

@@ -0,0 +1,20 @@
+package http
+
+import bm "go-common/library/net/http/blademaster"
+
+// innerRouter init local router api path.
+func innerRouter(e *bm.Engine) {
+	e.Ping(ping)
+	e.Register(register)
+	ig := e.Group("/x/internal/point", verSvc.Verify)
+	{
+		ig.GET("/info", pointInfoInner)
+		ig.POST("/consume", pointConsume)
+		ig.POST("/add", pointAddByBp)
+		ig.GET("/configs", configs)
+		ig.GET("/config", config)
+		ig.GET("/old/history", oldPointHistory)
+		ig.POST("/addbyadmin", pointAdd)
+	}
+
+}

app/service/main/point/server/http/outer.go

@@ -0,0 +1,16 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+// outerRouter init outer router api path.
+func outerRouter(e *bm.Engine) {
+	// api v1
+	g := e.Group("/x/point", bm.CORS())
+	{
+		g.GET("/info", authSvc.User, pointInfo)
+		g.GET("/history", authSvc.User, pointHistory)
+	}
+
+}

app/service/main/point/server/http/point.go

@@ -0,0 +1,154 @@
+package http
+
+import (
+	"strings"
+
+	"go-common/app/service/main/point/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func pointInfo(c *bm.Context) {
+	var (
+		mid, _ = c.Get("mid")
+	)
+	c.JSON(svc.PointInfo(c, mid.(int64)))
+}
+
+func pointInfoInner(c *bm.Context) {
+	m := new(model.ArgMid)
+	if err := c.Bind(m); err != nil {
+		return
+	}
+	c.JSON(svc.PointInfo(c, m.Mid))
+}
+
+func pointAddByBp(c *bm.Context) {
+	var (
+		err error
+		p   int64
+	)
+	if err = checkAuth(c); err != nil {
+		c.JSON(nil, err)
+	}
+	pa := new(model.ArgPointAdd)
+	if err = c.Bind(pa); err != nil {
+		log.Error("point add by bp bind %+v", err)
+		return
+	}
+	if p, err = svc.PointAddByBp(c, pa); err != nil {
+		log.Error("point add by bp(%+v) faild(%+v)", pa, err)
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(map[string]interface{}{
+		"point": p,
+	}, nil)
+}
+
+func pointConsume(c *bm.Context) {
+	var (
+		err    error
+		status int8
+	)
+	if err = checkAuth(c); err != nil {
+		c.JSON(nil, err)
+	}
+	arg := new(model.ArgPointConsume)
+	if err = c.Bind(arg); err != nil {
+		log.Error("point consume bind %+v", err)
+		return
+	}
+	if arg.Point <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if status, err = svc.ConsumePoint(c, arg); err != nil {
+		log.Error("point consume(%+v) faild(%+v)", arg, err)
+	}
+	c.JSON(map[string]interface{}{
+		"status": status,
+	}, nil)
+}
+
+func pointHistory(c *bm.Context) {
+	var (
+		mid, _ = c.Get("mid")
+		m      = new(model.ArgPointHistory)
+	)
+	if err := c.Bind(m); err != nil {
+		return
+	}
+	phs, total, cursor, err := svc.PointHistory(c, mid.(int64), m.Cursor, m.PS)
+	data := make(map[string]interface{})
+	data["total"] = total
+	data["phs"] = phs
+	data["cursor"] = cursor
+	c.JSON(data, err)
+}
+
+func oldPointHistory(c *bm.Context) {
+	var (
+		m = new(model.ArgOldPointHistory)
+	)
+	if err := c.Bind(m); err != nil {
+		return
+	}
+	phs, total, err := svc.OldPointHistory(c, m.Mid, m.PN, m.PS)
+	data := make(map[string]interface{})
+	data["total"] = total
+	data["phs"] = phs
+	c.JSON(data, err)
+}
+
+func configs(c *bm.Context) {
+	c.JSON(svc.AllConfig(c), nil)
+}
+
+func config(c *bm.Context) {
+	arg := new(model.ArgConfig)
+	if err := c.Bind(arg); err != nil {
+		return
+	}
+	if arg.ChangeType == 0 {
+		arg.ChangeType = model.Contract
+	}
+	c.JSON(svc.Config(c, int(arg.ChangeType), arg.Mid, arg.Bp))
+}
+
+func checkAuth(c *bm.Context) (err error) {
+	req := c.Request
+	params := req.Form
+	sappkey := params.Get("appkey")
+	if len(sappkey) == 0 || !strings.Contains(whiteAppkeys, sappkey) {
+		err = ecode.AccessDenied
+		return
+	}
+	return
+}
+
+func pointAdd(c *bm.Context) {
+	var (
+		err    error
+		status int8
+	)
+	if err = checkAuth(c); err != nil {
+		c.JSON(nil, err)
+	}
+	arg := new(model.ArgPoint)
+	if err = c.Bind(arg); err != nil {
+		log.Error("point add bind %+v", err)
+		return
+	}
+	if arg.Point <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if status, err = svc.AddPoint(c, arg); err != nil {
+		log.Error("point add(%+v) faild(%+v)", arg, err)
+	}
+	c.JSON(map[string]interface{}{
+		"status": status,
+	}, nil)
+}