Create & Init Project...

app/service/main/member/server/grpc/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 = [
+        "block.go",
+        "exp.go",
+        "member.go",
+        "moral.go",
+        "property_review.go",
+        "realname.go",
+    ],
+    importpath = "go-common/app/service/main/member/server/grpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/member/api:go_default_library",
+        "//app/service/main/member/model:go_default_library",
+        "//app/service/main/member/service:go_default_library",
+        "//app/service/main/member/service/block: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/member/server/grpc/block.go

@@ -0,0 +1,52 @@
+package grpc
+
+import (
+	"context"
+
+	"go-common/app/service/main/member/api"
+)
+
+// BlockInfo 查询封禁信息
+func (s *MemberServer) BlockInfo(ctx context.Context, req *api.MemberMidReq) (*api.BlockInfoReply, error) {
+	res, err := s.blockSvr.Infos(ctx, []int64{req.Mid})
+	if err != nil {
+		return nil, err
+	}
+	if len(res) == 0 {
+		return api.FromBlockInfo(s.blockSvr.DefaultUser(req.Mid)), nil
+	}
+	blockInfoReply := api.FromBlockInfo(res[0])
+	return blockInfoReply, nil
+}
+
+// BlockBatchInfo 批量查询封禁信息
+func (s *MemberServer) BlockBatchInfo(ctx context.Context, req *api.MemberMidsReq) (*api.BlockBatchInfoReply, error) {
+	res, err := s.blockSvr.Infos(ctx, req.Mids)
+	if err != nil {
+		return nil, err
+	}
+	blockInfos := make([]*api.BlockInfoReply, 0, len(res))
+	for i := range res {
+		blockInfos = append(blockInfos, api.FromBlockInfo(res[i]))
+	}
+	blockInfosReply := &api.BlockBatchInfoReply{
+		BlockInfos: blockInfos,
+	}
+	return blockInfosReply, nil
+}
+
+// BlockBatchDetail 批量查询封禁信息
+func (s *MemberServer) BlockBatchDetail(ctx context.Context, req *api.MemberMidsReq) (reply *api.BlockBatchDetailReply, err error) {
+	res, err := s.blockSvr.UserDetails(ctx, req.Mids)
+	if err != nil {
+		return nil, err
+	}
+	userDetails := make(map[int64]*api.BlockDetailReply, len(res))
+	for mid := range res {
+		userDetails[mid] = api.FromBlockUserDetail(res[mid])
+	}
+	blockUserDetailsReply := &api.BlockBatchDetailReply{
+		BlockDetails: userDetails,
+	}
+	return blockUserDetailsReply, nil
+}

app/service/main/member/server/grpc/exp.go

@@ -0,0 +1,97 @@
+package grpc
+
+import (
+	"context"
+	"go-common/app/service/main/member/api"
+	"go-common/app/service/main/member/model"
+)
+
+// Exp get member exp info
+func (s *MemberServer) Exp(ctx context.Context, req *api.MidReq) (*api.LevelInfoReply, error) {
+	res, err := s.svr.Exp(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	var levelInfoReply = &api.LevelInfoReply{
+		Cur:     res.Cur,
+		Min:     res.Min,
+		NowExp:  res.NowExp,
+		NextExp: res.NextExp,
+	}
+
+	return levelInfoReply, nil
+}
+
+// Level get member lebel info
+func (s *MemberServer) Level(ctx context.Context, req *api.MidReq) (*api.LevelInfoReply, error) {
+	res, err := s.svr.Level(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	var levelInfoReply = &api.LevelInfoReply{
+		Cur:     res.Cur,
+		Min:     res.Min,
+		NowExp:  res.NowExp,
+		NextExp: res.NextExp,
+	}
+
+	return levelInfoReply, nil
+}
+
+// UpdateExp update member exp value
+func (s *MemberServer) UpdateExp(ctx context.Context, req *api.AddExpReq) (*api.EmptyStruct, error) {
+	err := s.svr.UpdateExp(ctx, &model.ArgAddExp{
+		Mid:     req.Mid,
+		Count:   req.Count,
+		Reason:  req.Reason,
+		Operate: req.Operate,
+		IP:      req.Ip,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &api.EmptyStruct{}, nil
+}
+
+// ExpLog get member exp logs
+func (s *MemberServer) ExpLog(ctx context.Context, req *api.MidReq) (*api.UserLogsReply, error) {
+	res, err := s.svr.ExpLog(ctx, req.Mid, req.RealIP)
+	if err != nil {
+		return nil, err
+	}
+	userLogs := make([]*api.UserLogReply, 0, len(res))
+	for _, v := range res {
+		var userLog = &api.UserLogReply{
+			Mid:     v.Mid,
+			Ip:      v.IP,
+			Ts:      v.TS,
+			LogId:   v.LogID,
+			Content: v.Content,
+		}
+		userLogs = append(userLogs, userLog)
+	}
+	userLogsReply := &api.UserLogsReply{
+		UserLogs: userLogs,
+	}
+	return userLogsReply, nil
+}
+
+// ExpStat get exp status
+func (s *MemberServer) ExpStat(ctx context.Context, req *api.MidReq) (*api.ExpStatReply, error) {
+	res, err := s.svr.Stat(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	expStatReply := &api.ExpStatReply{
+		Login: res.Login,
+		Watch: res.Watch,
+		Coin:  res.Coin,
+		Share: res.Share,
+	}
+
+	return expStatReply, nil
+}

app/service/main/member/server/grpc/member.go

@@ -0,0 +1,190 @@
+package grpc
+
+import (
+	"context"
+	"go-common/app/service/main/member/api"
+	"go-common/app/service/main/member/service"
+	"go-common/app/service/main/member/service/block"
+	"go-common/library/net/rpc/warden"
+)
+
+// New Member warden rpc server
+func New(cfg *warden.ServerConfig, s *service.Service) *warden.Server {
+	w := warden.NewServer(cfg)
+	api.RegisterMemberServer(w.Server(), &MemberServer{svr: s, blockSvr: s.BlockImpl()})
+
+	ws, err := w.Start()
+	if err != nil {
+		panic(err)
+	}
+	return ws
+}
+
+// MemberServer define member Service
+type MemberServer struct {
+	svr      *service.Service
+	blockSvr *block.Service
+}
+
+var _ api.MemberServer = &MemberServer{}
+
+// Base get member base info
+func (s *MemberServer) Base(ctx context.Context, req *api.MemberMidReq) (*api.BaseInfoReply, error) {
+	res, err := s.svr.BaseInfo(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	return api.FromBaseInfo(res), nil
+}
+
+// Bases batch get members base info
+func (s *MemberServer) Bases(ctx context.Context, req *api.MemberMidsReq) (*api.BaseInfosReply, error) {
+	res, err := s.svr.BatchBaseInfo(ctx, req.Mids)
+	if err != nil {
+		return nil, err
+	}
+
+	baseInfos := make(map[int64]*api.BaseInfoReply, len(res))
+	baseInfosReply := &api.BaseInfosReply{
+		BaseInfos: baseInfos,
+	}
+
+	for k, v := range res {
+		baseInfos[k] = api.FromBaseInfo(v)
+	}
+
+	return baseInfosReply, nil
+}
+
+// Member get member full information
+func (s *MemberServer) Member(ctx context.Context, req *api.MemberMidReq) (*api.MemberInfoReply, error) {
+	res, err := s.svr.Member(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	memberInfoReply := api.FromMember(res)
+	return memberInfoReply, nil
+}
+
+// Members Batch get members info
+func (s *MemberServer) Members(ctx context.Context, req *api.MemberMidsReq) (*api.MemberInfosReply, error) {
+	res, err := s.svr.Members(ctx, req.Mids)
+	if err != nil {
+		return nil, err
+	}
+
+	memberInfos := make(map[int64]*api.MemberInfoReply, len(res))
+	for k, v := range res {
+		memberInfoReply := api.FromMember(v)
+		memberInfos[k] = memberInfoReply
+	}
+	memberInfosReply := &api.MemberInfosReply{
+		MemberInfos: memberInfos,
+	}
+
+	return memberInfosReply, nil
+}
+
+// NickUpdated Whether the member's nickname has been updated
+func (s *MemberServer) NickUpdated(ctx context.Context, req *api.MemberMidReq) (*api.NickUpdatedReply, error) {
+	res, err := s.svr.NickUpdated(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+	nickUpdatedReply := &api.NickUpdatedReply{
+		NickUpdated: res,
+	}
+	return nickUpdatedReply, nil
+}
+
+// SetNickUpdated Mark nickname as updated
+func (s *MemberServer) SetNickUpdated(ctx context.Context, req *api.MemberMidReq) (*api.EmptyStruct, error) {
+	err := s.svr.SetNickUpdated(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+	emptyStruct := &api.EmptyStruct{}
+	return emptyStruct, nil
+}
+
+// SetOfficialDoc Set offical document
+func (s *MemberServer) SetOfficialDoc(ctx context.Context, req *api.OfficialDocReq) (*api.EmptyStruct, error) {
+	err := s.svr.SetOfficialDoc(ctx, api.ToArgOfficialDoc(req))
+	if err != nil {
+		return nil, err
+	}
+	emptyStruct := &api.EmptyStruct{}
+	return emptyStruct, nil
+}
+
+// SetSex Set member's sex
+func (s *MemberServer) SetSex(ctx context.Context, req *api.UpdateSexReq) (*api.EmptyStruct, error) {
+	err := s.svr.SetSex(ctx, req.Mid, req.Sex)
+	if err != nil {
+		return nil, err
+	}
+	emptyStruct := &api.EmptyStruct{}
+	return emptyStruct, nil
+}
+
+// SetName Set member's name
+func (s *MemberServer) SetName(ctx context.Context, req *api.UpdateUnameReq) (*api.EmptyStruct, error) {
+	err := s.svr.SetName(ctx, req.Mid, req.Name)
+	if err != nil {
+		return nil, err
+	}
+	emptyStruct := &api.EmptyStruct{}
+	return emptyStruct, nil
+}
+
+// SetFace Set member's face
+func (s *MemberServer) SetFace(ctx context.Context, req *api.UpdateFaceReq) (*api.EmptyStruct, error) {
+	err := s.svr.SetFace(ctx, req.Mid, req.Face)
+	if err != nil {
+		return nil, err
+	}
+	emptyStruct := &api.EmptyStruct{}
+	return emptyStruct, nil
+}
+
+// SetRank Set member's rank
+func (s *MemberServer) SetRank(ctx context.Context, req *api.UpdateRankReq) (*api.EmptyStruct, error) {
+	err := s.svr.SetRank(ctx, req.Mid, req.Rank)
+	if err != nil {
+		return nil, err
+	}
+	emptyStruct := &api.EmptyStruct{}
+	return emptyStruct, nil
+}
+
+// SetBirthday Set member's birthday
+func (s *MemberServer) SetBirthday(ctx context.Context, req *api.UpdateBirthdayReq) (*api.EmptyStruct, error) {
+	err := s.svr.SetBirthday(ctx, req.Mid, req.Birthday)
+	if err != nil {
+		return nil, err
+	}
+	emptyStruct := &api.EmptyStruct{}
+	return emptyStruct, nil
+}
+
+// SetSign Set member's sign
+func (s *MemberServer) SetSign(ctx context.Context, req *api.UpdateSignReq) (*api.EmptyStruct, error) {
+	err := s.svr.SetSign(ctx, req.Mid, req.Sign)
+	if err != nil {
+		return nil, err
+	}
+	emptyStruct := &api.EmptyStruct{}
+	return emptyStruct, nil
+}
+
+// OfficialDoc Get member's offical doc
+func (s *MemberServer) OfficialDoc(ctx context.Context, req *api.MidReq) (*api.OfficialDocInfoReply, error) {
+	res, err := s.svr.OfficialDoc(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+	officialDocInfoReply := api.FromOfficialDoc(res)
+	return officialDocInfoReply, nil
+}

app/service/main/member/server/grpc/moral.go

@@ -0,0 +1,70 @@
+package grpc
+
+import (
+	"context"
+	"go-common/app/service/main/member/api"
+)
+
+// Moral Get member moral info
+func (s *MemberServer) Moral(ctx context.Context, req *api.MemberMidReq) (*api.MoralReply, error) {
+	res, err := s.svr.Moral(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	moralReply := &api.MoralReply{
+		Mid:             res.Mid,
+		Moral:           res.Moral,
+		Added:           res.Added,
+		Deducted:        res.Deducted,
+		LastRecoverDate: res.LastRecoverDate,
+	}
+
+	return moralReply, nil
+}
+
+// MoralLog Get member moral logs
+func (s *MemberServer) MoralLog(ctx context.Context, req *api.MemberMidReq) (*api.UserLogsReply, error) {
+	res, err := s.svr.MoralLog(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	userLogs := make([]*api.UserLogReply, 0, len(res))
+	for _, v := range res {
+		userLog := &api.UserLogReply{
+			Mid:     v.Mid,
+			Ip:      v.IP,
+			Ts:      v.TS,
+			LogId:   v.LogID,
+			Content: v.Content,
+		}
+		userLogs = append(userLogs, userLog)
+	}
+	userLogsReply := &api.UserLogsReply{
+		UserLogs: userLogs,
+	}
+
+	return userLogsReply, nil
+}
+
+// AddMoral Add member's moral value
+func (s *MemberServer) AddMoral(ctx context.Context, req *api.UpdateMoralReq) (*api.EmptyStruct, error) {
+	err := s.svr.UpdateMoral(ctx, api.ToArgUpdateMoral(req))
+	if err != nil {
+		return nil, err
+	}
+	return &api.EmptyStruct{}, nil
+}
+
+// BatchAddMoral Batch add member's moral value
+func (s *MemberServer) BatchAddMoral(ctx context.Context, req *api.UpdateMoralsReq) (*api.UpdateMoralsReply, error) {
+	res, err := s.svr.UpdateMorals(ctx, api.ToArgUpdateMorals(req))
+	if err != nil {
+		return nil, err
+	}
+	updateMoralsReply := &api.UpdateMoralsReply{
+		AfterMorals: res,
+	}
+	return updateMoralsReply, nil
+}

app/service/main/member/server/grpc/property_review.go

@@ -0,0 +1,39 @@
+package grpc
+
+import (
+	"context"
+	"go-common/app/service/main/member/api"
+	"go-common/app/service/main/member/model"
+)
+
+// AddUserMonitor add user monitor
+func (s *MemberServer) AddUserMonitor(ctx context.Context, req *api.AddUserMonitorReq) (*api.EmptyStruct, error) {
+	argAddUserMonitor := &model.ArgAddUserMonitor{
+		Mid:      req.Mid,
+		Operator: req.Operator,
+		Remark:   req.Remark,
+	}
+	err := s.svr.AddUserMonitor(ctx, argAddUserMonitor)
+	if err != nil {
+		return nil, err
+	}
+
+	emptyStruct := &api.EmptyStruct{}
+	return emptyStruct, nil
+}
+
+// IsInMonitor check whether the member is in monitored status
+func (s *MemberServer) IsInMonitor(ctx context.Context, req *api.MidReq) (*api.IsInMonitorReply, error) {
+	res, err := s.svr.IsInMonitor(ctx, &model.ArgMid{
+		Mid:    req.Mid,
+		RealIP: req.RealIP,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	isInMonitorReply := &api.IsInMonitorReply{
+		IsInMonitor: res,
+	}
+	return isInMonitorReply, nil
+}

app/service/main/member/server/grpc/realname.go

@@ -0,0 +1,84 @@
+package grpc
+
+import (
+	"context"
+	"go-common/app/service/main/member/api"
+)
+
+// RealnameStatus get the member realname status
+func (s *MemberServer) RealnameStatus(ctx context.Context, req *api.MemberMidReq) (*api.RealnameStatusReply, error) {
+	res, err := s.svr.RealnameStatus(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	var realnameStatusReply = &api.RealnameStatusReply{
+		RealnameStatus: int8(res),
+	}
+
+	return realnameStatusReply, nil
+}
+
+// RealnameApplyStatus get member realname apply status
+func (s *MemberServer) RealnameApplyStatus(ctx context.Context, req *api.MemberMidReq) (*api.RealnameApplyInfoReply, error) {
+	res, err := s.svr.RealnameApplyStatus(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	var realnameStatusReply = &api.RealnameApplyInfoReply{
+		Status: int8(res.Status),
+		Remark: res.Remark,
+	}
+
+	return realnameStatusReply, nil
+}
+
+// RealnameTelCapture mobilePhone realname certification
+func (s *MemberServer) RealnameTelCapture(ctx context.Context, req *api.MemberMidReq) (*api.EmptyStruct, error) {
+	_, err := s.svr.RealnameTelCapture(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	return &api.EmptyStruct{}, nil
+}
+
+// RealnameApply apply for realname certification
+func (s *MemberServer) RealnameApply(ctx context.Context, req *api.ArgRealnameApplyReq) (*api.EmptyStruct, error) {
+	err := s.svr.RealnameApply(ctx, req.Mid, int(req.CaptureCode), req.Realname, req.CardType, req.CardCode, req.Country, req.HandIMGToken, req.FrontIMGToken, req.BackIMGToken)
+	if err != nil {
+		return nil, err
+	}
+
+	return &api.EmptyStruct{}, nil
+}
+
+// RealnameDetail detail about realname by mid
+func (s *MemberServer) RealnameDetail(ctx context.Context, req *api.MemberMidReq) (*api.RealnameDetailReply, error) {
+	res, err := s.svr.RealnameDetail(ctx, req.Mid)
+	if err != nil {
+		return nil, err
+	}
+
+	var realnameDetail = &api.RealnameDetailReply{
+		Realname: res.Realname,
+		Card:     res.Card,
+		CardType: int8(res.CardType),
+		Status:   int8(res.Status),
+		Gender:   res.Gender,
+		HandImg:  res.HandIMG,
+	}
+
+	return realnameDetail, nil
+}
+
+// RealnameStrippedInfo is
+func (s *MemberServer) RealnameStrippedInfo(ctx context.Context, req *api.MemberMidReq) (*api.RealnameStrippedInfoReply, error) {
+	return s.svr.RealnameStrippedInfo(ctx, req.Mid)
+}
+
+// MidByRealnameCard is
+func (s *MemberServer) MidByRealnameCard(ctx context.Context, req *api.MidByRealnameCardsReq) (*api.MidByRealnameCardReply, error) {
+	return s.svr.MidByRealnameCard(ctx, req)
+}