Create & Init Project...

app/service/main/favorite/server/BUILD

@@ -0,0 +1,18 @@
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/service/main/favorite/server/gorpc:all-srcs",
+        "//app/service/main/favorite/server/grpc:all-srcs",
+        "//app/service/main/favorite/server/http:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/main/favorite/server/gorpc/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["server_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/favorite/api/gorpc:go_default_library",
+        "//app/service/main/favorite/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["server.go"],
+    importpath = "go-common/app/service/main/favorite/server/gorpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/favorite/conf:go_default_library",
+        "//app/service/main/favorite/model:go_default_library",
+        "//app/service/main/favorite/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/favorite/server/gorpc/server.go

@@ -0,0 +1,173 @@
+package rpc
+
+import (
+	"go-common/app/service/main/favorite/conf"
+	"go-common/app/service/main/favorite/model"
+	"go-common/app/service/main/favorite/service"
+	"go-common/library/net/rpc"
+	"go-common/library/net/rpc/context"
+)
+
+// RPC favorite rpc.
+type RPC struct {
+	c *conf.Config
+	s *service.Service
+}
+
+// New init rpc.
+func New(c *conf.Config, s *service.Service) (svr *rpc.Server) {
+	r := &RPC{
+		c: c,
+		s: s,
+	}
+	svr = rpc.NewServer(c.RPCServer)
+	if err := svr.Register(r); err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Ping check connection success.
+func (r *RPC) Ping(c context.Context, arg *struct{}, res *struct{}) (err error) {
+	return
+}
+
+// Folder return folder by mid.
+func (r *RPC) Folder(c context.Context, a *model.ArgFolder, res *model.Folder) (err error) {
+	var fl *model.Folder
+	if fl, err = r.s.Folder(c, a.Type, a.Mid, a.Vmid, a.Fid); err == nil {
+		*res = *fl
+	}
+	return
+}
+
+// Folders return folder by mid.
+func (r *RPC) Folders(c context.Context, a *model.ArgFolders, res *[]*model.Folder) (err error) {
+	*res, err = r.s.Folders(c, a.Type, a.Mid, a.FVmids)
+	return
+}
+
+// AllFolders return users folders.
+func (r *RPC) AllFolders(c context.Context, a *model.ArgAllFolders, res *[]*model.Folder) (err error) {
+	*res, err = r.s.UserFolders(c, a.Type, a.Mid, a.Vmid, a.Oid, a.Type)
+	return
+}
+
+// AddFolder add a Folder.
+func (r *RPC) AddFolder(c context.Context, a *model.ArgAddFolder, res *int64) (err error) {
+	var fid int64
+	if fid, err = r.s.AddFolder(c, a.Type, a.Mid, a.Name, a.Description, a.Cover, int32(a.Public), a.Cookie, a.AccessKey); err == nil {
+		*res = fid
+	}
+	return
+}
+
+// UpdateFolder update a Folder.
+func (r *RPC) UpdateFolder(c context.Context, a *model.ArgUpdateFolder, res *struct{}) (err error) {
+	err = r.s.UpdateFolder(c, a.Type, a.Fid, a.Mid, a.Name, a.Description, a.Cover, int32(a.Public), nil, nil)
+	return
+}
+
+// DelFolder del a folder.
+func (r *RPC) DelFolder(c context.Context, a *model.ArgDelFolder, res *struct{}) (err error) {
+	err = r.s.DelFolder(c, a.Type, a.Mid, a.Fid)
+	return
+}
+
+// Favorites return favorites by mid.
+func (r *RPC) Favorites(c context.Context, a *model.ArgFavs, res *model.Favorites) (err error) {
+	var fs *model.Favorites
+	if fs, err = r.s.Favorites(c, a.Type, a.Mid, a.Vmid, a.Fid, a.Tid, a.Tv, a.Pn, a.Ps, a.Keyword, a.Order); err == nil {
+		*res = *fs
+	}
+	return
+}
+
+// Add add a favorite relation.
+func (r *RPC) Add(c context.Context, a *model.ArgAdd, res *struct{}) (err error) {
+	err = r.s.AddFav(c, a.Type, a.Mid, a.Fid, a.Oid, a.Type)
+	return
+}
+
+// Del del a favorite relation.
+func (r *RPC) Del(c context.Context, a *model.ArgDel, res *struct{}) (err error) {
+	err = r.s.DelFav(c, a.Type, a.Mid, a.Fid, a.Oid, a.Type)
+	return
+}
+
+// Adds add a resource to folders.
+func (r *RPC) Adds(c context.Context, a *model.ArgAdds, res *struct{}) (err error) {
+	for _, fid := range a.Fids {
+		err = r.s.AddFav(c, a.Type, a.Mid, fid, a.Oid, a.Type)
+	}
+	return
+}
+
+// Dels del a resource in fodlers.
+func (r *RPC) Dels(c context.Context, a *model.ArgDels, res *struct{}) (err error) {
+	for _, fid := range a.Fids {
+		err = r.s.DelFav(c, a.Type, a.Mid, fid, a.Oid, a.Type)
+	}
+	return
+}
+
+// MultiAdd multi add favorite relations.
+func (r *RPC) MultiAdd(c context.Context, a *model.ArgMultiAdd, res *struct{}) (err error) {
+	err = r.s.MultiAddFavs(c, a.Type, a.Mid, a.Fid, a.Oids)
+	return
+}
+
+// MultiDel multi del favorite relations.
+func (r *RPC) MultiDel(c context.Context, a *model.ArgMultiDel, res *struct{}) (err error) {
+	err = r.s.MultiDelFavs(c, a.Type, a.Mid, a.Fid, a.Oids)
+	return
+}
+
+// IsFav check favorited relation.
+func (r *RPC) IsFav(c context.Context, a *model.ArgIsFav, faved *bool) (err error) {
+	*faved, err = r.s.IsFavored(c, a.Type, a.Mid, a.Oid)
+	return
+}
+
+// IsFavs return favored relation map.
+func (r *RPC) IsFavs(c context.Context, a *model.ArgIsFavs, res *map[int64]bool) (err error) {
+	*res, err = r.s.IsFavoreds(c, a.Type, a.Mid, a.Oids)
+	return
+}
+
+// InDefault return favored in default folder.
+func (r *RPC) InDefault(c context.Context, a *model.ArgInDefaultFolder, in *bool) (err error) {
+	*in, err = r.s.InDefaultFolder(c, a.Type, a.Mid, a.Oid)
+	return
+}
+
+// IsFavedByFid check the oid and fid relation.
+func (r *RPC) IsFavedByFid(c context.Context, a *model.ArgIsFavedByFid, faved *bool) (err error) {
+	*faved, err = r.s.IsFavedByFid(c, a.Type, a.Mid, a.Oid, a.Fid)
+	return
+}
+
+// CntUserFolders count user's folders.
+func (r *RPC) CntUserFolders(c context.Context, a *model.ArgCntUserFolders, count *int) (err error) {
+	*count, err = r.s.CntUserFolders(c, a.Type, a.Mid, a.Vmid)
+	return
+}
+
+// Users return favored users by mid.
+func (r *RPC) Users(c context.Context, a *model.ArgUsers, res *model.UserList) (err error) {
+	var us *model.UserList
+	if us, err = r.s.UserList(c, a.Type, a.Oid, a.Pn, a.Ps); err == nil {
+		*res = *us
+	}
+	return
+}
+
+// under v2 ===
+
+// AddVideo add a favorite video.
+func (r *RPC) AddVideo(c context.Context, a *model.ArgAddVideo, res *struct{}) (err error) {
+	for _, fid := range a.Fids {
+		err = r.s.AddFav(c, model.TypeVideo, a.Mid, fid, a.Aid, model.TypeVideo)
+	}
+	return
+}

app/service/main/favorite/server/gorpc/server_test.go

@@ -0,0 +1,172 @@
+package rpc
+
+import (
+	"context"
+	favmdl "go-common/app/service/main/favorite/model"
+	favsrv "go-common/app/service/main/favorite/api/gorpc"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	ctx = context.TODO()
+)
+
+func WithRPC(f func(client *favsrv.Service)) func() {
+	return func() {
+		client := favsrv.New2(nil)
+		time.Sleep(2 * time.Second)
+		f(client)
+	}
+}
+
+// func Test_Folders(t *testing.T) {
+// 	Convey("Folders", t, WithRPC(func(client *favsrv.Service) {
+// 		arg := &favmdl.ArgFolders{
+// 			Type: 5,
+// 			Mid:  88888894,
+// 			FVmids: []*favmdl.ArgFVmid{
+// 				{
+// 					Fid:  12331,
+// 					Vmid: 27515232,
+// 				},
+// 				{
+// 					Fid:  12315,
+// 					Vmid: 27515254,
+// 				},
+// 				{
+// 					Fid:  1237,
+// 					Vmid: 27515255,
+// 				},
+// 			},
+// 		}
+// 		res, err := client.Folders(ctx, arg)
+// 		t.Logf("res: %+v, error:%+v", res, err)
+// 		So(err, ShouldBeNil)
+// 	}))
+// }
+
+// func Test_AddFolder(t *testing.T) {
+// 	Convey("AddFolder", t, WithRPC(func(client *favsrv.Service) {
+// 		arg := &favmdl.ArgAddFolder{
+// 			Type:        5,
+// 			Mid:         88888894,
+// 			Name:        "1234",
+// 			Description: "1234",
+// 			Cover:       "1234",
+// 			Cookie:      "finger=14bc3c4e; sid=m65qzbpt; LIVE_BUVID=AUTO5915076321203625; fts=1507632123; UM_distinctid=15f05e08d7d1e5-0319506e9267a5-31657c00-1fa400-15f05e08d7e2b3; pgv_pvi=294734848; buvid3=C0E6B232-BC5C-4AEC-879C-1CC61C2336841986infoc; rpdid=kmilkmximpdoswqosospw; tma=136533283.50523868.1508466136624.1508466136624.1508466136624.1; tmd=2.136533283.50523868.1508466136624.; pgv_si=s1585227776; DedeUserID=88888894; DedeUserID__ckMd5=53cf4c9cd3a9e1fb; SESSDATA=6c75f0f3%2C1511521084%2Ce6967cf6; bili_jct=63ab513073169112f9f89b97c1713009; _cnt_pm=0; _cnt_notify=0; _dfcaptcha=db4362e021547cfab3dce5b4718ad573",
+// 		}
+// 		fid, err := client.AddFolder(ctx, arg)
+// 		So(err, ShouldBeNil)
+// 		t.Logf("fid: %d", fid)
+// 	}))
+// }
+
+// func Test_UpdateFolder(t *testing.T) {
+// 	Convey("UpdateFolder", t, WithRPC(func(client *favsrv.Service) {
+// 		arg := &favmdl.ArgUpdateFolder{
+// 			Type:        5,
+// 			Fid:         9,
+// 			Mid:         88888894,
+// 			Name:        "123",
+// 			Description: "",
+// 			// Cover:       "123",
+// 		}
+// 		err := client.UpdateFolder(ctx, arg)
+// 		So(err, ShouldBeNil)
+// 	}))
+// }
+
+// func Test_Add(t *testing.T) {
+// 	Convey("Add", t, WithRPC(func(client *favsrv.Service) {
+// 		arg := &favmdl.ArgAdd{
+// 			Type: 1,
+// 			Mid:  88888894,
+// 			Oid:  123,
+// 			Fid:  456,
+// 		}
+// 		err := client.Add(ctx, arg)
+// 		So(err, ShouldBeNil)
+// 	}))
+// }
+
+// func Test_AddVideo(t *testing.T) {
+// 	Convey("AddVideo", t, WithRPC(func(client *favsrv.Service) {
+// 		arg := &favmdl.ArgAddVideo{
+// 			Mid:    88888894,
+// 			Aid:    123,
+// 			Fids:   []int64{123, 456},
+// 			Cookie: "finger=14bc3c4e; sid=m65qzbpt; LIVE_BUVID=AUTO5915076321203625; fts=1507632123; UM_distinctid=15f05e08d7d1e5-0319506e9267a5-31657c00-1fa400-15f05e08d7e2b3; pgv_pvi=294734848; buvid3=C0E6B232-BC5C-4AEC-879C-1CC61C2336841986infoc; rpdid=kmilkmximpdoswqosospw; tma=136533283.50523868.1508466136624.1508466136624.1508466136624.1; tmd=2.136533283.50523868.1508466136624.; pgv_si=s1585227776; DedeUserID=88888894; DedeUserID__ckMd5=53cf4c9cd3a9e1fb; SESSDATA=6c75f0f3%2C1511521084%2Ce6967cf6; bili_jct=63ab513073169112f9f89b97c1713009; _cnt_pm=0; _cnt_notify=0; _dfcaptcha=db4362e021547cfab3dce5b4718ad573",
+// 		}
+// 		err := client.AddVideo(ctx, arg)
+// 		So(err, ShouldBeNil)
+// 	}))
+// }
+
+// func Test_Folder(t *testing.T) {
+// 	Convey("Add", t, WithRPC(func(client *favsrv.Service) {
+// 		arg := &favmdl.ArgFolder{
+// 			Type: 5,
+// 			Mid:  0,
+// 			Fid:  0,
+// 		}
+// 		res, err := client.Folder(ctx, arg)
+// 		t.Logf("res: %+v", res)
+// 		So(err, ShouldBeNil)
+// 	}))
+// }
+
+// func Test_IsFavedByFid(t *testing.T) {
+// 	Convey("IsFavedByFid", t, WithRPC(func(client *favsrv.Service) {
+// 		arg := &favmdl.ArgIsFavedByFid{
+// 			Type: 6,
+// 			Mid:  88888894,
+// 			Fid:  23,
+// 			Oid:  11112,
+// 		}
+// 		res, err := client.IsFavedByFid(ctx, arg)
+// 		t.Logf("res: %+v", res)
+// 		So(err, ShouldBeNil)
+// 	}))
+// }
+
+func Test_CntUserFolders(t *testing.T) {
+	Convey("CntUserFolders", t, WithRPC(func(client *favsrv.Service) {
+		arg := &favmdl.ArgCntUserFolders{
+			Type: 6,
+			Mid:  88888894,
+			Vmid: 88888894,
+		}
+		res, err := client.CntUserFolders(ctx, arg)
+		t.Logf("res: %+v", res)
+		So(err, ShouldBeNil)
+	}))
+}
+
+// func Test_DelFolder(t *testing.T) {
+// 	Convey("DelFolder", t, WithRPC(func(client *favsrv.Service) {
+// 		arg := &favmdl.ArgDelFolder{
+// 			Type: 5,
+// 			Mid:  88888894,
+// 			Fid:  9,
+// 		}
+// 		err := client.DelFolder(ctx, arg)
+// 		So(err, ShouldBeNil)
+// 	}))
+// }
+
+func Test_IsFavs(t *testing.T) {
+	Convey("IsFavs", t, WithRPC(func(client *favsrv.Service) {
+		arg := &favmdl.ArgIsFavs{
+			Type: 1,
+			Mid:  88888894,
+			Oids: []int64{123, 456},
+		}
+		res, err := client.IsFavs(ctx, arg)
+		t.Logf("res: %+v", res)
+		So(res, ShouldNotBeNil)
+		So(err, ShouldBeNil)
+	}))
+}

app/service/main/favorite/server/grpc/BUILD

@@ -0,0 +1,36 @@
+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/favorite/server/grpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/favorite/api:go_default_library",
+        "//app/service/main/favorite/model:go_default_library",
+        "//app/service/main/favorite/service:go_default_library",
+        "//library/ecode: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/favorite/server/grpc/server.go

@@ -0,0 +1,364 @@
+// Package server generate by warden_gen
+package server
+
+import (
+	"context"
+	"go-common/library/ecode"
+
+	pb "go-common/app/service/main/favorite/api"
+	"go-common/app/service/main/favorite/model"
+	service "go-common/app/service/main/favorite/service"
+	"go-common/library/net/rpc/warden"
+
+	empty "github.com/golang/protobuf/ptypes/empty"
+)
+
+// New Favorite warden rpc server
+func New(c *warden.ServerConfig, svr *service.Service) *warden.Server {
+	ws := warden.NewServer(c)
+	pb.RegisterFavoriteServer(ws.Server(), &server{svr})
+	return ws
+}
+
+type server struct {
+	svr *service.Service
+}
+
+var _ pb.FavoriteServer = &server{}
+
+func (s *server) SortFavs(ctx context.Context, req *pb.SortFavsReq) (*empty.Empty, error) {
+	var sorts []model.SortFav
+	for _, data := range req.Sorts {
+		sorts = append(sorts, model.SortFav{
+			Pre:    data.Pre,
+			Insert: data.Insert,
+		})
+	}
+	if len(sorts) == 0 {
+		return nil, ecode.RequestErr
+	}
+	s.svr.SortFavs(ctx, int8(req.Typ), req.Fid, req.Mid, sorts)
+	return &empty.Empty{}, nil
+}
+
+func (s *server) AdminUpdateFolder(ctx context.Context, req *pb.AdminUpdateFolderReq) (*empty.Empty, error) {
+	attr := int32(req.Attr)
+	state := int8(req.State)
+	err := s.svr.UpdateFolder(ctx, int8(req.Typ), req.Fid, req.Mid, req.Name, req.Description, req.Cover, 0, &attr, &state)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) UpFolderName(ctx context.Context, req *pb.UpFolderNameReq) (*empty.Empty, error) {
+	err := s.svr.UpFolderName(ctx, int8(req.Typ), req.Mid, req.Fid, req.Name, req.Cookie, req.AccessKey)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) FavDelFolders(ctx context.Context, req *pb.FavDelFoldersReq) (*empty.Empty, error) {
+	for _, fid := range req.Fids {
+		err := s.svr.DelFav(ctx, int8(req.Typ), req.Mid, fid, req.Oid, int8(req.Otype))
+		if err != nil {
+			return nil, err
+		}
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) FavAddFolders(ctx context.Context, req *pb.FavAddFoldersReq) (*empty.Empty, error) {
+	for _, fid := range req.Fids {
+		err := s.svr.AddFav(ctx, int8(req.Typ), req.Mid, fid, req.Oid, int8(req.Otype))
+		if err != nil {
+			return nil, err
+		}
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) UpFolderAttr(ctx context.Context, req *pb.UpFolderAttrReq) (*empty.Empty, error) {
+	err := s.svr.UpFolderAttr(ctx, int8(req.Typ), req.Mid, req.Fid, req.Public)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) CleanState(ctx context.Context, req *pb.CleanStateReq) (*pb.CleanStateReply, error) {
+	state, err := s.svr.CleanState(ctx, int8(req.Typ), req.Mid, req.Fid)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.CleanStateReply{CleanState: int32(state)}, nil
+}
+
+func (s *server) CleanInvalidFavs(ctx context.Context, req *pb.CleanInvalidFavsReq) (*empty.Empty, error) {
+	err := s.svr.CleanInvalidArcs(ctx, int8(req.Typ), req.Mid, req.Fid)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) CopyFavs(ctx context.Context, req *pb.CopyFavsReq) (*empty.Empty, error) {
+	err := s.svr.CopyFavs(ctx, int8(req.Typ), req.OldMid, req.Mid, req.OldFid, req.NewFid, req.Oids)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) MoveFavs(ctx context.Context, req *pb.MoveFavsReq) (*empty.Empty, error) {
+	err := s.svr.MoveFavs(ctx, int8(req.Typ), req.Mid, req.OldFid, req.NewFid, req.Oids)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) SetFolderSort(ctx context.Context, req *pb.SetFolderSortReq) (*empty.Empty, error) {
+	err := s.svr.SetFolderSort(ctx, int8(req.Typ), req.Mid, req.Fids)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) FavedUsers(ctx context.Context, req *pb.FavedUsersReq) (*pb.FavedUsersReply, error) {
+	list, err := s.svr.UserList(ctx, int8(req.Type), req.Oid, int(req.Pn), int(req.Ps))
+	if err != nil {
+		return nil, err
+	}
+	reply := &pb.FavedUsersReply{
+		Page: &pb.ModelPage{
+			Num:   int32(list.Page.Num),
+			Size_: int32(list.Page.Size),
+			Count: int32(list.Page.Total),
+		},
+	}
+	for _, data := range list.List {
+		reply.User = append(reply.User, &pb.User{
+			Id:    data.ID,
+			Oid:   data.Oid,
+			Mid:   data.Mid,
+			Typ:   int32(data.Type),
+			State: int32(data.State),
+			Ctime: int64(data.CTime),
+			Mtime: int64(data.MTime),
+		})
+	}
+	return reply, nil
+}
+
+func (s *server) CntUserFolders(ctx context.Context, req *pb.CntUserFoldersReq) (*pb.CntUserFoldersReply, error) {
+	count, err := s.svr.CntUserFolders(ctx, int8(req.Typ), req.Mid, req.Vmid)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.CntUserFoldersReply{Count: int32(count)}, nil
+}
+
+func (s *server) InDefault(ctx context.Context, req *pb.InDefaultFolderReq) (*pb.InDefaultFolderReply, error) {
+	isIn, err := s.svr.InDefaultFolder(ctx, int8(req.Typ), req.Mid, req.Oid)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.InDefaultFolderReply{IsIn: isIn}, nil
+}
+
+func (s *server) MultiDel(ctx context.Context, req *pb.MultiDelReq) (*empty.Empty, error) {
+	err := s.svr.MultiDelFavs(ctx, int8(req.Typ), req.Mid, req.Fid, req.Oids)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) MultiAdd(ctx context.Context, req *pb.MultiAddReq) (*empty.Empty, error) {
+	err := s.svr.MultiAddFavs(ctx, int8(req.Typ), req.Mid, req.Fid, req.Oids)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) DelFolder(ctx context.Context, req *pb.DelFolderReq) (*empty.Empty, error) {
+	err := s.svr.DelFolder(ctx, int8(req.Typ), req.Mid, req.Fid)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) UpdateFolder(ctx context.Context, req *pb.UpdateFolderReq) (*empty.Empty, error) {
+	err := s.svr.UpdateFolder(ctx, int8(req.Typ), req.Fid, req.Mid, req.Name, req.Description, req.Cover, req.Public, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &empty.Empty{}, nil
+}
+
+func (s *server) AddFolder(ctx context.Context, req *pb.AddFolderReq) (*pb.AddFolderReply, error) {
+	fid, err := s.svr.AddFolder(ctx, int8(req.Typ), req.Mid, req.Name, req.Description, req.Cover, req.Public, req.Cookie, req.AccessKey)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.AddFolderReply{Fid: fid}, nil
+}
+
+// IsFavoredByFid return folders by mid.
+func (s *server) IsFavoredByFid(ctx context.Context, req *pb.IsFavoredByFidReq) (*pb.IsFavoredReply, error) {
+	ok, err := s.svr.IsFavedByFid(ctx, int8(req.Type), req.Mid, req.Oid, req.Fid)
+	return &pb.IsFavoredReply{Faved: ok}, err
+}
+
+// UserFolders return folders by mid.
+func (s *server) UserFolders(ctx context.Context, req *pb.UserFoldersReq) (*pb.UserFoldersReply, error) {
+	if req.Otype <= 0 {
+		req.Otype = req.Typ
+	}
+	uf, err := s.svr.UserFolders(ctx, int8(req.Typ), req.Mid, req.Vmid, req.Oid, int8(req.Otype))
+	return &pb.UserFoldersReply{Res: uf}, err
+}
+
+// UserFolder return one folder by mid.
+func (s *server) UserFolder(ctx context.Context, req *pb.UserFolderReq) (*pb.UserFolderReply, error) {
+	f, err := s.svr.UserFolder(ctx, int8(req.Typ), req.Mid, req.Vmid, req.Fid)
+	return &pb.UserFolderReply{Res: f}, err
+}
+
+// Tlists return partitions .
+func (s *server) Tlists(ctx context.Context, req *pb.TlistsReq) (*pb.TlistsReply, error) {
+	ts, err := s.svr.Tlists(ctx, int8(req.Tp), req.Mid, req.Uid, req.Fid)
+	if err != nil {
+		return nil, err
+	}
+	reply := &pb.TlistsReply{}
+	for _, v := range ts {
+		reply.Res = append(reply.Res, &pb.ModelPartition{
+			Tid:   int32(v.Tid),
+			Name:  v.Name,
+			Count: int32(v.Count),
+		})
+	}
+	return reply, err
+}
+
+// RecentFavs return favs by mid.
+func (s *server) RecentFavs(ctx context.Context, req *pb.RecentFavsReq) (*pb.RecentFavsReply, error) {
+	ids, err := s.svr.RecentFavs(ctx, int8(req.Tp), req.Mid, int(req.Size_))
+	return &pb.RecentFavsReply{Res: ids}, err
+}
+
+// RecentFavs return favs by mid.
+func (s *server) RecentResources(ctx context.Context, req *pb.RecentResourcesReq) (*pb.RecentResourcesReply, error) {
+	recents, err := s.svr.RecentResources(ctx, int8(req.Tp), req.Mid, int(req.Size_))
+	return &pb.RecentResourcesReply{Res: recents}, err
+}
+
+// Favorites return favorieds info by fid.
+func (s *server) Favorites(ctx context.Context, req *pb.FavoritesReq) (*pb.FavoritesReply, error) {
+	f, err := s.svr.Favorites(ctx, int8(req.Tp), req.Mid, req.Uid, req.Fid, int(req.Tid), int(req.Tv), int(req.Pn), int(req.Ps), req.Keyword, req.Order)
+	if err != nil {
+		return nil, err
+	}
+	reply := &pb.FavoritesReply{Res: &pb.ModelFavorites{Page: &pb.ModelPage{
+		Num:   int32(f.Page.Num),
+		Size_: int32(f.Page.Size),
+		Count: int32(f.Page.Count),
+	}}}
+	for _, data := range f.List {
+		reply.Res.List = append(reply.Res.List, &pb.ModelFavorite{
+			Id:    data.ID,
+			Oid:   data.Oid,
+			Mid:   data.Mid,
+			Fid:   data.Fid,
+			Type:  int32(data.Type),
+			State: int32(data.State),
+			Ctime: int64(data.CTime),
+			Mtime: int64(data.MTime),
+		})
+	}
+	return reply, err
+}
+
+// AddFav add a favorite into folder.
+func (s *server) AddFav(ctx context.Context, req *pb.AddFavReq) (*pb.AddFavReply, error) {
+	err := s.svr.AddFav(ctx, int8(req.Tp), req.Mid, req.Fid, req.Oid, int8(req.Otype))
+	return &pb.AddFavReply{}, err
+}
+
+// DelFav delete a favorite.
+func (s *server) DelFav(ctx context.Context, req *pb.DelFavReq) (*pb.DelFavReply, error) {
+	err := s.svr.DelFav(ctx, int8(req.Tp), req.Mid, req.Fid, req.Oid, int8(req.Otype))
+	return &pb.DelFavReply{}, err
+}
+
+// IsFavored check if oid faved by user
+func (s *server) IsFavored(ctx context.Context, req *pb.IsFavoredReq) (*pb.IsFavoredReply, error) {
+	is, err := s.svr.IsFavored(ctx, int8(req.Typ), req.Mid, req.Oid)
+	return &pb.IsFavoredReply{Faved: is}, err
+}
+
+// IsFavoreds check if oids faved by user
+func (s *server) IsFavoreds(ctx context.Context, req *pb.IsFavoredsReq) (*pb.IsFavoredsReply, error) {
+	res, err := s.svr.IsFavoreds(ctx, int8(req.Typ), req.Mid, req.Oids)
+	return &pb.IsFavoredsReply{Faveds: res}, err
+}
+
+// FavoritesAll return favorieds info by fid.
+func (s *server) FavoritesAll(ctx context.Context, req *pb.FavoritesReq) (*pb.FavoritesReply, error) {
+	if req.Pn <= 0 {
+		req.Pn = 1
+	}
+	if req.Ps <= 0 {
+		req.Ps = 20
+	}
+	var f *model.Favorites
+	var err error
+	if int8(req.Tp) != model.TypeVideo {
+		f, err = s.svr.Favorites(ctx, int8(req.Tp), req.Mid, req.Uid, req.Fid, int(req.Tid), int(req.Tv), int(req.Pn), int(req.Ps), req.Keyword, req.Order)
+	} else {
+		f, err = s.svr.FavoritesAll(ctx, int8(req.Tp), req.Mid, req.Uid, req.Fid, int(req.Tid), int(req.Tv), int(req.Pn), int(req.Ps), req.Keyword, req.Order)
+	}
+	if err != nil {
+		return nil, err
+	}
+	reply := &pb.FavoritesReply{Res: &pb.ModelFavorites{Page: &pb.ModelPage{
+		Num:   int32(f.Page.Num),
+		Size_: int32(f.Page.Size),
+		Count: int32(f.Page.Count),
+	}}}
+	for _, data := range f.List {
+		reply.Res.List = append(reply.Res.List, &pb.ModelFavorite{
+			Id:    data.ID,
+			Oid:   data.Oid,
+			Mid:   data.Mid,
+			Fid:   data.Fid,
+			Type:  int32(data.Type),
+			State: int32(data.State),
+			Ctime: int64(data.CTime),
+			Mtime: int64(data.MTime),
+		})
+	}
+	return reply, err
+}
+
+// Folders return folders by ids.
+func (s *server) Folders(ctx context.Context, req *pb.FoldersReq) (*pb.FoldersReply, error) {
+	var afids []*model.ArgFVmid
+	for _, id := range req.Ids {
+		afids = append(afids, &model.ArgFVmid{
+			Fid:  id.Fid,
+			Vmid: id.Mid % 100,
+		})
+	}
+	res, err := s.svr.Folders(ctx, int8(req.Typ), req.Mid, afids)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.FoldersReply{Res: res}, nil
+}

app/service/main/favorite/server/http/BUILD

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

@@ -0,0 +1,115 @@
+package http
+
+import (
+	"net/http"
+	"strconv"
+
+	"go-common/app/service/main/favorite/conf"
+	"go-common/app/service/main/favorite/service"
+	"go-common/library/log"
+	"go-common/library/log/anticheat"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/antispam"
+	"go-common/library/net/http/blademaster/middleware/supervisor"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	favSvc      *service.Service
+	verifySvc   *verify.Verify
+	antispamM   *antispam.Antispam
+	supervisorM *supervisor.Supervisor
+	collector   *anticheat.AntiCheat
+)
+
+// Init init router
+func Init(c *conf.Config, svc *service.Service) {
+	verifySvc = verify.New(c.Verify)
+	antispamM = antispam.New(c.Antispam)
+	supervisorM = supervisor.New(c.Supervisor)
+	favSvc = svc
+	if c.Infoc2 != nil {
+		collector = anticheat.New(c.Infoc2)
+	}
+	// init outer router
+	engineOut := bm.DefaultServer(c.BM)
+	internalRouter(engineOut)
+	// init serve
+	if err := engineOut.Start(); err != nil {
+		log.Error("engineOut.Start() error(%v)", err)
+		panic(err)
+	}
+}
+
+// internalRouter init internal router api path
+func internalRouter(e *bm.Engine) {
+	// init api
+	e.Ping(ping)
+	e.Register(register)
+	favV3 := e.Group("/x/internal/v3/fav")
+	{
+		favV3.GET("", verifySvc.Verify, setMid, Favorites)
+		favV3.GET("/test", setMid, Favorites)
+		favV3.GET("/tlists", verifySvc.Verify, setMid, tlists)
+		favV3.GET("/recents", verifySvc.VerifyUser, recentFavs)
+		favV3.GET("/batch", verifySvc.Verify, batchFavs)
+		favV3.POST("/add", verifySvc.VerifyUser, addFav)
+		favV3.POST("/del", verifySvc.VerifyUser, delFav)
+		favV3.POST("/madd", verifySvc.VerifyUser, multiAddFavs)
+		favV3.POST("/mdel", verifySvc.VerifyUser, multiDelFavs)
+		favV3.POST("/move", verifySvc.VerifyUser, moveFavs)
+		favV3.POST("/copy", verifySvc.VerifyUser, copyFavs)
+		favV3.GET("/favored", verifySvc.VerifyUser, isFavored)
+		favV3.GET("/favoreds", verifySvc.VerifyUser, isFavoreds)
+		favV3.GET("/users", verifySvc.Verify, userList)
+		favV3.GET("/count", verifySvc.Verify, oidCount)
+		favV3.GET("/counts", verifySvc.Verify, oidsCount)
+		favV3.GET("/default", verifySvc.VerifyUser, inDefaultFolder)
+	}
+	folderV3 := e.Group("/x/internal/v3/fav/folder")
+	{
+		folderV3.GET("", verifySvc.Verify, setMid, userFolders)
+		folderV3.GET("/multi", verifySvc.Verify, folders)
+		folderV3.GET("/info", verifySvc.Verify, folderInfo)
+		folderV3.GET("/count", verifySvc.Verify, cntUserFolders)
+		folderV3.POST("/add", verifySvc.VerifyUser, addFolder)
+		folderV3.POST("/update", verifySvc.VerifyUser, updateFolder)
+		folderV3.POST("/del", verifySvc.VerifyUser, delFolder)
+		folderV3.POST("/rename", verifySvc.VerifyUser, renameFolder)
+		folderV3.POST("/public", verifySvc.VerifyUser, upAttrFolder)
+		folderV3.POST("/sort", verifySvc.VerifyUser, sortFolders)
+		folderV3.GET("/cleaned", verifySvc.VerifyUser, isCleaned)
+		folderV3.POST("/clean", verifySvc.VerifyUser, cleanInvalidFavs)
+	}
+}
+
+func setMid(c *bm.Context) {
+	var (
+		err error
+		mid int64
+	)
+	req := c.Request
+	midStr := req.Form.Get("mid")
+	if midStr != "" {
+		mid, err = strconv.ParseInt(midStr, 10, 64)
+		if err != nil {
+			c.JSON(nil, err)
+			c.Abort()
+			return
+		}
+	}
+	c.Set("mid", mid)
+}
+
+// ping check server ok.
+func ping(c *bm.Context) {
+	if err := favSvc.Ping(c); err != nil {
+		log.Error("favorite 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)
+}