From 7570fb44752f1444e7efadb95e0f7a0920d40b0b Mon Sep 17 00:00:00 2001 From: FantasyRL <1845983502@qq.com> Date: Sat, 27 Apr 2024 13:36:39 +0800 Subject: [PATCH] refactor:interaction --- Makefile | 11 +- .../biz/handler/api/interaction_handler.go | 3 +- cmd/api/biz/model/api/api.go | 12 +- cmd/interaction/handler.go | 30 +- cmd/interaction/main.go | 52 +- cmd/interaction/rpc/video.go | 48 + cmd/interaction/service/dislike_action.go | 70 + cmd/interaction/service/is_like.go | 38 + cmd/interaction/service/like_action.go | 61 +- cmd/interaction/service/like_list.go | 49 +- cmd/user/handler.go | 13 +- cmd/video/handler.go | 14 + cmd/video/service/list_by_id_list.go | 76 + .../{list_video.go => list_by_user_id.go} | 26 +- idl/api.thrift | 2 +- idl/user.thrift | 3 +- idl/video.thrift | 14 + kitex_gen/user/k-user.go | 51 +- kitex_gen/user/user.go | 80 +- kitex_gen/video/k-video.go | 716 ++++++++ kitex_gen/video/video.go | 1531 +++++++++++++---- kitex_gen/video/videohandler/client.go | 6 + kitex_gen/video/videohandler/videohandler.go | 35 + pkg/pack/build_api_resp.go | 12 +- 24 files changed, 2523 insertions(+), 430 deletions(-) create mode 100644 cmd/interaction/rpc/video.go create mode 100644 cmd/interaction/service/dislike_action.go create mode 100644 cmd/interaction/service/is_like.go create mode 100644 cmd/video/service/list_by_id_list.go rename cmd/video/service/{list_video.go => list_by_user_id.go} (72%) diff --git a/Makefile b/Makefile index 75aff85f..473c198d 100644 --- a/Makefile +++ b/Makefile @@ -4,6 +4,7 @@ IDL_PATH = $(DIR)/idl RPC = $(DIR)/cmd API_PATH= $(DIR)/cmd/api SHELL=/bin/bash +KITEX_GEN_PATH=$(DIR)/kitex_gen MODULE= bibi .PHONY: init @@ -21,7 +22,7 @@ env-down: SERVICES := api user video interaction service = $(word 1, $@) -.PHONY: $(SERVICES) +.PHONY: ${SERVICES} $(SERVICES): go run $(RPC)/$(service) @@ -36,11 +37,11 @@ KSERVICES := user video interaction .PHONY: kgen kgen: @for kservice in $(KSERVICES); do \ -# sh kitex_update.sh $$kservice; \ - kitex -module ${MODULE} idl/$$kservice.thrift; \ - cd ${RPC};cd $$kservice;kitex -module ${MODULE} -service $$kservice -use bibi/kitex_gen ../../idl/$$kservice.thrift; \ + kitex -module ${MODULE} ${IDL_PATH}/$$kservice.thrift; \ + cd ${RPC};cd $$kservice;kitex -module ${MODULE} -service $$kservice -use ${KITEX_GEN_PATH} ${IDL_PATH}/$$kservice.thrift; \ + cd ../../; \ done \ - echo "done" + .PHONY: hzgen hzgen: diff --git a/cmd/api/biz/handler/api/interaction_handler.go b/cmd/api/biz/handler/api/interaction_handler.go index ac858365..135d053c 100644 --- a/cmd/api/biz/handler/api/interaction_handler.go +++ b/cmd/api/biz/handler/api/interaction_handler.go @@ -3,13 +3,12 @@ package api import ( + api "bibi/cmd/api/biz/model/api" "bibi/cmd/api/biz/rpc" "bibi/kitex_gen/interaction" "bibi/pkg/errno" "bibi/pkg/pack" "context" - - api "bibi/cmd/api/biz/model/api" "github.com/cloudwego/hertz/pkg/app" "github.com/cloudwego/hertz/pkg/protocol/consts" ) diff --git a/cmd/api/biz/model/api/api.go b/cmd/api/biz/model/api/api.go index 1fb6d8de..07b30c63 100644 --- a/cmd/api/biz/model/api/api.go +++ b/cmd/api/biz/model/api/api.go @@ -2937,7 +2937,7 @@ type Video struct { CoverURL string `thrift:"cover_url,6" form:"cover_url" json:"cover_url" query:"cover_url"` LikeCount int64 `thrift:"like_count,7" form:"like_count" json:"like_count" query:"like_count"` CommentCount int64 `thrift:"comment_count,8" form:"comment_count" json:"comment_count" query:"comment_count"` - IsLike int64 `thrift:"is_like,9" form:"is_like" json:"is_like" query:"is_like"` + IsLike bool `thrift:"is_like,9" form:"is_like" json:"is_like" query:"is_like"` PublishTime string `thrift:"publish_time,10" form:"publish_time" json:"publish_time" query:"publish_time"` } @@ -2982,7 +2982,7 @@ func (p *Video) GetCommentCount() (v int64) { return p.CommentCount } -func (p *Video) GetIsLike() (v int64) { +func (p *Video) GetIsLike() (v bool) { return p.IsLike } @@ -3091,7 +3091,7 @@ func (p *Video) Read(iprot thrift.TProtocol) (err error) { goto SkipFieldError } case 9: - if fieldTypeId == thrift.I64 { + if fieldTypeId == thrift.BOOL { if err = p.ReadField9(iprot); err != nil { goto ReadFieldError } @@ -3207,7 +3207,7 @@ func (p *Video) ReadField8(iprot thrift.TProtocol) error { } func (p *Video) ReadField9(iprot thrift.TProtocol) error { - if v, err := iprot.ReadI64(); err != nil { + if v, err := iprot.ReadBool(); err != nil { return err } else { p.IsLike = v @@ -3425,10 +3425,10 @@ WriteFieldEndError: } func (p *Video) writeField9(oprot thrift.TProtocol) (err error) { - if err = oprot.WriteFieldBegin("is_like", thrift.I64, 9); err != nil { + if err = oprot.WriteFieldBegin("is_like", thrift.BOOL, 9); err != nil { goto WriteFieldBeginError } - if err := oprot.WriteI64(p.IsLike); err != nil { + if err := oprot.WriteBool(p.IsLike); err != nil { return err } if err = oprot.WriteFieldEnd(); err != nil { diff --git a/cmd/interaction/handler.go b/cmd/interaction/handler.go index 5e7cf928..1285592c 100644 --- a/cmd/interaction/handler.go +++ b/cmd/interaction/handler.go @@ -6,6 +6,7 @@ import ( "bibi/pkg/errno" "bibi/pkg/pack" "context" + "fmt" ) // InteractionHandlerImpl implements the last service interface defined in the IDL. @@ -35,28 +36,15 @@ func (s *InteractionHandlerImpl) LikeAction(ctx context.Context, req *interactio // LikeList implements the InteractionHandlerImpl interface. func (s *InteractionHandlerImpl) LikeList(ctx context.Context, req *interaction.LikeListRequest) (resp *interaction.LikeListResponse, err error) { resp = new(interaction.LikeListResponse) - allLikeResp, err := service.NewInteractionService(ctx).LikeVideoList(req, req.UserId) + videoResp, count, err := service.NewInteractionService(ctx).LikeVideoList(req, req.UserId) + resp.Base = pack.BuildBaseResp(err) if err != nil { resp.Base = pack.BuildBaseResp(err) return resp, nil } - count := int64(len(allLikeResp)) + resp.VideoList = videoResp resp.VideoCount = &count - - //var likeResp []int64 - //if len(allLikeResp) <= int(req.PageNum-1)*constants.PageSize || int(req.PageNum-1)*constants.PageSize < 0 { - // resp.Base = pack.BuildBaseResp(nil) - // return resp, nil - //} else { - // fst := int(req.PageNum-1) * constants.PageSize - // for i := fst; i < fst+constants.PageSize && i < len(allLikeResp); i++ { - // likeResp = append(likeResp, allLikeResp[i]) - // } - //} - //todo: - //videosResp:=make([]*video.Video,constants.PageSize) - //GetLikeVideoList - + fmt.Println(*videoResp[1]) return resp, nil } @@ -93,7 +81,13 @@ func (s *InteractionHandlerImpl) GetLikesCountByVideoIdList(ctx context.Context, // GetIsLikeByVideoIdList implements the InteractionHandlerImpl interface. func (s *InteractionHandlerImpl) GetIsLikeByVideoIdList(ctx context.Context, req *interaction.GetIsLikeByVideoIdListRequest) (resp *interaction.GetIsLikeByVideoIdListResponse, err error) { resp = new(interaction.GetIsLikeByVideoIdListResponse) - return + isLikeResp, err := service.NewInteractionService(ctx).GetIsLikeByVideoIdList(req) + resp.Base = pack.BuildBaseResp(err) + if err != nil { + return resp, nil + } + resp.IsLikeList = isLikeResp + return resp, nil } // CommentList implements the InteractionHandlerImpl interface. diff --git a/cmd/interaction/main.go b/cmd/interaction/main.go index 8ee6a32b..e8c1b161 100644 --- a/cmd/interaction/main.go +++ b/cmd/interaction/main.go @@ -2,25 +2,42 @@ package main import ( "bibi/cmd/interaction/dal" + "bibi/cmd/interaction/rpc" "bibi/config" interaction "bibi/kitex_gen/interaction/interactionhandler" "bibi/pkg/constants" "bibi/pkg/utils" + "bibi/pkg/utils/eslogrus" + "crypto/tls" + "fmt" "github.com/cloudwego/kitex/pkg/klog" "github.com/cloudwego/kitex/pkg/limit" "github.com/cloudwego/kitex/pkg/rpcinfo" "github.com/cloudwego/kitex/server" "github.com/cloudwego/netpoll" + elastic "github.com/elastic/go-elasticsearch/v8" + kitexlogrus "github.com/kitex-contrib/obs-opentelemetry/logging/logrus" etcd "github.com/kitex-contrib/registry-etcd" - "log" + "github.com/sirupsen/logrus" + "net" + "net/http" + "time" ) -var listenAddr string +var ( + listenAddr string + EsClient *elastic.Client +) func Init() { config.Init(constants.InteractionServiceName) dal.Init() + InitEs() + klog.SetLevel(klog.LevelDebug) + klog.SetLogger(kitexlogrus.NewLogger(kitexlogrus.WithHook(EsHookLog()))) + + rpc.InitVideoRPC() } func main() { @@ -46,7 +63,7 @@ func main() { interactionHandlerImpl := new(InteractionHandlerImpl) serviceAddr, err := netpoll.ResolveTCPAddr("tcp", listenAddr) if err != nil { - log.Fatal(err) + klog.Fatal(err) } svr := interaction.NewServer(interactionHandlerImpl, // 指定 Registry 与服务基本信息 @@ -67,3 +84,32 @@ func main() { klog.Error(err.Error()) } } + +func EsHookLog() *eslogrus.ElasticHook { + hook, err := eslogrus.NewElasticHook(EsClient, config.ElasticSearch.Host, logrus.DebugLevel, constants.ElasticSearchIndexName) + if err != nil { + klog.Warn(err) + } + + return hook +} + +func InitEs() { + esConn := fmt.Sprintf("http://%s", config.ElasticSearch.Addr) + cfg := elastic.Config{ + Addresses: []string{esConn}, + Transport: &http.Transport{ + MaxIdleConnsPerHost: 10, + ResponseHeaderTimeout: time.Second, + DialContext: (&net.Dialer{Timeout: time.Second}).DialContext, + TLSClientConfig: &tls.Config{ + MinVersion: tls.VersionTLS12, + }, + }, + } + client, err := elastic.NewClient(cfg) + if err != nil { + klog.Fatal(err) + } + EsClient = client +} diff --git a/cmd/interaction/rpc/video.go b/cmd/interaction/rpc/video.go new file mode 100644 index 00000000..ea39c8b1 --- /dev/null +++ b/cmd/interaction/rpc/video.go @@ -0,0 +1,48 @@ +package rpc + +import ( + "bibi/config" + "bibi/kitex_gen/video" + "bibi/kitex_gen/video/videohandler" + "bibi/pkg/constants" + "context" + "github.com/cloudwego/kitex/client" + "github.com/cloudwego/kitex/pkg/loadbalance" + "github.com/cloudwego/kitex/pkg/retry" + etcd "github.com/kitex-contrib/registry-etcd" +) + +var videoClient videohandler.Client + +func InitVideoRPC() { + r, err := etcd.NewEtcdResolver([]string{config.Etcd.Addr}) + + if err != nil { + panic(err) + } + + c, err := videohandler.NewClient( + constants.VideoServiceName, + client.WithMuxConnection(constants.MuxConnection), + client.WithRPCTimeout(constants.RPCTimeout), + client.WithConnectTimeout(constants.ConnectTimeout), + client.WithFailureRetry(retry.NewFailurePolicy()), + client.WithResolver(r), + client.WithLoadBalancer(loadbalance.NewWeightedRoundRobinBalancer()), + ) + + if err != nil { + panic(err) + } + + videoClient = c +} + +func VideoGetByIdList(ctx context.Context, req *video.GetVideoByIdListRequest) (*video.GetVideoByIdListResponse, error) { + resp, err := videoClient.GetVideoByIdList(ctx, req) + if err != nil { + return nil, err + } + return resp, nil + +} diff --git a/cmd/interaction/service/dislike_action.go b/cmd/interaction/service/dislike_action.go new file mode 100644 index 00000000..f9af4204 --- /dev/null +++ b/cmd/interaction/service/dislike_action.go @@ -0,0 +1,70 @@ +package service + +import ( + "bibi/cmd/interaction/dal/cache" + "bibi/cmd/interaction/dal/db" + "bibi/kitex_gen/interaction" + "bibi/pkg/constants" + "bibi/pkg/errno" + "errors" + "gorm.io/gorm" +) + +func (s *InteractionService) DisLike(req *interaction.LikeActionRequest, uid int64) error { + lkType := new(likeType) + if req.VideoId != nil { + lkType.suffix = constants.VideoLikeSuffix + lkType.targetId = *req.VideoId + lkType.zset = constants.VideoLikeZset + lkType.dbType = true + } else { + lkType.suffix = constants.CommentLikeSuffix + lkType.targetId = *req.CommentId + lkType.zset = constants.CommentLikeZset + lkType.dbType = false + } + + exist, err := cache.IsLikeExist(s.ctx, lkType.targetId, uid, lkType.suffix) + if err != nil { + return err + } + if !exist { + if lkType.dbType { + err = db.IsVideoLikeExist(s.ctx, uid, lkType.targetId) + if errors.Is(err, gorm.ErrRecordNotFound) { + return errno.LikeNotExistError + } + if err != nil { + return err + } + + if err = db.CheckVideoLikeStatus(s.ctx, uid, lkType.targetId, 0); err == nil { + return errno.LikeNotExistError + } + } else { + err = db.IsCommentLikeExist(s.ctx, uid, lkType.targetId) + if errors.Is(err, gorm.ErrRecordNotFound) { + return errno.LikeNotExistError + } + if err != nil { + return err + } + + if err = db.CheckCommentLikeStatus(s.ctx, uid, lkType.targetId, 0); err == nil { + return errno.LikeNotExistError + } + } + + } + if exist { + if err = cache.DelVideoLikeCount(s.ctx, lkType.zset, lkType.targetId, uid, lkType.suffix); err != nil { + return err + } + } + + if lkType.dbType { + return db.VideoLikeStatusUpdate(s.ctx, uid, lkType.targetId, 0) + } else { + return db.CommentLikeStatusUpdate(s.ctx, uid, lkType.targetId, 0) + } +} diff --git a/cmd/interaction/service/is_like.go b/cmd/interaction/service/is_like.go new file mode 100644 index 00000000..f5166e9e --- /dev/null +++ b/cmd/interaction/service/is_like.go @@ -0,0 +1,38 @@ +package service + +import ( + "bibi/cmd/interaction/dal/cache" + "bibi/cmd/interaction/dal/db" + "bibi/kitex_gen/interaction" + "bibi/pkg/constants" + "errors" + "github.com/redis/go-redis/v9" + "gorm.io/gorm" +) + +func (s *InteractionService) GetIsLikeByVideoIdList(req *interaction.GetIsLikeByVideoIdListRequest) ([]int64, error) { + //缓存未过期 + allVideoIdList, err := cache.GetUserLikeVideos(s.ctx, req.UserId, constants.VideoLikeSuffix) + if err != nil && !errors.Is(err, redis.Nil) { + return nil, err + } + + //缓存过期 + allVideoIdList, err = db.GetVideoByUid(s.ctx, req.UserId) + if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) { + return nil, err + } + + isLikeResp := make([]int64, len(req.VideoId)) + for i, v := range req.VideoId { + //也可以用二分，但麻烦点，所以懒了 + isLikeResp[i] = 0 + for j := 0; j < len(allVideoIdList); j++ { + if allVideoIdList[j] == v { + isLikeResp[i] = 1 + break + } + } + } + return isLikeResp, nil +} diff --git a/cmd/interaction/service/like_action.go b/cmd/interaction/service/like_action.go index 22f4e59f..8dc91ef3 100644 --- a/cmd/interaction/service/like_action.go +++ b/cmd/interaction/service/like_action.go @@ -17,7 +17,7 @@ type likeType struct { } // 好麻烦，我还是不做了... -// + //todo:isVideoExist;isAuthor(uid:video_id:countSuffix) func (s *InteractionService) Like(req *interaction.LikeActionRequest, uid int64) error { @@ -101,62 +101,3 @@ func (s *InteractionService) Like(req *interaction.LikeActionRequest, uid int64) } } - -func (s *InteractionService) DisLike(req *interaction.LikeActionRequest, uid int64) error { - lkType := new(likeType) - if req.VideoId != nil { - lkType.suffix = constants.VideoLikeSuffix - lkType.targetId = *req.VideoId - lkType.zset = constants.VideoLikeZset - lkType.dbType = true - } else { - lkType.suffix = constants.CommentLikeSuffix - lkType.targetId = *req.CommentId - lkType.zset = constants.CommentLikeZset - lkType.dbType = false - } - - exist, err := cache.IsLikeExist(s.ctx, lkType.targetId, uid, lkType.suffix) - if err != nil { - return err - } - if !exist { - if lkType.dbType { - err = db.IsVideoLikeExist(s.ctx, uid, lkType.targetId) - if errors.Is(err, gorm.ErrRecordNotFound) { - return errno.LikeNotExistError - } - if err != nil { - return err - } - - if err = db.CheckVideoLikeStatus(s.ctx, uid, lkType.targetId, 0); err == nil { - return errno.LikeNotExistError - } - } else { - err = db.IsCommentLikeExist(s.ctx, uid, lkType.targetId) - if errors.Is(err, gorm.ErrRecordNotFound) { - return errno.LikeNotExistError - } - if err != nil { - return err - } - - if err = db.CheckCommentLikeStatus(s.ctx, uid, lkType.targetId, 0); err == nil { - return errno.LikeNotExistError - } - } - - } - if exist { - if err = cache.DelVideoLikeCount(s.ctx, lkType.zset, lkType.targetId, uid, lkType.suffix); err != nil { - return err - } - } - - if lkType.dbType { - return db.VideoLikeStatusUpdate(s.ctx, uid, lkType.targetId, 0) - } else { - return db.CommentLikeStatusUpdate(s.ctx, uid, lkType.targetId, 0) - } -} diff --git a/cmd/interaction/service/like_list.go b/cmd/interaction/service/like_list.go index 5d5bd748..49a70491 100644 --- a/cmd/interaction/service/like_list.go +++ b/cmd/interaction/service/like_list.go @@ -3,34 +3,59 @@ package service import ( "bibi/cmd/interaction/dal/cache" "bibi/cmd/interaction/dal/db" + "bibi/cmd/interaction/rpc" + "bibi/kitex_gen/base" "bibi/kitex_gen/interaction" + "bibi/kitex_gen/video" "bibi/pkg/constants" + "bibi/pkg/errno" "errors" "gorm.io/gorm" ) -func (s *InteractionService) LikeVideoList(req *interaction.LikeListRequest, uid int64) ([]int64, error) { +func (s *InteractionService) LikeVideoList(req *interaction.LikeListRequest, uid int64) ([]*base.Video, int64, error) { //缓存未过期 - videoIdList, err := cache.GetUserLikeVideos(s.ctx, uid, constants.VideoLikeSuffix) + allVideoIdList, err := cache.GetUserLikeVideos(s.ctx, uid, constants.VideoLikeSuffix) if err != nil { - return nil, err - } - if len(videoIdList) != 0 { - return videoIdList, nil + return nil, 0, err } //缓存过期 - videoIdList, err = db.GetVideoByUid(s.ctx, uid) + allVideoIdList, err = db.GetVideoByUid(s.ctx, uid) if errors.Is(err, gorm.ErrRecordNotFound) { - return nil, nil + return nil, 0, nil } if err != nil { - return nil, err + return nil, 0, err } //将mysql数据存入redis缓存 - err = cache.AddLikeList(s.ctx, videoIdList, uid, constants.VideoLikeSuffix) + err = cache.AddLikeList(s.ctx, allVideoIdList, uid, constants.VideoLikeSuffix) if err != nil { - return nil, err + return nil, 0, err + } + + length := len(allVideoIdList) + var videoIdList []int64 + if length <= int(req.PageNum-1)*constants.PageSize || int(req.PageNum-1)*constants.PageSize < 0 { + return nil, 0, nil + } else { + fst := int(req.PageNum-1) * constants.PageSize + for i := fst; i < fst+constants.PageSize && i < length; i++ { + videoIdList = append(videoIdList, allVideoIdList[i]) + } + } + + rpcResp, err := rpc.VideoGetByIdList(s.ctx, &video.GetVideoByIdListRequest{ + VideoIdList: videoIdList, + UserId: req.UserId, + }) + if rpcResp.Base.Code != errno.SuccessCode { + return nil, 0, errno.NewErrNo(rpcResp.Base.Code, rpcResp.Base.Msg) + } + videoCount := rpcResp.Count + videosResp := make([]*base.Video, len(rpcResp.VideoList)) + for i, v := range rpcResp.VideoList { + videosResp[i] = v } - return videoIdList, nil + return videosResp, videoCount, nil } diff --git a/cmd/user/handler.go b/cmd/user/handler.go index 894397fb..221c9da1 100644 --- a/cmd/user/handler.go +++ b/cmd/user/handler.go @@ -117,17 +117,12 @@ func (s *UserHandlerImpl) Switch2FA(ctx context.Context, req *user.Switch2FARequ return resp, nil } -// GetAuthor implements the UserHandlerImpl interface. -func (s *UserHandlerImpl) GetAuthor(ctx context.Context, req *user.GetUsersRequest) (resp *user.GetUsersResponse, err error) { +// GetUserList implements the UserHandlerImpl interface. +func (s *UserHandlerImpl) GetUserList(ctx context.Context, req *user.GetUsersRequest) (resp *user.GetUsersResponse, err error) { resp = new(user.GetUsersResponse) - userResp, _ := service.NewUserService(ctx).GetUserByIdList(req.UserIdList) + userResp, err := service.NewUserService(ctx).GetUserByIdList(req.UserIdList) + resp.Base = pack.BuildBaseResp(err) resp.UserList = service.BuildUsersResp(userResp) return resp, nil } - -// GetUserList implements the UserHandlerImpl interface. -func (s *UserHandlerImpl) GetUserList(ctx context.Context, req *user.GetUsersRequest) (resp *user.GetUsersResponse, err error) { - // TODO: Your code here... - return -} diff --git a/cmd/video/handler.go b/cmd/video/handler.go index 6c85f74b..9a4cb0e7 100644 --- a/cmd/video/handler.go +++ b/cmd/video/handler.go @@ -100,3 +100,17 @@ func (s *VideoHandlerImpl) HotVideo(ctx context.Context, req *video.HotVideoRequ // TODO: Your code here... return } + +// GetVideoByIdList implements the VideoHandlerImpl interface. +func (s *VideoHandlerImpl) GetVideoByIdList(ctx context.Context, req *video.GetVideoByIdListRequest) (resp *video.GetVideoByIdListResponse, err error) { + resp = new(video.GetVideoByIdListResponse) + videoResp, count, authorList, likeCountList, isLikeList, err := service.NewVideoService(ctx).ListVideoByIdList(req) + resp.Base = pack.BuildBaseResp(err) + if err != nil { + return resp, nil + } + + resp.VideoList = service.BuildVideoListResp(videoResp, authorList, likeCountList, isLikeList) + resp.Count = count + return resp, nil +} diff --git a/cmd/video/service/list_by_id_list.go b/cmd/video/service/list_by_id_list.go new file mode 100644 index 00000000..10985fbb --- /dev/null +++ b/cmd/video/service/list_by_id_list.go @@ -0,0 +1,76 @@ +package service + +import ( + "bibi/cmd/video/dal/db" + "bibi/cmd/video/rpc" + "bibi/kitex_gen/base" + "bibi/kitex_gen/interaction" + "bibi/kitex_gen/user" + "bibi/kitex_gen/video" + "bibi/pkg/errno" + "golang.org/x/sync/errgroup" +) + +func (s *VideoService) ListVideoByIdList(req *video.GetVideoByIdListRequest) (*[]db.Video, int64, []*base.User, []int64, []int64, error) { + videoList, err := db.GetVideoByIdList(s.ctx, req.VideoIdList) + count := int64(len(videoList)) + if err != nil { + return nil, 0, nil, nil, nil, err + } + + videoIdList := make([]int64, len(videoList)) + authorIdList := make([]int64, len(videoList)) + var isLikeList []int64 + var likeCountList []int64 + var authorList []*base.User + for i, v := range videoList { + videoIdList[i] = v.ID + authorIdList[i] = v.Uid + } + var eg errgroup.Group + eg.Go(func() error { + rpcResp, err := rpc.GetLikeCountByIdList(s.ctx, &interaction.GetLikesCountByVideoIdListRequest{ + VideoId: videoIdList, + }) + if err != nil { + return err + } + if rpcResp.Base.Code != errno.SuccessCode { + return errno.NewErrNo(rpcResp.Base.Code, rpcResp.Base.Msg) + } + likeCountList = rpcResp.LikeCountList + return nil + }) + eg.Go(func() error { + rpcResp, err := rpc.UserGetUserList(s.ctx, &user.GetUsersRequest{ + UserIdList: authorIdList, + }) + if err != nil { + return err + } + if rpcResp.Base.Code != errno.SuccessCode { + return errno.NewErrNo(rpcResp.Base.Code, rpcResp.Base.Msg) + } + authorList = rpcResp.UserList + return nil + }) + eg.Go(func() error { + rpcResp, err := rpc.GetIsLikeByIdList(s.ctx, &interaction.GetIsLikeByVideoIdListRequest{ + VideoId: videoIdList, + UserId: req.UserId, + }) + if err != nil { + return err + } + if rpcResp.Base.Code != errno.SuccessCode { + return errno.NewErrNo(rpcResp.Base.Code, rpcResp.Base.Msg) + } + isLikeList = rpcResp.IsLikeList + return nil + }) + if err = eg.Wait(); err != nil { + return nil, 0, nil, nil, nil, err + } + + return &videoList, count, authorList, likeCountList, isLikeList, nil +} diff --git a/cmd/video/service/list_video.go b/cmd/video/service/list_by_user_id.go similarity index 72% rename from cmd/video/service/list_video.go rename to cmd/video/service/list_by_user_id.go index 221f7c46..4951660c 100644 --- a/cmd/video/service/list_video.go +++ b/cmd/video/service/list_by_user_id.go @@ -7,6 +7,7 @@ import ( "bibi/kitex_gen/interaction" "bibi/kitex_gen/user" "bibi/kitex_gen/video" + "bibi/pkg/errno" "golang.org/x/sync/errgroup" ) @@ -18,8 +19,7 @@ func (s *VideoService) ListVideo(req *video.ListUserVideoRequest) (*[]db.Video, videoIdList := make([]int64, len(*videoList)) authorIdList := make([]int64, len(*videoList)) - //likeCountList := make([]int64, len(*videoResp)) - //authorList := make([]*user.User, len(*videoResp)) + var isLikeList []int64 var likeCountList []int64 var authorList []*base.User for i, v := range *videoList { @@ -47,15 +47,23 @@ func (s *VideoService) ListVideo(req *video.ListUserVideoRequest) (*[]db.Video, authorList = rpcResp.UserList return nil }) - //eg.Go(func() error { - // rpcResp,err:=rpc.GetIsLikeByIdList(ctx,&interaction.GetIsLikeByVideoIdListRequest{ - // VideoId: videoIdList, - // UserId:, - // }) - //}) + eg.Go(func() error { + rpcResp, err := rpc.GetIsLikeByIdList(s.ctx, &interaction.GetIsLikeByVideoIdListRequest{ + VideoId: videoIdList, + UserId: req.UserId, + }) + if err != nil { + return err + } + if rpcResp.Base.Code != errno.SuccessCode { + return errno.NewErrNo(rpcResp.Base.Code, rpcResp.Base.Msg) + } + isLikeList = rpcResp.IsLikeList + return nil + }) if err := eg.Wait(); err != nil { return nil, 0, nil, nil, nil, err } - return videoList, count, authorList, likeCountList, nil, nil + return videoList, count, authorList, likeCountList, isLikeList, nil } diff --git a/idl/api.thrift b/idl/api.thrift index 37f70e52..eff69305 100644 --- a/idl/api.thrift +++ b/idl/api.thrift @@ -105,7 +105,7 @@ struct Video{ 6:string cover_url, 7:i64 like_count, 8:i64 comment_count, - 9:i64 is_like, + 9:bool is_like, 10:string publish_time, } diff --git a/idl/user.thrift b/idl/user.thrift index 861731fb..b490ef15 100644 --- a/idl/user.thrift +++ b/idl/user.thrift @@ -68,7 +68,8 @@ struct GetUsersRequest{ } struct GetUsersResponse{ - 1:list user_list, + 1:base.BaseResp base, + 2:list user_list, } service UserHandler { diff --git a/idl/video.thrift b/idl/video.thrift index d33f5d9e..c78a6f43 100644 --- a/idl/video.thrift +++ b/idl/video.thrift @@ -44,9 +44,23 @@ struct HotVideoResponse{ 2:optional list video_list, } + +//rpc +struct GetVideoByIdListRequest{ + 1:list video_id_list, + 2:i64 user_id, +} + +struct GetVideoByIdListResponse{ + 1:base.BaseResp base, + 2:list video_list, + 3:i64 count, +} + service VideoHandler{ PutVideoResponse PutVideo(1:PutVideoRequest req), ListUserVideoResponse ListVideo(1:ListUserVideoRequest req), SearchVideoResponse SearchVideo(1:SearchVideoRequest req), HotVideoResponse HotVideo(1:HotVideoRequest req), + GetVideoByIdListResponse GetVideoByIdList(1:GetVideoByIdListRequest req), } \ No newline at end of file diff --git a/kitex_gen/user/k-user.go b/kitex_gen/user/k-user.go index 8d5f3f5e..ca7242be 100644 --- a/kitex_gen/user/k-user.go +++ b/kitex_gen/user/k-user.go @@ -2030,7 +2030,7 @@ func (p *GetUsersResponse) FastRead(buf []byte) (int, error) { } switch fieldId { case 1: - if fieldTypeId == thrift.LIST { + if fieldTypeId == thrift.STRUCT { l, err = p.FastReadField1(buf[offset:]) offset += l if err != nil { @@ -2043,6 +2043,20 @@ func (p *GetUsersResponse) FastRead(buf []byte) (int, error) { goto SkipFieldError } } + case 2: + if fieldTypeId == thrift.LIST { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } default: l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) offset += l @@ -2081,6 +2095,19 @@ ReadStructEndError: func (p *GetUsersResponse) FastReadField1(buf []byte) (int, error) { offset := 0 + tmp := base.NewBaseResp() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Base = tmp + return offset, nil +} + +func (p *GetUsersResponse) FastReadField2(buf []byte) (int, error) { + offset := 0 + _, size, l, err := bthrift.Binary.ReadListBegin(buf[offset:]) offset += l if err != nil { @@ -2115,6 +2142,7 @@ func (p *GetUsersResponse) FastWriteNocopy(buf []byte, binaryWriter bthrift.Bina offset += bthrift.Binary.WriteStructBegin(buf[offset:], "GetUsersResponse") if p != nil { offset += p.fastWriteField1(buf[offset:], binaryWriter) + offset += p.fastWriteField2(buf[offset:], binaryWriter) } offset += bthrift.Binary.WriteFieldStop(buf[offset:]) offset += bthrift.Binary.WriteStructEnd(buf[offset:]) @@ -2126,6 +2154,7 @@ func (p *GetUsersResponse) BLength() int { l += bthrift.Binary.StructBeginLength("GetUsersResponse") if p != nil { l += p.field1Length() + l += p.field2Length() } l += bthrift.Binary.FieldStopLength() l += bthrift.Binary.StructEndLength() @@ -2134,7 +2163,15 @@ func (p *GetUsersResponse) BLength() int { func (p *GetUsersResponse) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { offset := 0 - offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "user_list", thrift.LIST, 1) + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "base", thrift.STRUCT, 1) + offset += p.Base.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *GetUsersResponse) fastWriteField2(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "user_list", thrift.LIST, 2) listBeginOffset := offset offset += bthrift.Binary.ListBeginLength(thrift.STRUCT, 0) var length int @@ -2150,7 +2187,15 @@ func (p *GetUsersResponse) fastWriteField1(buf []byte, binaryWriter bthrift.Bina func (p *GetUsersResponse) field1Length() int { l := 0 - l += bthrift.Binary.FieldBeginLength("user_list", thrift.LIST, 1) + l += bthrift.Binary.FieldBeginLength("base", thrift.STRUCT, 1) + l += p.Base.BLength() + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *GetUsersResponse) field2Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("user_list", thrift.LIST, 2) l += bthrift.Binary.ListBeginLength(thrift.STRUCT, len(p.UserList)) for _, v := range p.UserList { l += v.BLength() diff --git a/kitex_gen/user/user.go b/kitex_gen/user/user.go index 3720e72f..62acb087 100644 --- a/kitex_gen/user/user.go +++ b/kitex_gen/user/user.go @@ -2558,7 +2558,8 @@ func (p *GetUsersRequest) Field1DeepEqual(src []int64) bool { } type GetUsersResponse struct { - UserList []*base.User `thrift:"user_list,1" frugal:"1,default,list" json:"user_list"` + Base *base.BaseResp `thrift:"base,1" frugal:"1,default,base.BaseResp" json:"base"` + UserList []*base.User `thrift:"user_list,2" frugal:"2,default,list" json:"user_list"` } func NewGetUsersResponse() *GetUsersResponse { @@ -2569,15 +2570,32 @@ func (p *GetUsersResponse) InitDefault() { *p = GetUsersResponse{} } +var GetUsersResponse_Base_DEFAULT *base.BaseResp + +func (p *GetUsersResponse) GetBase() (v *base.BaseResp) { + if !p.IsSetBase() { + return GetUsersResponse_Base_DEFAULT + } + return p.Base +} + func (p *GetUsersResponse) GetUserList() (v []*base.User) { return p.UserList } +func (p *GetUsersResponse) SetBase(val *base.BaseResp) { + p.Base = val +} func (p *GetUsersResponse) SetUserList(val []*base.User) { p.UserList = val } var fieldIDToName_GetUsersResponse = map[int16]string{ - 1: "user_list", + 1: "base", + 2: "user_list", +} + +func (p *GetUsersResponse) IsSetBase() bool { + return p.Base != nil } func (p *GetUsersResponse) Read(iprot thrift.TProtocol) (err error) { @@ -2600,13 +2618,21 @@ func (p *GetUsersResponse) Read(iprot thrift.TProtocol) (err error) { switch fieldId { case 1: - if fieldTypeId == thrift.LIST { + if fieldTypeId == thrift.STRUCT { if err = p.ReadField1(iprot); err != nil { goto ReadFieldError } } else if err = iprot.Skip(fieldTypeId); err != nil { goto SkipFieldError } + case 2: + if fieldTypeId == thrift.LIST { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } default: if err = iprot.Skip(fieldTypeId); err != nil { goto SkipFieldError @@ -2637,6 +2663,13 @@ ReadStructEndError: } func (p *GetUsersResponse) ReadField1(iprot thrift.TProtocol) error { + p.Base = base.NewBaseResp() + if err := p.Base.Read(iprot); err != nil { + return err + } + return nil +} +func (p *GetUsersResponse) ReadField2(iprot thrift.TProtocol) error { _, size, err := iprot.ReadListBegin() if err != nil { return err @@ -2666,6 +2699,10 @@ func (p *GetUsersResponse) Write(oprot thrift.TProtocol) (err error) { fieldId = 1 goto WriteFieldError } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } } if err = oprot.WriteFieldStop(); err != nil { goto WriteFieldStopError @@ -2685,7 +2722,24 @@ WriteStructEndError: } func (p *GetUsersResponse) writeField1(oprot thrift.TProtocol) (err error) { - if err = oprot.WriteFieldBegin("user_list", thrift.LIST, 1); err != nil { + if err = oprot.WriteFieldBegin("base", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Base.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *GetUsersResponse) writeField2(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("user_list", thrift.LIST, 2); err != nil { goto WriteFieldBeginError } if err := oprot.WriteListBegin(thrift.STRUCT, len(p.UserList)); err != nil { @@ -2704,9 +2758,9 @@ func (p *GetUsersResponse) writeField1(oprot thrift.TProtocol) (err error) { } return nil WriteFieldBeginError: - return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) WriteFieldEndError: - return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) } func (p *GetUsersResponse) String() string { @@ -2723,13 +2777,23 @@ func (p *GetUsersResponse) DeepEqual(ano *GetUsersResponse) bool { } else if p == nil || ano == nil { return false } - if !p.Field1DeepEqual(ano.UserList) { + if !p.Field1DeepEqual(ano.Base) { + return false + } + if !p.Field2DeepEqual(ano.UserList) { return false } return true } -func (p *GetUsersResponse) Field1DeepEqual(src []*base.User) bool { +func (p *GetUsersResponse) Field1DeepEqual(src *base.BaseResp) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} +func (p *GetUsersResponse) Field2DeepEqual(src []*base.User) bool { if len(p.UserList) != len(src) { return false diff --git a/kitex_gen/video/k-video.go b/kitex_gen/video/k-video.go index 082f2e7d..1382f05a 100644 --- a/kitex_gen/video/k-video.go +++ b/kitex_gen/video/k-video.go @@ -1621,6 +1621,456 @@ func (p *HotVideoResponse) field2Length() int { return l } +func (p *GetVideoByIdListRequest) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.LIST { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_GetVideoByIdListRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *GetVideoByIdListRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + _, size, l, err := bthrift.Binary.ReadListBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + p.VideoIdList = make([]int64, 0, size) + for i := 0; i < size; i++ { + var _elem int64 + if v, l, err := bthrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + _elem = v + + } + + p.VideoIdList = append(p.VideoIdList, _elem) + } + if l, err := bthrift.Binary.ReadListEnd(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + return offset, nil +} + +func (p *GetVideoByIdListRequest) FastReadField2(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.UserId = v + + } + return offset, nil +} + +// for compatibility +func (p *GetVideoByIdListRequest) FastWrite(buf []byte) int { + return 0 +} + +func (p *GetVideoByIdListRequest) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "GetVideoByIdListRequest") + if p != nil { + offset += p.fastWriteField2(buf[offset:], binaryWriter) + offset += p.fastWriteField1(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *GetVideoByIdListRequest) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("GetVideoByIdListRequest") + if p != nil { + l += p.field1Length() + l += p.field2Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *GetVideoByIdListRequest) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "video_id_list", thrift.LIST, 1) + listBeginOffset := offset + offset += bthrift.Binary.ListBeginLength(thrift.I64, 0) + var length int + for _, v := range p.VideoIdList { + length++ + offset += bthrift.Binary.WriteI64(buf[offset:], v) + + } + bthrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.I64, length) + offset += bthrift.Binary.WriteListEnd(buf[offset:]) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *GetVideoByIdListRequest) fastWriteField2(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "user_id", thrift.I64, 2) + offset += bthrift.Binary.WriteI64(buf[offset:], p.UserId) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *GetVideoByIdListRequest) field1Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("video_id_list", thrift.LIST, 1) + l += bthrift.Binary.ListBeginLength(thrift.I64, len(p.VideoIdList)) + var tmpV int64 + l += bthrift.Binary.I64Length(int64(tmpV)) * len(p.VideoIdList) + l += bthrift.Binary.ListEndLength() + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *GetVideoByIdListRequest) field2Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("user_id", thrift.I64, 2) + l += bthrift.Binary.I64Length(p.UserId) + + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *GetVideoByIdListResponse) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.LIST { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 3: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField3(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_GetVideoByIdListResponse[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *GetVideoByIdListResponse) FastReadField1(buf []byte) (int, error) { + offset := 0 + + tmp := base.NewBaseResp() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Base = tmp + return offset, nil +} + +func (p *GetVideoByIdListResponse) FastReadField2(buf []byte) (int, error) { + offset := 0 + + _, size, l, err := bthrift.Binary.ReadListBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + p.VideoList = make([]*base.Video, 0, size) + for i := 0; i < size; i++ { + _elem := base.NewVideo() + if l, err := _elem.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + + p.VideoList = append(p.VideoList, _elem) + } + if l, err := bthrift.Binary.ReadListEnd(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + return offset, nil +} + +func (p *GetVideoByIdListResponse) FastReadField3(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.Count = v + + } + return offset, nil +} + +// for compatibility +func (p *GetVideoByIdListResponse) FastWrite(buf []byte) int { + return 0 +} + +func (p *GetVideoByIdListResponse) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "GetVideoByIdListResponse") + if p != nil { + offset += p.fastWriteField3(buf[offset:], binaryWriter) + offset += p.fastWriteField1(buf[offset:], binaryWriter) + offset += p.fastWriteField2(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *GetVideoByIdListResponse) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("GetVideoByIdListResponse") + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field3Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *GetVideoByIdListResponse) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "base", thrift.STRUCT, 1) + offset += p.Base.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *GetVideoByIdListResponse) fastWriteField2(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "video_list", thrift.LIST, 2) + listBeginOffset := offset + offset += bthrift.Binary.ListBeginLength(thrift.STRUCT, 0) + var length int + for _, v := range p.VideoList { + length++ + offset += v.FastWriteNocopy(buf[offset:], binaryWriter) + } + bthrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRUCT, length) + offset += bthrift.Binary.WriteListEnd(buf[offset:]) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *GetVideoByIdListResponse) fastWriteField3(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "count", thrift.I64, 3) + offset += bthrift.Binary.WriteI64(buf[offset:], p.Count) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *GetVideoByIdListResponse) field1Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("base", thrift.STRUCT, 1) + l += p.Base.BLength() + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *GetVideoByIdListResponse) field2Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("video_list", thrift.LIST, 2) + l += bthrift.Binary.ListBeginLength(thrift.STRUCT, len(p.VideoList)) + for _, v := range p.VideoList { + l += v.BLength() + } + l += bthrift.Binary.ListEndLength() + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *GetVideoByIdListResponse) field3Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("count", thrift.I64, 3) + l += bthrift.Binary.I64Length(p.Count) + + l += bthrift.Binary.FieldEndLength() + return l +} + func (p *VideoHandlerPutVideoArgs) FastRead(buf []byte) (int, error) { var err error var offset int @@ -2653,6 +3103,264 @@ func (p *VideoHandlerHotVideoResult) field0Length() int { return l } +func (p *VideoHandlerGetVideoByIdListArgs) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerGetVideoByIdListArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *VideoHandlerGetVideoByIdListArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + + tmp := NewGetVideoByIdListRequest() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Req = tmp + return offset, nil +} + +// for compatibility +func (p *VideoHandlerGetVideoByIdListArgs) FastWrite(buf []byte) int { + return 0 +} + +func (p *VideoHandlerGetVideoByIdListArgs) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "GetVideoByIdList_args") + if p != nil { + offset += p.fastWriteField1(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *VideoHandlerGetVideoByIdListArgs) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("GetVideoByIdList_args") + if p != nil { + l += p.field1Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *VideoHandlerGetVideoByIdListArgs) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "req", thrift.STRUCT, 1) + offset += p.Req.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *VideoHandlerGetVideoByIdListArgs) field1Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("req", thrift.STRUCT, 1) + l += p.Req.BLength() + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *VideoHandlerGetVideoByIdListResult) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField0(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerGetVideoByIdListResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *VideoHandlerGetVideoByIdListResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + + tmp := NewGetVideoByIdListResponse() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = tmp + return offset, nil +} + +// for compatibility +func (p *VideoHandlerGetVideoByIdListResult) FastWrite(buf []byte) int { + return 0 +} + +func (p *VideoHandlerGetVideoByIdListResult) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "GetVideoByIdList_result") + if p != nil { + offset += p.fastWriteField0(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *VideoHandlerGetVideoByIdListResult) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("GetVideoByIdList_result") + if p != nil { + l += p.field0Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *VideoHandlerGetVideoByIdListResult) fastWriteField0(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetSuccess() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "success", thrift.STRUCT, 0) + offset += p.Success.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *VideoHandlerGetVideoByIdListResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += bthrift.Binary.FieldBeginLength("success", thrift.STRUCT, 0) + l += p.Success.BLength() + l += bthrift.Binary.FieldEndLength() + } + return l +} + func (p *VideoHandlerPutVideoArgs) GetFirstArgument() interface{} { return p.Req } @@ -2684,3 +3392,11 @@ func (p *VideoHandlerHotVideoArgs) GetFirstArgument() interface{} { func (p *VideoHandlerHotVideoResult) GetResult() interface{} { return p.Success } + +func (p *VideoHandlerGetVideoByIdListArgs) GetFirstArgument() interface{} { + return p.Req +} + +func (p *VideoHandlerGetVideoByIdListResult) GetResult() interface{} { + return p.Success +} diff --git a/kitex_gen/video/video.go b/kitex_gen/video/video.go index 82e8122a..702e2826 100644 --- a/kitex_gen/video/video.go +++ b/kitex_gen/video/video.go @@ -2042,6 +2042,559 @@ func (p *HotVideoResponse) Field2DeepEqual(src []*base.Video) bool { return true } +type GetVideoByIdListRequest struct { + VideoIdList []int64 `thrift:"video_id_list,1" frugal:"1,default,list" json:"video_id_list"` + UserId int64 `thrift:"user_id,2" frugal:"2,default,i64" json:"user_id"` +} + +func NewGetVideoByIdListRequest() *GetVideoByIdListRequest { + return &GetVideoByIdListRequest{} +} + +func (p *GetVideoByIdListRequest) InitDefault() { + *p = GetVideoByIdListRequest{} +} + +func (p *GetVideoByIdListRequest) GetVideoIdList() (v []int64) { + return p.VideoIdList +} + +func (p *GetVideoByIdListRequest) GetUserId() (v int64) { + return p.UserId +} +func (p *GetVideoByIdListRequest) SetVideoIdList(val []int64) { + p.VideoIdList = val +} +func (p *GetVideoByIdListRequest) SetUserId(val int64) { + p.UserId = val +} + +var fieldIDToName_GetVideoByIdListRequest = map[int16]string{ + 1: "video_id_list", + 2: "user_id", +} + +func (p *GetVideoByIdListRequest) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.LIST { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.I64 { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_GetVideoByIdListRequest[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *GetVideoByIdListRequest) ReadField1(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + p.VideoIdList = make([]int64, 0, size) + for i := 0; i < size; i++ { + + var _elem int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _elem = v + } + + p.VideoIdList = append(p.VideoIdList, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + return nil +} +func (p *GetVideoByIdListRequest) ReadField2(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + p.UserId = v + } + return nil +} + +func (p *GetVideoByIdListRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("GetVideoByIdListRequest"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *GetVideoByIdListRequest) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("video_id_list", thrift.LIST, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.I64, len(p.VideoIdList)); err != nil { + return err + } + for _, v := range p.VideoIdList { + if err := oprot.WriteI64(v); err != nil { + return err + } + } + if err := oprot.WriteListEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *GetVideoByIdListRequest) writeField2(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("user_id", thrift.I64, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(p.UserId); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} + +func (p *GetVideoByIdListRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("GetVideoByIdListRequest(%+v)", *p) + +} + +func (p *GetVideoByIdListRequest) DeepEqual(ano *GetVideoByIdListRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.VideoIdList) { + return false + } + if !p.Field2DeepEqual(ano.UserId) { + return false + } + return true +} + +func (p *GetVideoByIdListRequest) Field1DeepEqual(src []int64) bool { + + if len(p.VideoIdList) != len(src) { + return false + } + for i, v := range p.VideoIdList { + _src := src[i] + if v != _src { + return false + } + } + return true +} +func (p *GetVideoByIdListRequest) Field2DeepEqual(src int64) bool { + + if p.UserId != src { + return false + } + return true +} + +type GetVideoByIdListResponse struct { + Base *base.BaseResp `thrift:"base,1" frugal:"1,default,base.BaseResp" json:"base"` + VideoList []*base.Video `thrift:"video_list,2" frugal:"2,default,list" json:"video_list"` + Count int64 `thrift:"count,3" frugal:"3,default,i64" json:"count"` +} + +func NewGetVideoByIdListResponse() *GetVideoByIdListResponse { + return &GetVideoByIdListResponse{} +} + +func (p *GetVideoByIdListResponse) InitDefault() { + *p = GetVideoByIdListResponse{} +} + +var GetVideoByIdListResponse_Base_DEFAULT *base.BaseResp + +func (p *GetVideoByIdListResponse) GetBase() (v *base.BaseResp) { + if !p.IsSetBase() { + return GetVideoByIdListResponse_Base_DEFAULT + } + return p.Base +} + +func (p *GetVideoByIdListResponse) GetVideoList() (v []*base.Video) { + return p.VideoList +} + +func (p *GetVideoByIdListResponse) GetCount() (v int64) { + return p.Count +} +func (p *GetVideoByIdListResponse) SetBase(val *base.BaseResp) { + p.Base = val +} +func (p *GetVideoByIdListResponse) SetVideoList(val []*base.Video) { + p.VideoList = val +} +func (p *GetVideoByIdListResponse) SetCount(val int64) { + p.Count = val +} + +var fieldIDToName_GetVideoByIdListResponse = map[int16]string{ + 1: "base", + 2: "video_list", + 3: "count", +} + +func (p *GetVideoByIdListResponse) IsSetBase() bool { + return p.Base != nil +} + +func (p *GetVideoByIdListResponse) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.LIST { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 3: + if fieldTypeId == thrift.I64 { + if err = p.ReadField3(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_GetVideoByIdListResponse[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *GetVideoByIdListResponse) ReadField1(iprot thrift.TProtocol) error { + p.Base = base.NewBaseResp() + if err := p.Base.Read(iprot); err != nil { + return err + } + return nil +} +func (p *GetVideoByIdListResponse) ReadField2(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + p.VideoList = make([]*base.Video, 0, size) + for i := 0; i < size; i++ { + _elem := base.NewVideo() + if err := _elem.Read(iprot); err != nil { + return err + } + + p.VideoList = append(p.VideoList, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + return nil +} +func (p *GetVideoByIdListResponse) ReadField3(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + p.Count = v + } + return nil +} + +func (p *GetVideoByIdListResponse) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("GetVideoByIdListResponse"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField3(oprot); err != nil { + fieldId = 3 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *GetVideoByIdListResponse) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("base", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Base.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *GetVideoByIdListResponse) writeField2(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("video_list", thrift.LIST, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.STRUCT, len(p.VideoList)); err != nil { + return err + } + for _, v := range p.VideoList { + if err := v.Write(oprot); err != nil { + return err + } + } + if err := oprot.WriteListEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} + +func (p *GetVideoByIdListResponse) writeField3(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("count", thrift.I64, 3); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(p.Count); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) +} + +func (p *GetVideoByIdListResponse) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("GetVideoByIdListResponse(%+v)", *p) + +} + +func (p *GetVideoByIdListResponse) DeepEqual(ano *GetVideoByIdListResponse) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Base) { + return false + } + if !p.Field2DeepEqual(ano.VideoList) { + return false + } + if !p.Field3DeepEqual(ano.Count) { + return false + } + return true +} + +func (p *GetVideoByIdListResponse) Field1DeepEqual(src *base.BaseResp) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} +func (p *GetVideoByIdListResponse) Field2DeepEqual(src []*base.Video) bool { + + if len(p.VideoList) != len(src) { + return false + } + for i, v := range p.VideoList { + _src := src[i] + if !v.DeepEqual(_src) { + return false + } + } + return true +} +func (p *GetVideoByIdListResponse) Field3DeepEqual(src int64) bool { + + if p.Count != src { + return false + } + return true +} + type VideoHandler interface { PutVideo(ctx context.Context, req *PutVideoRequest) (r *PutVideoResponse, err error) @@ -2050,6 +2603,8 @@ type VideoHandler interface { SearchVideo(ctx context.Context, req *SearchVideoRequest) (r *SearchVideoResponse, err error) HotVideo(ctx context.Context, req *HotVideoRequest) (r *HotVideoResponse, err error) + + GetVideoByIdList(ctx context.Context, req *GetVideoByIdListRequest) (r *GetVideoByIdListResponse, err error) } type VideoHandlerClient struct { @@ -2114,6 +2669,15 @@ func (p *VideoHandlerClient) HotVideo(ctx context.Context, req *HotVideoRequest) } return _result.GetSuccess(), nil } +func (p *VideoHandlerClient) GetVideoByIdList(ctx context.Context, req *GetVideoByIdListRequest) (r *GetVideoByIdListResponse, err error) { + var _args VideoHandlerGetVideoByIdListArgs + _args.Req = req + var _result VideoHandlerGetVideoByIdListResult + if err = p.Client_().Call(ctx, "GetVideoByIdList", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} type VideoHandlerProcessor struct { processorMap map[string]thrift.TProcessorFunction @@ -2139,6 +2703,7 @@ func NewVideoHandlerProcessor(handler VideoHandler) *VideoHandlerProcessor { self.AddToProcessorMap("ListVideo", &videoHandlerProcessorListVideo{handler: handler}) self.AddToProcessorMap("SearchVideo", &videoHandlerProcessorSearchVideo{handler: handler}) self.AddToProcessorMap("HotVideo", &videoHandlerProcessorHotVideo{handler: handler}) + self.AddToProcessorMap("GetVideoByIdList", &videoHandlerProcessorGetVideoByIdList{handler: handler}) return self } func (p *VideoHandlerProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { @@ -2159,16 +2724,160 @@ func (p *VideoHandlerProcessor) Process(ctx context.Context, iprot, oprot thrift return false, x } -type videoHandlerProcessorPutVideo struct { +type videoHandlerProcessorPutVideo struct { + handler VideoHandler +} + +func (p *videoHandlerProcessorPutVideo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := VideoHandlerPutVideoArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("PutVideo", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := VideoHandlerPutVideoResult{} + var retval *PutVideoResponse + if retval, err2 = p.handler.PutVideo(ctx, args.Req); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing PutVideo: "+err2.Error()) + oprot.WriteMessageBegin("PutVideo", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("PutVideo", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + +type videoHandlerProcessorListVideo struct { + handler VideoHandler +} + +func (p *videoHandlerProcessorListVideo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := VideoHandlerListVideoArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("ListVideo", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := VideoHandlerListVideoResult{} + var retval *ListUserVideoResponse + if retval, err2 = p.handler.ListVideo(ctx, args.Req); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ListVideo: "+err2.Error()) + oprot.WriteMessageBegin("ListVideo", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("ListVideo", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + +type videoHandlerProcessorSearchVideo struct { + handler VideoHandler +} + +func (p *videoHandlerProcessorSearchVideo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := VideoHandlerSearchVideoArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("SearchVideo", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := VideoHandlerSearchVideoResult{} + var retval *SearchVideoResponse + if retval, err2 = p.handler.SearchVideo(ctx, args.Req); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing SearchVideo: "+err2.Error()) + oprot.WriteMessageBegin("SearchVideo", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("SearchVideo", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + +type videoHandlerProcessorHotVideo struct { handler VideoHandler } -func (p *videoHandlerProcessorPutVideo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := VideoHandlerPutVideoArgs{} +func (p *videoHandlerProcessorHotVideo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := VideoHandlerHotVideoArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("PutVideo", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("HotVideo", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush(ctx) @@ -2177,11 +2886,11 @@ func (p *videoHandlerProcessorPutVideo) Process(ctx context.Context, seqId int32 iprot.ReadMessageEnd() var err2 error - result := VideoHandlerPutVideoResult{} - var retval *PutVideoResponse - if retval, err2 = p.handler.PutVideo(ctx, args.Req); err2 != nil { - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing PutVideo: "+err2.Error()) - oprot.WriteMessageBegin("PutVideo", thrift.EXCEPTION, seqId) + result := VideoHandlerHotVideoResult{} + var retval *HotVideoResponse + if retval, err2 = p.handler.HotVideo(ctx, args.Req); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing HotVideo: "+err2.Error()) + oprot.WriteMessageBegin("HotVideo", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush(ctx) @@ -2189,7 +2898,7 @@ func (p *videoHandlerProcessorPutVideo) Process(ctx context.Context, seqId int32 } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("PutVideo", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("HotVideo", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -2207,16 +2916,16 @@ func (p *videoHandlerProcessorPutVideo) Process(ctx context.Context, seqId int32 return true, err } -type videoHandlerProcessorListVideo struct { +type videoHandlerProcessorGetVideoByIdList struct { handler VideoHandler } -func (p *videoHandlerProcessorListVideo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := VideoHandlerListVideoArgs{} +func (p *videoHandlerProcessorGetVideoByIdList) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := VideoHandlerGetVideoByIdListArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("ListVideo", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("GetVideoByIdList", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush(ctx) @@ -2225,11 +2934,11 @@ func (p *videoHandlerProcessorListVideo) Process(ctx context.Context, seqId int3 iprot.ReadMessageEnd() var err2 error - result := VideoHandlerListVideoResult{} - var retval *ListUserVideoResponse - if retval, err2 = p.handler.ListVideo(ctx, args.Req); err2 != nil { - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ListVideo: "+err2.Error()) - oprot.WriteMessageBegin("ListVideo", thrift.EXCEPTION, seqId) + result := VideoHandlerGetVideoByIdListResult{} + var retval *GetVideoByIdListResponse + if retval, err2 = p.handler.GetVideoByIdList(ctx, args.Req); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetVideoByIdList: "+err2.Error()) + oprot.WriteMessageBegin("GetVideoByIdList", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush(ctx) @@ -2237,7 +2946,7 @@ func (p *videoHandlerProcessorListVideo) Process(ctx context.Context, seqId int3 } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("ListVideo", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("GetVideoByIdList", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -2249,141 +2958,385 @@ func (p *videoHandlerProcessorListVideo) Process(ctx context.Context, seqId int3 if err2 = oprot.Flush(ctx); err == nil && err2 != nil { err = err2 } - if err != nil { - return + if err != nil { + return + } + return true, err +} + +type VideoHandlerPutVideoArgs struct { + Req *PutVideoRequest `thrift:"req,1" frugal:"1,default,PutVideoRequest" json:"req"` +} + +func NewVideoHandlerPutVideoArgs() *VideoHandlerPutVideoArgs { + return &VideoHandlerPutVideoArgs{} +} + +func (p *VideoHandlerPutVideoArgs) InitDefault() { + *p = VideoHandlerPutVideoArgs{} +} + +var VideoHandlerPutVideoArgs_Req_DEFAULT *PutVideoRequest + +func (p *VideoHandlerPutVideoArgs) GetReq() (v *PutVideoRequest) { + if !p.IsSetReq() { + return VideoHandlerPutVideoArgs_Req_DEFAULT + } + return p.Req +} +func (p *VideoHandlerPutVideoArgs) SetReq(val *PutVideoRequest) { + p.Req = val +} + +var fieldIDToName_VideoHandlerPutVideoArgs = map[int16]string{ + 1: "req", +} + +func (p *VideoHandlerPutVideoArgs) IsSetReq() bool { + return p.Req != nil +} + +func (p *VideoHandlerPutVideoArgs) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerPutVideoArgs[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *VideoHandlerPutVideoArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = NewPutVideoRequest() + if err := p.Req.Read(iprot); err != nil { + return err + } + return nil +} + +func (p *VideoHandlerPutVideoArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("PutVideo_args"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *VideoHandlerPutVideoArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Req.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *VideoHandlerPutVideoArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("VideoHandlerPutVideoArgs(%+v)", *p) + +} + +func (p *VideoHandlerPutVideoArgs) DeepEqual(ano *VideoHandlerPutVideoArgs) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Req) { + return false + } + return true +} + +func (p *VideoHandlerPutVideoArgs) Field1DeepEqual(src *PutVideoRequest) bool { + + if !p.Req.DeepEqual(src) { + return false + } + return true +} + +type VideoHandlerPutVideoResult struct { + Success *PutVideoResponse `thrift:"success,0,optional" frugal:"0,optional,PutVideoResponse" json:"success,omitempty"` +} + +func NewVideoHandlerPutVideoResult() *VideoHandlerPutVideoResult { + return &VideoHandlerPutVideoResult{} +} + +func (p *VideoHandlerPutVideoResult) InitDefault() { + *p = VideoHandlerPutVideoResult{} +} + +var VideoHandlerPutVideoResult_Success_DEFAULT *PutVideoResponse + +func (p *VideoHandlerPutVideoResult) GetSuccess() (v *PutVideoResponse) { + if !p.IsSetSuccess() { + return VideoHandlerPutVideoResult_Success_DEFAULT + } + return p.Success +} +func (p *VideoHandlerPutVideoResult) SetSuccess(x interface{}) { + p.Success = x.(*PutVideoResponse) +} + +var fieldIDToName_VideoHandlerPutVideoResult = map[int16]string{ + 0: "success", +} + +func (p *VideoHandlerPutVideoResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *VideoHandlerPutVideoResult) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField0(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError } - return true, err -} -type videoHandlerProcessorSearchVideo struct { - handler VideoHandler + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerPutVideoResult[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *videoHandlerProcessorSearchVideo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := VideoHandlerSearchVideoArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("SearchVideo", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush(ctx) - return false, err +func (p *VideoHandlerPutVideoResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = NewPutVideoResponse() + if err := p.Success.Read(iprot); err != nil { + return err } + return nil +} - iprot.ReadMessageEnd() - var err2 error - result := VideoHandlerSearchVideoResult{} - var retval *SearchVideoResponse - if retval, err2 = p.handler.SearchVideo(ctx, args.Req); err2 != nil { - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing SearchVideo: "+err2.Error()) - oprot.WriteMessageBegin("SearchVideo", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush(ctx) - return true, err2 - } else { - result.Success = retval - } - if err2 = oprot.WriteMessageBegin("SearchVideo", thrift.REPLY, seqId); err2 != nil { - err = err2 - } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 +func (p *VideoHandlerPutVideoResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("PutVideo_result"); err != nil { + goto WriteStructBeginError } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } } - if err2 = oprot.Flush(ctx); err == nil && err2 != nil { - err = err2 + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError } - if err != nil { - return + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError } - return true, err + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -type videoHandlerProcessorHotVideo struct { - handler VideoHandler +func (p *VideoHandlerPutVideoResult) writeField0(oprot thrift.TProtocol) (err error) { + if p.IsSetSuccess() { + if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { + goto WriteFieldBeginError + } + if err := p.Success.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *videoHandlerProcessorHotVideo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := VideoHandlerHotVideoArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("HotVideo", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush(ctx) - return false, err +func (p *VideoHandlerPutVideoResult) String() string { + if p == nil { + return "" } + return fmt.Sprintf("VideoHandlerPutVideoResult(%+v)", *p) - iprot.ReadMessageEnd() - var err2 error - result := VideoHandlerHotVideoResult{} - var retval *HotVideoResponse - if retval, err2 = p.handler.HotVideo(ctx, args.Req); err2 != nil { - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing HotVideo: "+err2.Error()) - oprot.WriteMessageBegin("HotVideo", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush(ctx) - return true, err2 - } else { - result.Success = retval - } - if err2 = oprot.WriteMessageBegin("HotVideo", thrift.REPLY, seqId); err2 != nil { - err = err2 - } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 - } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 +} + +func (p *VideoHandlerPutVideoResult) DeepEqual(ano *VideoHandlerPutVideoResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false } - if err2 = oprot.Flush(ctx); err == nil && err2 != nil { - err = err2 + if !p.Field0DeepEqual(ano.Success) { + return false } - if err != nil { - return + return true +} + +func (p *VideoHandlerPutVideoResult) Field0DeepEqual(src *PutVideoResponse) bool { + + if !p.Success.DeepEqual(src) { + return false } - return true, err + return true } -type VideoHandlerPutVideoArgs struct { - Req *PutVideoRequest `thrift:"req,1" frugal:"1,default,PutVideoRequest" json:"req"` +type VideoHandlerListVideoArgs struct { + Req *ListUserVideoRequest `thrift:"req,1" frugal:"1,default,ListUserVideoRequest" json:"req"` } -func NewVideoHandlerPutVideoArgs() *VideoHandlerPutVideoArgs { - return &VideoHandlerPutVideoArgs{} +func NewVideoHandlerListVideoArgs() *VideoHandlerListVideoArgs { + return &VideoHandlerListVideoArgs{} } -func (p *VideoHandlerPutVideoArgs) InitDefault() { - *p = VideoHandlerPutVideoArgs{} +func (p *VideoHandlerListVideoArgs) InitDefault() { + *p = VideoHandlerListVideoArgs{} } -var VideoHandlerPutVideoArgs_Req_DEFAULT *PutVideoRequest +var VideoHandlerListVideoArgs_Req_DEFAULT *ListUserVideoRequest -func (p *VideoHandlerPutVideoArgs) GetReq() (v *PutVideoRequest) { +func (p *VideoHandlerListVideoArgs) GetReq() (v *ListUserVideoRequest) { if !p.IsSetReq() { - return VideoHandlerPutVideoArgs_Req_DEFAULT + return VideoHandlerListVideoArgs_Req_DEFAULT } return p.Req } -func (p *VideoHandlerPutVideoArgs) SetReq(val *PutVideoRequest) { +func (p *VideoHandlerListVideoArgs) SetReq(val *ListUserVideoRequest) { p.Req = val } -var fieldIDToName_VideoHandlerPutVideoArgs = map[int16]string{ +var fieldIDToName_VideoHandlerListVideoArgs = map[int16]string{ 1: "req", } -func (p *VideoHandlerPutVideoArgs) IsSetReq() bool { +func (p *VideoHandlerListVideoArgs) IsSetReq() bool { return p.Req != nil } -func (p *VideoHandlerPutVideoArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *VideoHandlerListVideoArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -2429,7 +3382,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerPutVideoArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerListVideoArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -2439,17 +3392,17 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *VideoHandlerPutVideoArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = NewPutVideoRequest() +func (p *VideoHandlerListVideoArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = NewListUserVideoRequest() if err := p.Req.Read(iprot); err != nil { return err } return nil } -func (p *VideoHandlerPutVideoArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerListVideoArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("PutVideo_args"); err != nil { + if err = oprot.WriteStructBegin("ListVideo_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -2475,7 +3428,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *VideoHandlerPutVideoArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerListVideoArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -2492,15 +3445,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *VideoHandlerPutVideoArgs) String() string { +func (p *VideoHandlerListVideoArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("VideoHandlerPutVideoArgs(%+v)", *p) + return fmt.Sprintf("VideoHandlerListVideoArgs(%+v)", *p) } -func (p *VideoHandlerPutVideoArgs) DeepEqual(ano *VideoHandlerPutVideoArgs) bool { +func (p *VideoHandlerListVideoArgs) DeepEqual(ano *VideoHandlerListVideoArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -2512,7 +3465,7 @@ func (p *VideoHandlerPutVideoArgs) DeepEqual(ano *VideoHandlerPutVideoArgs) bool return true } -func (p *VideoHandlerPutVideoArgs) Field1DeepEqual(src *PutVideoRequest) bool { +func (p *VideoHandlerListVideoArgs) Field1DeepEqual(src *ListUserVideoRequest) bool { if !p.Req.DeepEqual(src) { return false @@ -2520,39 +3473,39 @@ func (p *VideoHandlerPutVideoArgs) Field1DeepEqual(src *PutVideoRequest) bool { return true } -type VideoHandlerPutVideoResult struct { - Success *PutVideoResponse `thrift:"success,0,optional" frugal:"0,optional,PutVideoResponse" json:"success,omitempty"` +type VideoHandlerListVideoResult struct { + Success *ListUserVideoResponse `thrift:"success,0,optional" frugal:"0,optional,ListUserVideoResponse" json:"success,omitempty"` } -func NewVideoHandlerPutVideoResult() *VideoHandlerPutVideoResult { - return &VideoHandlerPutVideoResult{} +func NewVideoHandlerListVideoResult() *VideoHandlerListVideoResult { + return &VideoHandlerListVideoResult{} } -func (p *VideoHandlerPutVideoResult) InitDefault() { - *p = VideoHandlerPutVideoResult{} +func (p *VideoHandlerListVideoResult) InitDefault() { + *p = VideoHandlerListVideoResult{} } -var VideoHandlerPutVideoResult_Success_DEFAULT *PutVideoResponse +var VideoHandlerListVideoResult_Success_DEFAULT *ListUserVideoResponse -func (p *VideoHandlerPutVideoResult) GetSuccess() (v *PutVideoResponse) { +func (p *VideoHandlerListVideoResult) GetSuccess() (v *ListUserVideoResponse) { if !p.IsSetSuccess() { - return VideoHandlerPutVideoResult_Success_DEFAULT + return VideoHandlerListVideoResult_Success_DEFAULT } return p.Success } -func (p *VideoHandlerPutVideoResult) SetSuccess(x interface{}) { - p.Success = x.(*PutVideoResponse) +func (p *VideoHandlerListVideoResult) SetSuccess(x interface{}) { + p.Success = x.(*ListUserVideoResponse) } -var fieldIDToName_VideoHandlerPutVideoResult = map[int16]string{ +var fieldIDToName_VideoHandlerListVideoResult = map[int16]string{ 0: "success", } -func (p *VideoHandlerPutVideoResult) IsSetSuccess() bool { +func (p *VideoHandlerListVideoResult) IsSetSuccess() bool { return p.Success != nil } -func (p *VideoHandlerPutVideoResult) Read(iprot thrift.TProtocol) (err error) { +func (p *VideoHandlerListVideoResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -2598,7 +3551,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerPutVideoResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerListVideoResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -2608,17 +3561,17 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *VideoHandlerPutVideoResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = NewPutVideoResponse() +func (p *VideoHandlerListVideoResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = NewListUserVideoResponse() if err := p.Success.Read(iprot); err != nil { return err } return nil } -func (p *VideoHandlerPutVideoResult) Write(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerListVideoResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("PutVideo_result"); err != nil { + if err = oprot.WriteStructBegin("ListVideo_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -2644,7 +3597,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *VideoHandlerPutVideoResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerListVideoResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -2663,15 +3616,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *VideoHandlerPutVideoResult) String() string { +func (p *VideoHandlerListVideoResult) String() string { if p == nil { return "" } - return fmt.Sprintf("VideoHandlerPutVideoResult(%+v)", *p) + return fmt.Sprintf("VideoHandlerListVideoResult(%+v)", *p) } -func (p *VideoHandlerPutVideoResult) DeepEqual(ano *VideoHandlerPutVideoResult) bool { +func (p *VideoHandlerListVideoResult) DeepEqual(ano *VideoHandlerListVideoResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -2683,7 +3636,7 @@ func (p *VideoHandlerPutVideoResult) DeepEqual(ano *VideoHandlerPutVideoResult) return true } -func (p *VideoHandlerPutVideoResult) Field0DeepEqual(src *PutVideoResponse) bool { +func (p *VideoHandlerListVideoResult) Field0DeepEqual(src *ListUserVideoResponse) bool { if !p.Success.DeepEqual(src) { return false @@ -2691,39 +3644,39 @@ func (p *VideoHandlerPutVideoResult) Field0DeepEqual(src *PutVideoResponse) bool return true } -type VideoHandlerListVideoArgs struct { - Req *ListUserVideoRequest `thrift:"req,1" frugal:"1,default,ListUserVideoRequest" json:"req"` +type VideoHandlerSearchVideoArgs struct { + Req *SearchVideoRequest `thrift:"req,1" frugal:"1,default,SearchVideoRequest" json:"req"` } -func NewVideoHandlerListVideoArgs() *VideoHandlerListVideoArgs { - return &VideoHandlerListVideoArgs{} +func NewVideoHandlerSearchVideoArgs() *VideoHandlerSearchVideoArgs { + return &VideoHandlerSearchVideoArgs{} } -func (p *VideoHandlerListVideoArgs) InitDefault() { - *p = VideoHandlerListVideoArgs{} +func (p *VideoHandlerSearchVideoArgs) InitDefault() { + *p = VideoHandlerSearchVideoArgs{} } -var VideoHandlerListVideoArgs_Req_DEFAULT *ListUserVideoRequest +var VideoHandlerSearchVideoArgs_Req_DEFAULT *SearchVideoRequest -func (p *VideoHandlerListVideoArgs) GetReq() (v *ListUserVideoRequest) { +func (p *VideoHandlerSearchVideoArgs) GetReq() (v *SearchVideoRequest) { if !p.IsSetReq() { - return VideoHandlerListVideoArgs_Req_DEFAULT + return VideoHandlerSearchVideoArgs_Req_DEFAULT } return p.Req } -func (p *VideoHandlerListVideoArgs) SetReq(val *ListUserVideoRequest) { +func (p *VideoHandlerSearchVideoArgs) SetReq(val *SearchVideoRequest) { p.Req = val } -var fieldIDToName_VideoHandlerListVideoArgs = map[int16]string{ +var fieldIDToName_VideoHandlerSearchVideoArgs = map[int16]string{ 1: "req", } -func (p *VideoHandlerListVideoArgs) IsSetReq() bool { +func (p *VideoHandlerSearchVideoArgs) IsSetReq() bool { return p.Req != nil } -func (p *VideoHandlerListVideoArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *VideoHandlerSearchVideoArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -2769,7 +3722,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerListVideoArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerSearchVideoArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -2779,17 +3732,17 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *VideoHandlerListVideoArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = NewListUserVideoRequest() +func (p *VideoHandlerSearchVideoArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = NewSearchVideoRequest() if err := p.Req.Read(iprot); err != nil { return err } return nil } -func (p *VideoHandlerListVideoArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerSearchVideoArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("ListVideo_args"); err != nil { + if err = oprot.WriteStructBegin("SearchVideo_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -2815,7 +3768,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *VideoHandlerListVideoArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerSearchVideoArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -2832,15 +3785,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *VideoHandlerListVideoArgs) String() string { +func (p *VideoHandlerSearchVideoArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("VideoHandlerListVideoArgs(%+v)", *p) + return fmt.Sprintf("VideoHandlerSearchVideoArgs(%+v)", *p) } -func (p *VideoHandlerListVideoArgs) DeepEqual(ano *VideoHandlerListVideoArgs) bool { +func (p *VideoHandlerSearchVideoArgs) DeepEqual(ano *VideoHandlerSearchVideoArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -2852,7 +3805,7 @@ func (p *VideoHandlerListVideoArgs) DeepEqual(ano *VideoHandlerListVideoArgs) bo return true } -func (p *VideoHandlerListVideoArgs) Field1DeepEqual(src *ListUserVideoRequest) bool { +func (p *VideoHandlerSearchVideoArgs) Field1DeepEqual(src *SearchVideoRequest) bool { if !p.Req.DeepEqual(src) { return false @@ -2860,39 +3813,39 @@ func (p *VideoHandlerListVideoArgs) Field1DeepEqual(src *ListUserVideoRequest) b return true } -type VideoHandlerListVideoResult struct { - Success *ListUserVideoResponse `thrift:"success,0,optional" frugal:"0,optional,ListUserVideoResponse" json:"success,omitempty"` +type VideoHandlerSearchVideoResult struct { + Success *SearchVideoResponse `thrift:"success,0,optional" frugal:"0,optional,SearchVideoResponse" json:"success,omitempty"` } -func NewVideoHandlerListVideoResult() *VideoHandlerListVideoResult { - return &VideoHandlerListVideoResult{} +func NewVideoHandlerSearchVideoResult() *VideoHandlerSearchVideoResult { + return &VideoHandlerSearchVideoResult{} } -func (p *VideoHandlerListVideoResult) InitDefault() { - *p = VideoHandlerListVideoResult{} +func (p *VideoHandlerSearchVideoResult) InitDefault() { + *p = VideoHandlerSearchVideoResult{} } -var VideoHandlerListVideoResult_Success_DEFAULT *ListUserVideoResponse +var VideoHandlerSearchVideoResult_Success_DEFAULT *SearchVideoResponse -func (p *VideoHandlerListVideoResult) GetSuccess() (v *ListUserVideoResponse) { +func (p *VideoHandlerSearchVideoResult) GetSuccess() (v *SearchVideoResponse) { if !p.IsSetSuccess() { - return VideoHandlerListVideoResult_Success_DEFAULT + return VideoHandlerSearchVideoResult_Success_DEFAULT } return p.Success } -func (p *VideoHandlerListVideoResult) SetSuccess(x interface{}) { - p.Success = x.(*ListUserVideoResponse) +func (p *VideoHandlerSearchVideoResult) SetSuccess(x interface{}) { + p.Success = x.(*SearchVideoResponse) } -var fieldIDToName_VideoHandlerListVideoResult = map[int16]string{ +var fieldIDToName_VideoHandlerSearchVideoResult = map[int16]string{ 0: "success", } -func (p *VideoHandlerListVideoResult) IsSetSuccess() bool { +func (p *VideoHandlerSearchVideoResult) IsSetSuccess() bool { return p.Success != nil } -func (p *VideoHandlerListVideoResult) Read(iprot thrift.TProtocol) (err error) { +func (p *VideoHandlerSearchVideoResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -2938,7 +3891,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerListVideoResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerSearchVideoResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -2948,17 +3901,17 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *VideoHandlerListVideoResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = NewListUserVideoResponse() +func (p *VideoHandlerSearchVideoResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = NewSearchVideoResponse() if err := p.Success.Read(iprot); err != nil { return err } return nil } -func (p *VideoHandlerListVideoResult) Write(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerSearchVideoResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("ListVideo_result"); err != nil { + if err = oprot.WriteStructBegin("SearchVideo_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -2984,7 +3937,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *VideoHandlerListVideoResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerSearchVideoResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -3003,15 +3956,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *VideoHandlerListVideoResult) String() string { +func (p *VideoHandlerSearchVideoResult) String() string { if p == nil { return "" } - return fmt.Sprintf("VideoHandlerListVideoResult(%+v)", *p) + return fmt.Sprintf("VideoHandlerSearchVideoResult(%+v)", *p) } -func (p *VideoHandlerListVideoResult) DeepEqual(ano *VideoHandlerListVideoResult) bool { +func (p *VideoHandlerSearchVideoResult) DeepEqual(ano *VideoHandlerSearchVideoResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -3023,7 +3976,7 @@ func (p *VideoHandlerListVideoResult) DeepEqual(ano *VideoHandlerListVideoResult return true } -func (p *VideoHandlerListVideoResult) Field0DeepEqual(src *ListUserVideoResponse) bool { +func (p *VideoHandlerSearchVideoResult) Field0DeepEqual(src *SearchVideoResponse) bool { if !p.Success.DeepEqual(src) { return false @@ -3031,39 +3984,39 @@ func (p *VideoHandlerListVideoResult) Field0DeepEqual(src *ListUserVideoResponse return true } -type VideoHandlerSearchVideoArgs struct { - Req *SearchVideoRequest `thrift:"req,1" frugal:"1,default,SearchVideoRequest" json:"req"` +type VideoHandlerHotVideoArgs struct { + Req *HotVideoRequest `thrift:"req,1" frugal:"1,default,HotVideoRequest" json:"req"` } -func NewVideoHandlerSearchVideoArgs() *VideoHandlerSearchVideoArgs { - return &VideoHandlerSearchVideoArgs{} +func NewVideoHandlerHotVideoArgs() *VideoHandlerHotVideoArgs { + return &VideoHandlerHotVideoArgs{} } -func (p *VideoHandlerSearchVideoArgs) InitDefault() { - *p = VideoHandlerSearchVideoArgs{} +func (p *VideoHandlerHotVideoArgs) InitDefault() { + *p = VideoHandlerHotVideoArgs{} } -var VideoHandlerSearchVideoArgs_Req_DEFAULT *SearchVideoRequest +var VideoHandlerHotVideoArgs_Req_DEFAULT *HotVideoRequest -func (p *VideoHandlerSearchVideoArgs) GetReq() (v *SearchVideoRequest) { +func (p *VideoHandlerHotVideoArgs) GetReq() (v *HotVideoRequest) { if !p.IsSetReq() { - return VideoHandlerSearchVideoArgs_Req_DEFAULT + return VideoHandlerHotVideoArgs_Req_DEFAULT } return p.Req } -func (p *VideoHandlerSearchVideoArgs) SetReq(val *SearchVideoRequest) { +func (p *VideoHandlerHotVideoArgs) SetReq(val *HotVideoRequest) { p.Req = val } -var fieldIDToName_VideoHandlerSearchVideoArgs = map[int16]string{ +var fieldIDToName_VideoHandlerHotVideoArgs = map[int16]string{ 1: "req", } -func (p *VideoHandlerSearchVideoArgs) IsSetReq() bool { +func (p *VideoHandlerHotVideoArgs) IsSetReq() bool { return p.Req != nil } -func (p *VideoHandlerSearchVideoArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *VideoHandlerHotVideoArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -3109,7 +4062,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerSearchVideoArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerHotVideoArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -3119,17 +4072,17 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *VideoHandlerSearchVideoArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = NewSearchVideoRequest() +func (p *VideoHandlerHotVideoArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = NewHotVideoRequest() if err := p.Req.Read(iprot); err != nil { return err } return nil } -func (p *VideoHandlerSearchVideoArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerHotVideoArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("SearchVideo_args"); err != nil { + if err = oprot.WriteStructBegin("HotVideo_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -3155,7 +4108,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *VideoHandlerSearchVideoArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerHotVideoArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -3172,15 +4125,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *VideoHandlerSearchVideoArgs) String() string { +func (p *VideoHandlerHotVideoArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("VideoHandlerSearchVideoArgs(%+v)", *p) + return fmt.Sprintf("VideoHandlerHotVideoArgs(%+v)", *p) } -func (p *VideoHandlerSearchVideoArgs) DeepEqual(ano *VideoHandlerSearchVideoArgs) bool { +func (p *VideoHandlerHotVideoArgs) DeepEqual(ano *VideoHandlerHotVideoArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -3192,7 +4145,7 @@ func (p *VideoHandlerSearchVideoArgs) DeepEqual(ano *VideoHandlerSearchVideoArgs return true } -func (p *VideoHandlerSearchVideoArgs) Field1DeepEqual(src *SearchVideoRequest) bool { +func (p *VideoHandlerHotVideoArgs) Field1DeepEqual(src *HotVideoRequest) bool { if !p.Req.DeepEqual(src) { return false @@ -3200,39 +4153,39 @@ func (p *VideoHandlerSearchVideoArgs) Field1DeepEqual(src *SearchVideoRequest) b return true } -type VideoHandlerSearchVideoResult struct { - Success *SearchVideoResponse `thrift:"success,0,optional" frugal:"0,optional,SearchVideoResponse" json:"success,omitempty"` +type VideoHandlerHotVideoResult struct { + Success *HotVideoResponse `thrift:"success,0,optional" frugal:"0,optional,HotVideoResponse" json:"success,omitempty"` } -func NewVideoHandlerSearchVideoResult() *VideoHandlerSearchVideoResult { - return &VideoHandlerSearchVideoResult{} +func NewVideoHandlerHotVideoResult() *VideoHandlerHotVideoResult { + return &VideoHandlerHotVideoResult{} } -func (p *VideoHandlerSearchVideoResult) InitDefault() { - *p = VideoHandlerSearchVideoResult{} +func (p *VideoHandlerHotVideoResult) InitDefault() { + *p = VideoHandlerHotVideoResult{} } -var VideoHandlerSearchVideoResult_Success_DEFAULT *SearchVideoResponse +var VideoHandlerHotVideoResult_Success_DEFAULT *HotVideoResponse -func (p *VideoHandlerSearchVideoResult) GetSuccess() (v *SearchVideoResponse) { +func (p *VideoHandlerHotVideoResult) GetSuccess() (v *HotVideoResponse) { if !p.IsSetSuccess() { - return VideoHandlerSearchVideoResult_Success_DEFAULT + return VideoHandlerHotVideoResult_Success_DEFAULT } return p.Success } -func (p *VideoHandlerSearchVideoResult) SetSuccess(x interface{}) { - p.Success = x.(*SearchVideoResponse) +func (p *VideoHandlerHotVideoResult) SetSuccess(x interface{}) { + p.Success = x.(*HotVideoResponse) } -var fieldIDToName_VideoHandlerSearchVideoResult = map[int16]string{ +var fieldIDToName_VideoHandlerHotVideoResult = map[int16]string{ 0: "success", } -func (p *VideoHandlerSearchVideoResult) IsSetSuccess() bool { +func (p *VideoHandlerHotVideoResult) IsSetSuccess() bool { return p.Success != nil } -func (p *VideoHandlerSearchVideoResult) Read(iprot thrift.TProtocol) (err error) { +func (p *VideoHandlerHotVideoResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -3278,7 +4231,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerSearchVideoResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerHotVideoResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -3288,17 +4241,17 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *VideoHandlerSearchVideoResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = NewSearchVideoResponse() +func (p *VideoHandlerHotVideoResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = NewHotVideoResponse() if err := p.Success.Read(iprot); err != nil { return err } return nil } -func (p *VideoHandlerSearchVideoResult) Write(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerHotVideoResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("SearchVideo_result"); err != nil { + if err = oprot.WriteStructBegin("HotVideo_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -3324,7 +4277,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *VideoHandlerSearchVideoResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerHotVideoResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -3343,15 +4296,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *VideoHandlerSearchVideoResult) String() string { +func (p *VideoHandlerHotVideoResult) String() string { if p == nil { return "" } - return fmt.Sprintf("VideoHandlerSearchVideoResult(%+v)", *p) + return fmt.Sprintf("VideoHandlerHotVideoResult(%+v)", *p) } -func (p *VideoHandlerSearchVideoResult) DeepEqual(ano *VideoHandlerSearchVideoResult) bool { +func (p *VideoHandlerHotVideoResult) DeepEqual(ano *VideoHandlerHotVideoResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -3363,7 +4316,7 @@ func (p *VideoHandlerSearchVideoResult) DeepEqual(ano *VideoHandlerSearchVideoRe return true } -func (p *VideoHandlerSearchVideoResult) Field0DeepEqual(src *SearchVideoResponse) bool { +func (p *VideoHandlerHotVideoResult) Field0DeepEqual(src *HotVideoResponse) bool { if !p.Success.DeepEqual(src) { return false @@ -3371,39 +4324,39 @@ func (p *VideoHandlerSearchVideoResult) Field0DeepEqual(src *SearchVideoResponse return true } -type VideoHandlerHotVideoArgs struct { - Req *HotVideoRequest `thrift:"req,1" frugal:"1,default,HotVideoRequest" json:"req"` +type VideoHandlerGetVideoByIdListArgs struct { + Req *GetVideoByIdListRequest `thrift:"req,1" frugal:"1,default,GetVideoByIdListRequest" json:"req"` } -func NewVideoHandlerHotVideoArgs() *VideoHandlerHotVideoArgs { - return &VideoHandlerHotVideoArgs{} +func NewVideoHandlerGetVideoByIdListArgs() *VideoHandlerGetVideoByIdListArgs { + return &VideoHandlerGetVideoByIdListArgs{} } -func (p *VideoHandlerHotVideoArgs) InitDefault() { - *p = VideoHandlerHotVideoArgs{} +func (p *VideoHandlerGetVideoByIdListArgs) InitDefault() { + *p = VideoHandlerGetVideoByIdListArgs{} } -var VideoHandlerHotVideoArgs_Req_DEFAULT *HotVideoRequest +var VideoHandlerGetVideoByIdListArgs_Req_DEFAULT *GetVideoByIdListRequest -func (p *VideoHandlerHotVideoArgs) GetReq() (v *HotVideoRequest) { +func (p *VideoHandlerGetVideoByIdListArgs) GetReq() (v *GetVideoByIdListRequest) { if !p.IsSetReq() { - return VideoHandlerHotVideoArgs_Req_DEFAULT + return VideoHandlerGetVideoByIdListArgs_Req_DEFAULT } return p.Req } -func (p *VideoHandlerHotVideoArgs) SetReq(val *HotVideoRequest) { +func (p *VideoHandlerGetVideoByIdListArgs) SetReq(val *GetVideoByIdListRequest) { p.Req = val } -var fieldIDToName_VideoHandlerHotVideoArgs = map[int16]string{ +var fieldIDToName_VideoHandlerGetVideoByIdListArgs = map[int16]string{ 1: "req", } -func (p *VideoHandlerHotVideoArgs) IsSetReq() bool { +func (p *VideoHandlerGetVideoByIdListArgs) IsSetReq() bool { return p.Req != nil } -func (p *VideoHandlerHotVideoArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *VideoHandlerGetVideoByIdListArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -3449,7 +4402,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerHotVideoArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerGetVideoByIdListArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -3459,17 +4412,17 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *VideoHandlerHotVideoArgs) ReadField1(iprot thrift.TProtocol) error { - p.Req = NewHotVideoRequest() +func (p *VideoHandlerGetVideoByIdListArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = NewGetVideoByIdListRequest() if err := p.Req.Read(iprot); err != nil { return err } return nil } -func (p *VideoHandlerHotVideoArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerGetVideoByIdListArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("HotVideo_args"); err != nil { + if err = oprot.WriteStructBegin("GetVideoByIdList_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -3495,7 +4448,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *VideoHandlerHotVideoArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerGetVideoByIdListArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -3512,15 +4465,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *VideoHandlerHotVideoArgs) String() string { +func (p *VideoHandlerGetVideoByIdListArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("VideoHandlerHotVideoArgs(%+v)", *p) + return fmt.Sprintf("VideoHandlerGetVideoByIdListArgs(%+v)", *p) } -func (p *VideoHandlerHotVideoArgs) DeepEqual(ano *VideoHandlerHotVideoArgs) bool { +func (p *VideoHandlerGetVideoByIdListArgs) DeepEqual(ano *VideoHandlerGetVideoByIdListArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -3532,7 +4485,7 @@ func (p *VideoHandlerHotVideoArgs) DeepEqual(ano *VideoHandlerHotVideoArgs) bool return true } -func (p *VideoHandlerHotVideoArgs) Field1DeepEqual(src *HotVideoRequest) bool { +func (p *VideoHandlerGetVideoByIdListArgs) Field1DeepEqual(src *GetVideoByIdListRequest) bool { if !p.Req.DeepEqual(src) { return false @@ -3540,39 +4493,39 @@ func (p *VideoHandlerHotVideoArgs) Field1DeepEqual(src *HotVideoRequest) bool { return true } -type VideoHandlerHotVideoResult struct { - Success *HotVideoResponse `thrift:"success,0,optional" frugal:"0,optional,HotVideoResponse" json:"success,omitempty"` +type VideoHandlerGetVideoByIdListResult struct { + Success *GetVideoByIdListResponse `thrift:"success,0,optional" frugal:"0,optional,GetVideoByIdListResponse" json:"success,omitempty"` } -func NewVideoHandlerHotVideoResult() *VideoHandlerHotVideoResult { - return &VideoHandlerHotVideoResult{} +func NewVideoHandlerGetVideoByIdListResult() *VideoHandlerGetVideoByIdListResult { + return &VideoHandlerGetVideoByIdListResult{} } -func (p *VideoHandlerHotVideoResult) InitDefault() { - *p = VideoHandlerHotVideoResult{} +func (p *VideoHandlerGetVideoByIdListResult) InitDefault() { + *p = VideoHandlerGetVideoByIdListResult{} } -var VideoHandlerHotVideoResult_Success_DEFAULT *HotVideoResponse +var VideoHandlerGetVideoByIdListResult_Success_DEFAULT *GetVideoByIdListResponse -func (p *VideoHandlerHotVideoResult) GetSuccess() (v *HotVideoResponse) { +func (p *VideoHandlerGetVideoByIdListResult) GetSuccess() (v *GetVideoByIdListResponse) { if !p.IsSetSuccess() { - return VideoHandlerHotVideoResult_Success_DEFAULT + return VideoHandlerGetVideoByIdListResult_Success_DEFAULT } return p.Success } -func (p *VideoHandlerHotVideoResult) SetSuccess(x interface{}) { - p.Success = x.(*HotVideoResponse) +func (p *VideoHandlerGetVideoByIdListResult) SetSuccess(x interface{}) { + p.Success = x.(*GetVideoByIdListResponse) } -var fieldIDToName_VideoHandlerHotVideoResult = map[int16]string{ +var fieldIDToName_VideoHandlerGetVideoByIdListResult = map[int16]string{ 0: "success", } -func (p *VideoHandlerHotVideoResult) IsSetSuccess() bool { +func (p *VideoHandlerGetVideoByIdListResult) IsSetSuccess() bool { return p.Success != nil } -func (p *VideoHandlerHotVideoResult) Read(iprot thrift.TProtocol) (err error) { +func (p *VideoHandlerGetVideoByIdListResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -3618,7 +4571,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerHotVideoResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_VideoHandlerGetVideoByIdListResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -3628,17 +4581,17 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *VideoHandlerHotVideoResult) ReadField0(iprot thrift.TProtocol) error { - p.Success = NewHotVideoResponse() +func (p *VideoHandlerGetVideoByIdListResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = NewGetVideoByIdListResponse() if err := p.Success.Read(iprot); err != nil { return err } return nil } -func (p *VideoHandlerHotVideoResult) Write(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerGetVideoByIdListResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("HotVideo_result"); err != nil { + if err = oprot.WriteStructBegin("GetVideoByIdList_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -3664,7 +4617,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *VideoHandlerHotVideoResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *VideoHandlerGetVideoByIdListResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -3683,15 +4636,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *VideoHandlerHotVideoResult) String() string { +func (p *VideoHandlerGetVideoByIdListResult) String() string { if p == nil { return "" } - return fmt.Sprintf("VideoHandlerHotVideoResult(%+v)", *p) + return fmt.Sprintf("VideoHandlerGetVideoByIdListResult(%+v)", *p) } -func (p *VideoHandlerHotVideoResult) DeepEqual(ano *VideoHandlerHotVideoResult) bool { +func (p *VideoHandlerGetVideoByIdListResult) DeepEqual(ano *VideoHandlerGetVideoByIdListResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -3703,7 +4656,7 @@ func (p *VideoHandlerHotVideoResult) DeepEqual(ano *VideoHandlerHotVideoResult) return true } -func (p *VideoHandlerHotVideoResult) Field0DeepEqual(src *HotVideoResponse) bool { +func (p *VideoHandlerGetVideoByIdListResult) Field0DeepEqual(src *GetVideoByIdListResponse) bool { if !p.Success.DeepEqual(src) { return false diff --git a/kitex_gen/video/videohandler/client.go b/kitex_gen/video/videohandler/client.go index 4aeeb948..21063e44 100644 --- a/kitex_gen/video/videohandler/client.go +++ b/kitex_gen/video/videohandler/client.go @@ -15,6 +15,7 @@ type Client interface { ListVideo(ctx context.Context, req *video.ListUserVideoRequest, callOptions ...callopt.Option) (r *video.ListUserVideoResponse, err error) SearchVideo(ctx context.Context, req *video.SearchVideoRequest, callOptions ...callopt.Option) (r *video.SearchVideoResponse, err error) HotVideo(ctx context.Context, req *video.HotVideoRequest, callOptions ...callopt.Option) (r *video.HotVideoResponse, err error) + GetVideoByIdList(ctx context.Context, req *video.GetVideoByIdListRequest, callOptions ...callopt.Option) (r *video.GetVideoByIdListResponse, err error) } // NewClient creates a client for the service defined in IDL. @@ -65,3 +66,8 @@ func (p *kVideoHandlerClient) HotVideo(ctx context.Context, req *video.HotVideoR ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.HotVideo(ctx, req) } + +func (p *kVideoHandlerClient) GetVideoByIdList(ctx context.Context, req *video.GetVideoByIdListRequest, callOptions ...callopt.Option) (r *video.GetVideoByIdListResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.GetVideoByIdList(ctx, req) +} diff --git a/kitex_gen/video/videohandler/videohandler.go b/kitex_gen/video/videohandler/videohandler.go index f38b2364..4f3c56fc 100644 --- a/kitex_gen/video/videohandler/videohandler.go +++ b/kitex_gen/video/videohandler/videohandler.go @@ -41,6 +41,13 @@ var serviceMethods = map[string]kitex.MethodInfo{ false, kitex.WithStreamingMode(kitex.StreamingNone), ), + "GetVideoByIdList": kitex.NewMethodInfo( + getVideoByIdListHandler, + newVideoHandlerGetVideoByIdListArgs, + newVideoHandlerGetVideoByIdListResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), } var ( @@ -179,6 +186,24 @@ func newVideoHandlerHotVideoResult() interface{} { return video.NewVideoHandlerHotVideoResult() } +func getVideoByIdListHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*video.VideoHandlerGetVideoByIdListArgs) + realResult := result.(*video.VideoHandlerGetVideoByIdListResult) + success, err := handler.(video.VideoHandler).GetVideoByIdList(ctx, realArg.Req) + if err != nil { + return err + } + realResult.Success = success + return nil +} +func newVideoHandlerGetVideoByIdListArgs() interface{} { + return video.NewVideoHandlerGetVideoByIdListArgs() +} + +func newVideoHandlerGetVideoByIdListResult() interface{} { + return video.NewVideoHandlerGetVideoByIdListResult() +} + type kClient struct { c client.Client } @@ -228,3 +253,13 @@ func (p *kClient) HotVideo(ctx context.Context, req *video.HotVideoRequest) (r * } return _result.GetSuccess(), nil } + +func (p *kClient) GetVideoByIdList(ctx context.Context, req *video.GetVideoByIdListRequest) (r *video.GetVideoByIdListResponse, err error) { + var _args video.VideoHandlerGetVideoByIdListArgs + _args.Req = req + var _result video.VideoHandlerGetVideoByIdListResult + if err = p.c.Call(ctx, "GetVideoByIdList", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} diff --git a/pkg/pack/build_api_resp.go b/pkg/pack/build_api_resp.go index ee48f31d..145dbb5e 100644 --- a/pkg/pack/build_api_resp.go +++ b/pkg/pack/build_api_resp.go @@ -69,6 +69,10 @@ func ToUserResp(_user interface{}) *api.User { } func ConvertToAPIVideo(kitexVideo *base.Video) *api.Video { + var isLike bool = false + if kitexVideo.IsLike == 1 { + isLike = true + } return &api.Video{ ID: kitexVideo.Id, Title: kitexVideo.Title, @@ -78,15 +82,15 @@ func ConvertToAPIVideo(kitexVideo *base.Video) *api.Video { CoverURL: kitexVideo.CoverUrl, LikeCount: kitexVideo.LikeCount, CommentCount: kitexVideo.CommentCount, - IsLike: kitexVideo.IsLike, + IsLike: isLike, PublishTime: kitexVideo.PublishTime, } } func ConvertToAPIVideos(kitexVideos []*base.Video) []*api.Video { - videosResp := make([]*api.Video, len(kitexVideos)) - for i, v := range kitexVideos { - videosResp[i] = ConvertToAPIVideo(v) + videosResp := make([]*api.Video, 0) + for _, v := range kitexVideos { + videosResp = append(videosResp, ConvertToAPIVideo(v)) } return videosResp }