Initial commit

app/service/main/thumbup/server/gorpc/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 = ["rpc.go"],
+    importpath = "go-common/app/service/main/thumbup/server/gorpc",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/thumbup/conf:go_default_library",
+        "//app/service/main/thumbup/model:go_default_library",
+        "//app/service/main/thumbup/service:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//library/net/rpc/context: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/thumbup/server/gorpc/rpc.go

@@ -0,0 +1,106 @@
+package server
+
+import (
+	"go-common/app/service/main/thumbup/conf"
+	"go-common/app/service/main/thumbup/model"
+	"go-common/app/service/main/thumbup/service"
+	"go-common/library/net/rpc"
+	"go-common/library/net/rpc/context"
+)
+
+// RPC .
+type RPC struct {
+	s *service.Service
+}
+
+// New creates rpc server.
+func New(c *conf.Config, s *service.Service) (svr *rpc.Server) {
+	r := &RPC{s: s}
+	svr = rpc.NewServer(c.RPCServer)
+	if err := svr.Register(r); err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Ping checks connection success.
+func (r *RPC) Ping(c context.Context, arg *struct{}, res *struct{}) (err error) {
+	return
+}
+
+// Auth check connection success.
+func (r *RPC) Auth(c context.Context, arg *rpc.Auth, res *struct{}) (err error) {
+	return
+}
+
+// Like add like/dislike
+func (r *RPC) Like(c context.Context, arg *model.ArgLike, res *struct{}) (err error) {
+	_, err = r.s.Like(c, arg.Business, arg.Mid, arg.OriginID, arg.MessageID, arg.Type, arg.UpMid)
+	return
+}
+
+// LikeWithStats add like/dislike and return the stats info
+func (r *RPC) LikeWithStats(ctx context.Context, arg *model.ArgLike, res *model.Stats) (err error) {
+	*res, err = r.s.Like(ctx, arg.Business, arg.Mid, arg.OriginID, arg.MessageID, arg.Type, arg.UpMid)
+	return
+}
+
+// Stats return stats message
+func (r *RPC) Stats(c context.Context, arg *model.ArgStats, res *map[int64]*model.Stats) (err error) {
+	*res, err = r.s.Stats(c, arg.Business, arg.OriginID, arg.MessageIDs)
+	return
+}
+
+// UserLikes user likes list
+func (r *RPC) UserLikes(c context.Context, arg *model.ArgUserLikes, res *[]*model.ItemLikeRecord) (err error) {
+	*res, err = r.s.UserLikes(c, arg.Business, arg.Mid, arg.Pn, arg.Ps)
+	return
+}
+
+// UserDislikes user dislikes list
+func (r *RPC) UserDislikes(c context.Context, arg *model.ArgUserLikes, res *[]*model.ItemLikeRecord) (err error) {
+	*res, err = r.s.UserDislikes(c, arg.Business, arg.Mid, arg.Pn, arg.Ps)
+	return
+}
+
+// ItemLikes item likes list
+func (r *RPC) ItemLikes(c context.Context, arg *model.ArgItemLikes, res *[]*model.UserLikeRecord) (err error) {
+	*res, err = r.s.ItemLikes(c, arg.Business, arg.OriginID, arg.MessageID, arg.Pn, arg.Ps, arg.Mid)
+	return
+}
+
+// ItemDislikes item dislikes list
+func (r *RPC) ItemDislikes(c context.Context, arg *model.ArgItemLikes, res *[]*model.UserLikeRecord) (err error) {
+	*res, err = r.s.ItemDislikes(c, arg.Business, arg.OriginID, arg.MessageID, arg.Pn, arg.Ps, arg.Mid)
+	return
+}
+
+// HasLike query user has liked something
+func (r *RPC) HasLike(c context.Context, arg *model.ArgHasLike, res *map[int64]int8) (err error) {
+	*res, _, err = r.s.HasLike(c, arg.Business, arg.Mid, arg.MessageIDs)
+	return
+}
+
+// StatsWithLike return stats and like state
+func (r *RPC) StatsWithLike(c context.Context, arg *model.ArgStatsWithLike, res *map[int64]*model.StatsWithLike) (err error) {
+	*res, err = r.s.StatsWithLike(c, arg.Business, arg.Mid, arg.OriginID, arg.MessageIDs)
+	return
+}
+
+// UserTotalLike user item list with total count
+func (r *RPC) UserTotalLike(c context.Context, arg *model.ArgUserLikes, res **model.UserTotalLike) (err error) {
+	*res, err = r.s.UserTotalLike(c, arg.Business, arg.Mid, arg.Pn, arg.Ps)
+	return
+}
+
+// UpdateCount update count
+func (r *RPC) UpdateCount(c context.Context, arg *model.ArgUpdateCount, res *struct{}) (err error) {
+	err = r.s.UpdateCount(c, arg.Business, arg.OriginID, arg.MessageID, arg.LikeChange, arg.DislikeChange, arg.RealIP, arg.Operator)
+	return
+}
+
+// RawStats get stat changes
+func (r *RPC) RawStats(c context.Context, arg *model.ArgRawStats, res *model.RawStats) (err error) {
+	*res, err = r.s.RawStats(c, arg.Business, arg.OriginID, arg.MessageID)
+	return
+}

app/service/main/thumbup/server/grpc/BUILD

@@ -0,0 +1,35 @@
+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/thumbup/server/grpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/thumbup/api:go_default_library",
+        "//app/service/main/thumbup/model:go_default_library",
+        "//app/service/main/thumbup/service:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "@io_bazel_rules_go//proto/wkt:empty_go_proto",
+    ],
+)
+
+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/thumbup/server/grpc/server.go

@@ -0,0 +1,141 @@
+package grpc
+
+import (
+	"context"
+
+	pb "go-common/app/service/main/thumbup/api"
+	"go-common/app/service/main/thumbup/model"
+	"go-common/app/service/main/thumbup/service"
+	"go-common/library/net/rpc/warden"
+
+	"github.com/golang/protobuf/ptypes/empty"
+)
+
+// New Coin warden rpc server
+func New(c *warden.ServerConfig, svr *service.Service) *warden.Server {
+	ws := warden.NewServer(c)
+	pb.RegisterThumbupServer(ws.Server(), &server{s: svr})
+	ws, err := ws.Start()
+	if err != nil {
+		panic(err)
+	}
+	return ws
+}
+
+type server struct {
+	s *service.Service
+}
+
+func (r server) Like(c context.Context, req *pb.LikeReq) (reply *pb.LikeReply, err error) {
+	res, err := r.s.Like(c, req.Business, req.Mid, req.OriginID, req.MessageID, int8(req.Action), req.UpMid)
+	reply = &pb.LikeReply{
+		OriginID:      res.OriginID,
+		MessageID:     res.ID,
+		LikeNumber:    res.Likes,
+		DislikeNumber: res.Dislikes,
+	}
+	return
+}
+
+func (r server) Stats(c context.Context, req *pb.StatsReq) (reply *pb.StatsReply, err error) {
+	res, err := r.s.StatsWithLike(c, req.Business, req.Mid, req.OriginID, req.MessageIds)
+	reply = &pb.StatsReply{Stats: map[int64]*pb.StatState{}}
+	for name, item := range res {
+		reply.Stats[name] = &pb.StatState{
+			OriginID:      item.OriginID,
+			MessageID:     item.ID,
+			LikeNumber:    item.Likes,
+			DislikeNumber: item.Dislikes,
+			LikeState:     pb.State(item.LikeState),
+		}
+	}
+	return
+}
+
+func (r server) MultiStats(c context.Context, req *pb.MultiStatsReq) (reply *pb.MultiStatsReply, err error) {
+	arg := &model.MultiBusiness{
+		Mid:        req.Mid,
+		Businesses: make(map[string][]*model.MultiBusinessItem),
+	}
+	for name, b := range req.Business {
+		for _, i := range b.Records {
+			arg.Businesses[name] = append(arg.Businesses[name], &model.MultiBusinessItem{
+				OriginID:  i.OriginID,
+				MessageID: i.MessageID,
+			})
+		}
+	}
+	res, err := r.s.MultiStatsWithLike(c, arg)
+	reply = &pb.MultiStatsReply{}
+	if res != nil {
+		reply.Business = make(map[string]*pb.MultiStatsReply_Records)
+		for k, v := range res {
+			items := &pb.MultiStatsReply_Records{
+				Records: make(map[int64]*pb.StatState),
+			}
+			for id, state := range v {
+				items.Records[id] = &pb.StatState{
+					OriginID:      state.OriginID,
+					MessageID:     state.ID,
+					LikeNumber:    state.Likes,
+					DislikeNumber: state.Dislikes,
+					LikeState:     pb.State(state.LikeState),
+				}
+			}
+			reply.Business[k] = items
+		}
+	}
+	return
+}
+
+func (r server) HasLike(c context.Context, req *pb.HasLikeReq) (reply *pb.HasLikeReply, err error) {
+	_, res, err := r.s.HasLike(c, req.Business, req.Mid, req.MessageIds)
+	reply = &pb.HasLikeReply{States: res}
+	return
+}
+
+func (r server) UserLikes(c context.Context, req *pb.UserLikesReq) (reply *pb.UserLikesReply, err error) {
+	res, err := r.s.UserTotalLike(c, req.Business, req.Mid, int(req.Pn), int(req.Ps))
+	reply = &pb.UserLikesReply{}
+	if res != nil {
+		reply.Total = int64(res.Total)
+		for _, item := range res.List {
+			reply.Items = append(reply.Items, &pb.ItemRecord{
+				MessageID: item.MessageID,
+				Time:      item.Time,
+			})
+		}
+	}
+	return
+}
+
+func (r server) ItemLikes(c context.Context, req *pb.ItemLikesReq) (reply *pb.ItemLikesReply, err error) {
+	res, err := r.s.ItemLikes(c, req.Business, req.OriginID, req.MessageID, int(req.Pn), int(req.Ps), req.LastMid)
+	reply = &pb.ItemLikesReply{}
+	for _, item := range res {
+		reply.Users = append(reply.Users, &pb.UserRecord{
+			Mid:  item.Mid,
+			Time: item.Time,
+		})
+	}
+	return
+}
+
+func (r server) UpdateCount(c context.Context, req *pb.UpdateCountReq) (reply *empty.Empty, err error) {
+	reply = &empty.Empty{}
+	err = r.s.UpdateCount(c, req.Business, req.OriginID, req.MessageID, req.LikeChange, req.DislikeChange, req.IP, req.Operator)
+	return
+}
+
+func (r server) RawStat(c context.Context, req *pb.RawStatReq) (reply *pb.RawStatReply, err error) {
+	res, err := r.s.RawStats(c, req.Business, req.OriginID, req.MessageID)
+	reply = &pb.RawStatReply{
+		OriginID:      res.OriginID,
+		MessageID:     res.ID,
+		LikeNumber:    res.Likes,
+		DislikeNumber: res.Dislikes,
+		LikeChange:    res.LikesChange,
+		DislikeChange: res.DislikesChange,
+	}
+	return
+}

app/service/main/thumbup/server/http/BUILD

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

@@ -0,0 +1,62 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/service/main/thumbup/conf"
+	"go-common/app/service/main/thumbup/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/rate"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	likeSrv   *service.Service
+	verifySrv *verify.Verify
+)
+
+// Init init
+func Init(c *conf.Config, s *service.Service) {
+	verifySrv = verify.New(c.Verify)
+	rateLimit := rate.New(c.Rate)
+	likeSrv = s
+	// init outer router
+	engineOuter := bm.DefaultServer(c.BM)
+	engineOuter.Use(rateLimit)
+	outerRouter(engineOuter)
+	if err := engineOuter.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/internal/thumbup", verifySrv.Verify)
+	{
+		cr.GET("/stats", stats)
+		cr.POST("/multi_stats", multiStats)
+		cr.GET("/user_likes", userLikes)
+		cr.GET("/item_likes", itemLikes)
+		cr.POST("/like", like)
+		cr.GET("/has_like", hasLike)
+		cr.POST("/update_count", updateCount)
+		cr.GET("/raw_stats", rawStats)
+		cr.POST("/update_upmids", updateUpMids)
+		cr.POST("/item_has_like", itemHasLike)
+	}
+}
+
+func ping(c *bm.Context) {
+	if err := likeSrv.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)
+}

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

@@ -0,0 +1,182 @@
+package http
+
+import (
+	"go-common/app/service/main/thumbup/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+	"go-common/library/net/metadata"
+)
+
+func like(c *bm.Context) {
+	var (
+		err error
+	)
+	v := new(struct {
+		Business  string `form:"business" validate:"required"`
+		OriginID  int64  `form:"origin_id" validate:"min=0"`
+		MessageID int64  `form:"message_id" validate:"min=1,required"`
+		Type      int8   `form:"type" validate:"required"`
+		Mid       int64  `form:"mid" validate:"min=1,required"`
+		UpMid     int64  `form:"up_mid" validate:"omitempty,min=1"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(likeSrv.Like(c, v.Business, v.Mid, v.OriginID, v.MessageID, v.Type, v.UpMid))
+}
+
+func hasLike(c *bm.Context) {
+	v := new(struct {
+		Business   string  `form:"business" validate:"required"`
+		OriginID   int64   `form:"origin_id" validate:"min=0"`
+		MessageIDs []int64 `form:"message_ids,split" validate:"required"`
+		Mid        int64   `form:"mid" validate:"min=1,required"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	res, _, err := likeSrv.HasLike(c, v.Business, v.Mid, v.MessageIDs)
+	c.JSON(res, err)
+}
+
+func stats(c *bm.Context) {
+	v := new(struct {
+		Business   string  `form:"business" validate:"required"`
+		OriginID   int64   `form:"origin_id" validate:"min=0"`
+		MessageIDs []int64 `form:"message_ids,split" validate:"required"`
+		Mid        int64   `form:"mid"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if v.Mid > 0 {
+		c.JSON(likeSrv.StatsWithLike(c, v.Business, v.Mid, v.OriginID, v.MessageIDs))
+		return
+	}
+	c.JSON(likeSrv.Stats(c, v.Business, v.OriginID, v.MessageIDs))
+}
+
+func userLikes(c *bm.Context) {
+	var (
+		err  error
+		data []*model.ItemLikeRecord
+	)
+	v := new(struct {
+		Business string `form:"business" validate:"required"`
+		Type     string `form:"type" validate:"required"`
+		Mid      int64  `form:"mid" validate:"min=1,required"`
+		Pn       int    `form:"pn" default:"1" validate:"omitempty,min=1"`
+		Ps       int    `form:"ps" default:"20" validate:"omitempty,min=1"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if v.Type == "like" {
+		data, err = likeSrv.UserLikes(c, v.Business, v.Mid, v.Pn, v.Ps)
+	} else {
+		data, err = likeSrv.UserDislikes(c, v.Business, v.Mid, v.Pn, v.Ps)
+	}
+	if data == nil {
+		data = make([]*model.ItemLikeRecord, 0)
+	}
+	c.JSON(data, err)
+}
+
+func itemLikes(c *bm.Context) {
+	var (
+		err  error
+		data []*model.UserLikeRecord
+	)
+	v := new(struct {
+		Business  string `form:"business" validate:"required"`
+		OriginID  int64  `form:"origin_id" validate:"min=0"`
+		MessageID int64  `form:"message_id" validate:"min=1,required"`
+		Mid       int64  `form:"mid" validate:"omitempty,min=1"`
+		Type      string `form:"type" validate:"required"`
+		Pn        int    `form:"pn" default:"1" validate:"omitempty,min=1"`
+		Ps        int    `form:"ps" default:"20" validate:"omitempty,min=1"`
+	})
+	if err = c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	if v.Type == "like" {
+		data, err = likeSrv.ItemLikes(c, v.Business, v.OriginID, v.MessageID, v.Pn, v.Ps, v.Mid)
+	} else {
+		data, err = likeSrv.ItemDislikes(c, v.Business, v.OriginID, v.MessageID, v.Pn, v.Ps, v.Mid)
+	}
+	if data == nil {
+		data = make([]*model.UserLikeRecord, 0)
+	}
+	c.JSON(data, err)
+}
+
+func multiStats(c *bm.Context) {
+	v := new(model.MultiBusiness)
+	if err := c.BindWith(v, binding.JSON); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(likeSrv.MultiStatsWithLike(c, v))
+}
+
+func updateCount(c *bm.Context) {
+	v := new(struct {
+		Business      string `form:"business" validate:"required"`
+		OriginID      int64  `form:"origin_id" validate:"min=0"`
+		MessageID     int64  `form:"message_id" validate:"min=1,required"`
+		LikeChange    int64  `form:"like_change"`
+		DislikeChange int64  `form:"dislike_change"`
+		Operator      string `form:"operator" validate:"required"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	c.JSON(nil, likeSrv.UpdateCount(c, v.Business, v.OriginID, v.MessageID, v.LikeChange, v.DislikeChange, ip, v.Operator))
+}
+
+func rawStats(c *bm.Context) {
+	v := new(struct {
+		Business  string `form:"business" validate:"required"`
+		OriginID  int64  `form:"origin_id" validate:"min=0"`
+		MessageID int64  `form:"message_id" validate:"min=1,required"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(likeSrv.RawStats(c, v.Business, v.OriginID, v.MessageID))
+}
+
+func updateUpMids(c *bm.Context) {
+	v := new(struct {
+		Business string             `json:"business" validate:"required"`
+		Data     []*model.UpMidsReq `json:"data" validate:"required,gte=1,lte=100"`
+	})
+	if err := c.BindWith(v, binding.JSON); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, likeSrv.UpdateUpMids(c, v.Business, v.Data))
+}
+
+func itemHasLike(c *bm.Context) {
+	v := new(struct {
+		Business  string  `json:"business" validate:"required"`
+		OriginID  int64   `json:"origin_id" validate:"min=0"`
+		MessageID int64   `json:"message_id" validate:"min=1"`
+		Mids      []int64 `json:"mids,split" validate:"required"`
+	})
+	if err := c.BindWith(v, binding.JSON); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(likeSrv.ItemHasLike(c, v.Business, v.OriginID, v.MessageID, v.Mids))
+}