You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
364 lines
11 KiB
364 lines
11 KiB
// 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 |
|
}
|
|
|