From fc939e2bb496b85bab292aa319b1bef08f7b0698 Mon Sep 17 00:00:00 2001 From: jiuxia211 <2064166368@qq.com> Date: Sat, 9 Dec 2023 13:12:19 +0800 Subject: [PATCH] feat: add empty room service --- cmd/empty_room/Makefile | 22 + cmd/empty_room/README.md | 59 + cmd/empty_room/build.sh | 12 + cmd/empty_room/dal/cache/empty_room.go | 42 + cmd/empty_room/dal/cache/init.go | 23 + cmd/empty_room/dal/init.go | 7 + cmd/empty_room/handler.go | 41 + cmd/empty_room/kitex_info.yaml | 3 + cmd/empty_room/main.go | 105 ++ cmd/empty_room/pack/pack.go | 30 + cmd/empty_room/script/bootstrap.sh | 21 + cmd/empty_room/service/get_room.go | 50 + cmd/empty_room/service/service.go | 13 + config/config.yaml | 8 +- config/sql/init.sql | 15 +- go.mod | 5 + go.sum | 15 + idl/empty_room.thrift | 25 + kitex_gen/empty_room/empty_room.go | 1538 +++++++++++++++++ .../empty_room/emptyroomservice/client.go | 49 + .../emptyroomservice/emptyroomservice.go | 75 + .../empty_room/emptyroomservice/invoker.go | 24 + .../empty_room/emptyroomservice/server.go | 20 + kitex_gen/empty_room/k-consts.go | 4 + kitex_gen/empty_room/k-empty_room.go | 1146 ++++++++++++ pkg/constants/constants.go | 8 + pkg/utils/jwt.go | 44 + 27 files changed, 3396 insertions(+), 8 deletions(-) create mode 100644 cmd/empty_room/Makefile create mode 100755 cmd/empty_room/README.md create mode 100644 cmd/empty_room/build.sh create mode 100644 cmd/empty_room/dal/cache/empty_room.go create mode 100644 cmd/empty_room/dal/cache/init.go create mode 100644 cmd/empty_room/dal/init.go create mode 100644 cmd/empty_room/handler.go create mode 100644 cmd/empty_room/kitex_info.yaml create mode 100644 cmd/empty_room/main.go create mode 100644 cmd/empty_room/pack/pack.go create mode 100644 cmd/empty_room/script/bootstrap.sh create mode 100644 cmd/empty_room/service/get_room.go create mode 100644 cmd/empty_room/service/service.go create mode 100644 idl/empty_room.thrift create mode 100644 kitex_gen/empty_room/empty_room.go create mode 100644 kitex_gen/empty_room/emptyroomservice/client.go create mode 100644 kitex_gen/empty_room/emptyroomservice/emptyroomservice.go create mode 100644 kitex_gen/empty_room/emptyroomservice/invoker.go create mode 100644 kitex_gen/empty_room/emptyroomservice/server.go create mode 100644 kitex_gen/empty_room/k-consts.go create mode 100644 kitex_gen/empty_room/k-empty_room.go create mode 100644 pkg/utils/jwt.go diff --git a/cmd/empty_room/Makefile b/cmd/empty_room/Makefile new file mode 100644 index 0000000..73141da --- /dev/null +++ b/cmd/empty_room/Makefile @@ -0,0 +1,22 @@ +include ../common.mk + +SERVICE_NAME = empty_room + +.PHONY: server +server: + sh build.sh + cd output && sh bootstrap.sh + +.PHONY: gen +gen: + kitex \ + -gen-path ../../kitex_gen \ + -service "$(SERVICE_NAME)" \ + -module "$(MODULE)" \ + -type thrift \ + ../../idl/$(SERVICE_NAME).thrift + go mod tidy + +.PHONY: test +test: + cd test && go test -v \ No newline at end of file diff --git a/cmd/empty_room/README.md b/cmd/empty_room/README.md new file mode 100755 index 0000000..670249c --- /dev/null +++ b/cmd/empty_room/README.md @@ -0,0 +1,59 @@ +# 空教室模块 + +**此模块用于研究生获取空教室信息** create by 李梓玄 2023.10.17 + +此模块基于kitex框架(微服务框架):https://github.com/cloudwego/kitex + +此模块基于jwch库(教务处的信息爬取库):https://github.com/west2-online/jwch + +## 接口文档 + +TODOOOOOOOOOOOOOOOOOOO! + +## 接口的传入参数与返回值 + +参阅项目根目录下的`idl/empty_room.thrift`文件 + +如需修改接口的传入参数与返回值，参照thrift语法修改`empty_room.thrift`后，在`cmd/empty_room`执行 + +```shell +# 更多信息参照 cmd/empty_room/Makefile +make gen +``` + +其中请求中的参数`building`需要传入一个教学楼Map的key，代码如下 + +```go +var ( + buildingMap = map[string]string{ + "x3": "公共教学楼西3", + "x2": "公共教学楼西2", + "x1": "公共教学楼西1", + "zl": "公共教学楼中楼", + "d1": "公共教学楼东1", + "d2": "公共教学楼东2", + "d3": "公共教学楼东3", + "wkl": "公共教学楼文科楼", + "wk": "公共教学楼文科楼", + } +) + +``` + +该Map定义于jwch库中: https://github.com/west2-online/jwch + +## 接口逻辑 + +**因为研究生的教学管理系统没有获取空教室功能，所以本接口基于一个默认的本科生账号密码去本科教学管理系统获取** + +此模块暂时只能获取旗山校区的空教室信息 + +### `GetEmptyRoom` + +1. 验证token handler +2. 当未传入账号密码时,使用默认账号密码 handler +3. 根据request信息拼接key,从`redis`中寻找缓存 +4. 如果命中缓存，则返回空教室信息 +5. 如果未命中缓存,调用`jwch`库进行登录、获取空教室信息 +6. 返回空教室信息，同时开启一个Goroutine 将空教室信息写入 + diff --git a/cmd/empty_room/build.sh b/cmd/empty_room/build.sh new file mode 100644 index 0000000..6e71e32 --- /dev/null +++ b/cmd/empty_room/build.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +RUN_NAME="empty_room" + +mkdir -p output/bin +cp script/* output/ +chmod +x output/bootstrap.sh + +if [ "$IS_SYSTEM_TEST_ENV" != "1" ]; then + go build -o output/bin/${RUN_NAME} +else + go test -c -covermode=set -o output/bin/${RUN_NAME} -coverpkg=./... +fi diff --git a/cmd/empty_room/dal/cache/empty_room.go b/cmd/empty_room/dal/cache/empty_room.go new file mode 100644 index 0000000..81d7e89 --- /dev/null +++ b/cmd/empty_room/dal/cache/empty_room.go @@ -0,0 +1,42 @@ +package cache + +import ( + "context" + "encoding/json" + "time" + + "github.com/cloudwego/kitex/pkg/klog" +) + +type EmptyRoomCache struct { + roomName []string + lastTime int64 +} + +func SetEmptyRoomCache(ctx context.Context, key string, emptyRoomList []string) { + emptyRoomCache := &EmptyRoomCache{ + roomName: emptyRoomList, + lastTime: time.Now().Unix(), + } + emptyRoomJson, err := json.Marshal(emptyRoomCache) + // 10分钟过期 + err = RedisClient.Set(ctx, key, emptyRoomJson, time.Minute*10).Err() + if err != nil { + klog.Error(err) + } +} +func GetEmptyRoomCache(ctx context.Context, key string) (emptyRoomList []string, err error) { + data, err := RedisClient.Get(ctx, key).Result() + if err != nil { + return nil, err + } + err = json.Unmarshal([]byte(data), &emptyRoomList) + if err != nil { + return nil, err + } + return +} +func IsExistRoomInfo(ctx context.Context, key string) (exist int64, err error) { + exist, err = RedisClient.Exists(ctx, key).Result() + return +} diff --git a/cmd/empty_room/dal/cache/init.go b/cmd/empty_room/dal/cache/init.go new file mode 100644 index 0000000..0a556b0 --- /dev/null +++ b/cmd/empty_room/dal/cache/init.go @@ -0,0 +1,23 @@ +package cache + +import ( + "context" + + "github.com/redis/go-redis/v9" + "github.com/west2-online/fzuhelper-server/config" + "github.com/west2-online/fzuhelper-server/pkg/constants" +) + +var RedisClient *redis.Client + +func Init() { + RedisClient = redis.NewClient(&redis.Options{ + Addr: config.Redis.Addr, + Password: config.Redis.Password, + DB: constants.RedisDBEmptyRoom, + }) + _, err := RedisClient.Ping(context.TODO()).Result() + if err != nil { + panic(err) + } +} diff --git a/cmd/empty_room/dal/init.go b/cmd/empty_room/dal/init.go new file mode 100644 index 0000000..22de3cd --- /dev/null +++ b/cmd/empty_room/dal/init.go @@ -0,0 +1,7 @@ +package dal + +import "github.com/west2-online/fzuhelper-server/cmd/empty_room/dal/cache" + +func Init() { + cache.Init() +} diff --git a/cmd/empty_room/handler.go b/cmd/empty_room/handler.go new file mode 100644 index 0000000..bd60720 --- /dev/null +++ b/cmd/empty_room/handler.go @@ -0,0 +1,41 @@ +package main + +import ( + "context" + + "github.com/west2-online/fzuhelper-server/cmd/empty_room/pack" + "github.com/west2-online/fzuhelper-server/cmd/empty_room/service" + empty_room "github.com/west2-online/fzuhelper-server/kitex_gen/empty_room" + "github.com/west2-online/fzuhelper-server/pkg/constants" + "github.com/west2-online/fzuhelper-server/pkg/errno" + "github.com/west2-online/fzuhelper-server/pkg/utils" +) + +// EmptyRoomServiceImpl implements the last service interface defined in the IDL. +type EmptyRoomServiceImpl struct{} + +// GetEmptyRoom implements the EmptyRoomServiceImpl interface. +func (s *EmptyRoomServiceImpl) GetEmptyRoom(ctx context.Context, req *empty_room.EmptyRoomRequest) (resp *empty_room.EmptyRoomResponse, err error) { + resp = new(empty_room.EmptyRoomResponse) + + if _, err := utils.CheckToken(req.Token); err != nil { + resp.Base = pack.BuildBaseResp(errno.AuthFailedError) + return resp, nil + } + + if req.Account == nil && req.Password == nil { + // 当未传入账号密码时(例如研究生获取空教室),使用默认账号密码 + *req.Account = constants.DefaultAccount + *req.Password = constants.DefaultPassword + } + + empty_room, err := service.NewEmptyRoomService(ctx).GetRoom(req) + if err != nil { + resp.Base = pack.BuildBaseResp(err) + return resp, nil + } + + resp.Base = pack.BuildBaseResp(nil) + resp.RoomName = empty_room + return +} diff --git a/cmd/empty_room/kitex_info.yaml b/cmd/empty_room/kitex_info.yaml new file mode 100644 index 0000000..3f1e0b1 --- /dev/null +++ b/cmd/empty_room/kitex_info.yaml @@ -0,0 +1,3 @@ +kitexinfo: + ServiceName: 'empty_room' + ToolVersion: 'v0.7.1' diff --git a/cmd/empty_room/main.go b/cmd/empty_room/main.go new file mode 100644 index 0000000..4d40775 --- /dev/null +++ b/cmd/empty_room/main.go @@ -0,0 +1,105 @@ +package main + +import ( + "flag" + "fmt" + "net" + + "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/elastic/go-elasticsearch" + kitexlogrus "github.com/kitex-contrib/obs-opentelemetry/logging/logrus" + etcd "github.com/kitex-contrib/registry-etcd" + trace "github.com/kitex-contrib/tracer-opentracing" + "github.com/sirupsen/logrus" + "github.com/west2-online/fzuhelper-server/cmd/empty_room/dal" + "github.com/west2-online/fzuhelper-server/config" + empty_room "github.com/west2-online/fzuhelper-server/kitex_gen/empty_room/emptyroomservice" + "github.com/west2-online/fzuhelper-server/pkg/constants" + "github.com/west2-online/fzuhelper-server/pkg/eslogrus" + "github.com/west2-online/fzuhelper-server/pkg/tracer" + "github.com/west2-online/fzuhelper-server/pkg/utils" +) + +var ( + path *string + listenAddr string // listen port + + EsClient *elasticsearch.Client +) + +func Init() { + // config init + path = flag.String("config", "./config", "config path") + flag.Parse() + config.Init(*path, constants.EmptyRoomService) + tracer.InitJaeger(constants.EmptyRoomService) + dal.Init() + EsInit() + klog.SetLevel(klog.LevelDebug) + klog.SetLogger(kitexlogrus.NewLogger(kitexlogrus.WithHook(EsHookLog()))) +} + +func EsHookLog() *eslogrus.ElasticHook { + hook, err := eslogrus.NewElasticHook(EsClient, config.Elasticsearch.Host, logrus.DebugLevel, constants.EmptyRoomService) + if err != nil { + panic(err) + } + + return hook +} + +// InitEs 初始化es +func EsInit() { + esConn := fmt.Sprintf("http://%s", config.Elasticsearch.Addr) + cfg := elasticsearch.Config{ + Addresses: []string{esConn}, + } + klog.Infof("esConn:%v", esConn) + client, err := elasticsearch.NewClient(cfg) + if err != nil { + panic(err) + } + EsClient = client +} +func main() { + Init() + r, err := etcd.NewEtcdRegistry([]string{config.Etcd.Addr}) + + if err != nil { + panic(err) + } + + // get available port from config set + for index, addr := range config.Service.AddrList { + if ok := utils.AddrCheck(addr); ok { + listenAddr = addr + break + } + + if index == len(config.Service.AddrList)-1 { + klog.Fatal("not available port from config") + } + } + + addr, err := net.ResolveTCPAddr("tcp", listenAddr) + + svr := empty_room.NewServer(new(EmptyRoomServiceImpl), + server.WithServerBasicInfo(&rpcinfo.EndpointBasicInfo{ + ServiceName: constants.EmptyRoomService, + }), + server.WithMuxTransport(), + server.WithServiceAddr(addr), + server.WithRegistry(r), + server.WithSuite(trace.NewDefaultServerSuite()), + server.WithLimit(&limit.Option{ + MaxConnections: constants.MaxConnections, + MaxQPS: constants.MaxQPS, + })) + + if err = svr.Run(); err != nil { + panic(err) + } +} diff --git a/cmd/empty_room/pack/pack.go b/cmd/empty_room/pack/pack.go new file mode 100644 index 0000000..573b1b1 --- /dev/null +++ b/cmd/empty_room/pack/pack.go @@ -0,0 +1,30 @@ +package pack + +import ( + "errors" + + "github.com/west2-online/fzuhelper-server/kitex_gen/empty_room" + "github.com/west2-online/fzuhelper-server/pkg/errno" +) + +func BuildBaseResp(err error) *empty_room.BaseResp { + if err == nil { + return baseResp(errno.Success) + } + + e := errno.ErrNo{} + + if errors.As(err, &e) { + return baseResp(e) + } + + s := errno.InternalServiceError.WithMessage(err.Error()) + return baseResp(s) +} + +func baseResp(err errno.ErrNo) *empty_room.BaseResp { + return &empty_room.BaseResp{ + Code: err.ErrorCode, + Msg: err.ErrorMsg, + } +} diff --git a/cmd/empty_room/script/bootstrap.sh b/cmd/empty_room/script/bootstrap.sh new file mode 100644 index 0000000..dc15bea --- /dev/null +++ b/cmd/empty_room/script/bootstrap.sh @@ -0,0 +1,21 @@ +#! /usr/bin/env bash +CURDIR=$(cd $(dirname $0); pwd) + +if [ "X$1" != "X" ]; then + RUNTIME_ROOT=$1 +else + RUNTIME_ROOT=${CURDIR} +fi + +export KITEX_RUNTIME_ROOT=$RUNTIME_ROOT +export KITEX_LOG_DIR="$RUNTIME_ROOT/log" + +if [ ! -d "$KITEX_LOG_DIR/app" ]; then + mkdir -p "$KITEX_LOG_DIR/app" +fi + +if [ ! -d "$KITEX_LOG_DIR/rpc" ]; then + mkdir -p "$KITEX_LOG_DIR/rpc" +fi + +exec "$CURDIR/bin/empty_room" diff --git a/cmd/empty_room/service/get_room.go b/cmd/empty_room/service/get_room.go new file mode 100644 index 0000000..94ded69 --- /dev/null +++ b/cmd/empty_room/service/get_room.go @@ -0,0 +1,50 @@ +package service + +import ( + "fmt" + + "github.com/west2-online/fzuhelper-server/cmd/empty_room/dal/cache" + "github.com/west2-online/fzuhelper-server/kitex_gen/empty_room" + "github.com/west2-online/jwch" +) + +func (s *EmptyRoomService) GetRoom(req *empty_room.EmptyRoomRequest) (empty_room []string, err error) { + key := fmt.Sprintf("%s.%s.%s.%s", req.Time, req.Start, req.End, req.Building) + if exist, err := cache.IsExistRoomInfo(s.ctx, key); exist == 1 { + // 获取缓存 + if err != nil { + return nil, err + } + empty_room, err = cache.GetEmptyRoomCache(s.ctx, key) + if err != nil { + return nil, err + } + } else { + // 未命中缓存，登录进行爬取 + student := jwch.NewStudent().WithUser(*req.Account, *req.Password) + + err = student.Login() + if err != nil { + return nil, err + } + + err = student.CheckSession() + if err != nil { + return nil, err + } + + err, empty_room = student.GetEmptyRoom(jwch.EmptyRoomReq{ + Time: req.Time, + Start: req.Start, + End: req.End, + Building: req.Building, + }) + if err != nil { + return nil, err + } + + // 异步写入缓存 + go cache.SetEmptyRoomCache(s.ctx, key, empty_room) + } + return empty_room, nil +} diff --git a/cmd/empty_room/service/service.go b/cmd/empty_room/service/service.go new file mode 100644 index 0000000..8636939 --- /dev/null +++ b/cmd/empty_room/service/service.go @@ -0,0 +1,13 @@ +package service + +import ( + "context" +) + +type EmptyRoomService struct { + ctx context.Context +} + +func NewEmptyRoomService(ctx context.Context) *EmptyRoomService { + return &EmptyRoomService{ctx: ctx} +} diff --git a/config/config.yaml b/config/config.yaml index 4e5ff02..3654d91 100644 --- a/config/config.yaml +++ b/config/config.yaml @@ -45,4 +45,10 @@ services: name: template load-balance: false addr: - - 127.0.0.1:10001 \ No newline at end of file + - 127.0.0.1:10001 + + empty_room: + name: empty_room + load-balance: false + addr: + - 127.0.0.1:10002 \ No newline at end of file diff --git a/config/sql/init.sql b/config/sql/init.sql index 0bdfabb..6e7c5d0 100644 --- a/config/sql/init.sql +++ b/config/sql/init.sql @@ -1,6 +1,7 @@ create table fzuhelper.`student` ( - `id` bigint not null comment '学号', + `id` bigint not null comment '学生ID', + `number` varchar(255) not null comment '学号', `password` varchar(255) not null comment '密码', `sex` varchar(255) not null comment '性别', `birthday` varchar(255) not null comment '出生日期', @@ -16,9 +17,9 @@ create table fzuhelper.`student` `country` varchar(255) not null comment '国别', `political_status` varchar(255) not null comment '政治面貌', `source` varchar(255) not null comment '生源地', - `created_at` timestamp default current_timestamp not null, - `updated_at` timestamp default current_timestamp not null on update current_timestamp comment 'update profile time', - `deleted_at` timestamp default null null, + `created_at` timestamp default current_timestamp not null, + `updated_at` timestamp default current_timestamp not null on update current_timestamp comment 'update profile time', + `deleted_at` timestamp default null null, constraint `id` primary key (`id`) )engine=InnoDB default charset=utf8mb4; @@ -57,9 +58,9 @@ create table fzuhelper.`course` `examtime` varchar(255) not null comment '考试时间地点', `remark` varchar(255) not null comment '备注', `adjust` varchar(255) not null comment '调课信息', - `created_at` timestamp default current_timestamp not null, - `updated_at` timestamp default current_timestamp not null on update current_timestamp comment 'update profile time', - `deleted_at` timestamp default null null, + `created_at` timestamp default current_timestamp not null, + `updated_at` timestamp default current_timestamp not null on update current_timestamp comment 'update profile time', + `deleted_at` timestamp default null null, constraint `id` primary key (`id`), constraint `course_student` diff --git a/go.mod b/go.mod index 94a3e4c..177b128 100644 --- a/go.mod +++ b/go.mod @@ -16,6 +16,7 @@ require ( github.com/sirupsen/logrus v1.9.3 github.com/spf13/viper v1.16.0 github.com/uber/jaeger-client-go v2.30.0+incompatible + github.com/west2-online/jwch v0.0.4 gorm.io/driver/mysql v1.5.1 gorm.io/gorm v1.25.1 gorm.io/plugin/opentracing v0.0.0-20211220013347-7d2b2af23560 @@ -27,6 +28,8 @@ require ( cloud.google.com/go/compute/metadata v0.2.3 // indirect cloud.google.com/go/firestore v1.9.0 // indirect cloud.google.com/go/longrunning v0.4.1 // indirect + github.com/antchfx/htmlquery v1.3.0 // indirect + github.com/antchfx/xpath v1.2.4 // indirect github.com/armon/go-metrics v0.4.0 // indirect github.com/bytedance/gopkg v0.0.0-20230728082804-614d0af6619b // indirect github.com/bytedance/sonic v1.9.1 // indirect @@ -47,8 +50,10 @@ require ( github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect github.com/fatih/color v1.13.0 // indirect github.com/fatih/structtag v1.2.0 // indirect + github.com/go-resty/resty/v2 v2.7.0 // indirect github.com/go-sql-driver/mysql v1.7.0 // indirect github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang-jwt/jwt v3.2.2+incompatible github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/golang/protobuf v1.5.3 // indirect github.com/google/go-cmp v0.5.9 // indirect diff --git a/go.sum b/go.sum index d096f25..5af9c03 100644 --- a/go.sum +++ b/go.sum @@ -64,6 +64,11 @@ github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuy github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho= +github.com/antchfx/htmlquery v1.3.0 h1:5I5yNFOVI+egyia5F2s/5Do2nFWxJz41Tr3DyfKD25E= +github.com/antchfx/htmlquery v1.3.0/go.mod h1:zKPDVTMhfOmcwxheXUsx4rKJy8KEY/PU6eXr/2SebQ8= +github.com/antchfx/xpath v1.2.3/go.mod h1:i54GszH55fYfBmoZXapTHN8T8tkcHfRgLyVwwqzXNcs= +github.com/antchfx/xpath v1.2.4 h1:dW1HB/JxKvGtJ9WyVGJ0sIoEcqftV3SqIstujI+B9XY= +github.com/antchfx/xpath v1.2.4/go.mod h1:i54GszH55fYfBmoZXapTHN8T8tkcHfRgLyVwwqzXNcs= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= github.com/apache/thrift v0.13.0 h1:5hryIiq9gtn+MiLVn0wP37kb/uTeRZgN08WoCsAhIhI= github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= @@ -253,6 +258,8 @@ github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-pdf/fpdf v0.5.0/go.mod h1:HzcnA+A23uwogo0tp9yU+l3V+KXhiESpt1PMayhOh5M= github.com/go-pdf/fpdf v0.6.0/go.mod h1:HzcnA+A23uwogo0tp9yU+l3V+KXhiESpt1PMayhOh5M= +github.com/go-resty/resty/v2 v2.7.0 h1:me+K9p3uhSmXtrBZ4k9jcEAfJmuC8IivWHwaLZwPrFY= +github.com/go-resty/resty/v2 v2.7.0/go.mod h1:9PWDzw47qPphMRFfhsyk0NnSgvluHcljSMVIq3w7q0I= github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc= github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= @@ -262,6 +269,8 @@ github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zV github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= +github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -660,6 +669,8 @@ github.com/uber/jaeger-lib v2.4.1+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6 github.com/v2pro/plz v0.0.0-20221028024117-e5f9aec5b631/go.mod h1:3gacX+hQo+xvl0vtLqCMufzxuNCwt4geAVOMt2LQYfE= github.com/v2pro/quokka v0.0.0-20171201153428-382cb39c6ee6/go.mod h1:0VP5W9AFNVWU8C1QLNeVg8TvzoEkIHWZ4vxtxEVFWUY= github.com/v2pro/wombat v0.0.0-20180402055224-a56dbdcddef2/go.mod h1:wen8nMxrRrUmXnRwH+3wGAW+hyYTHcOrTNhMpxyp/i0= +github.com/west2-online/jwch v0.0.4 h1:3yN6FEt7g88LBPmrfOj0rWEbV3fj/r3BUvR083wsv58= +github.com/west2-online/jwch v0.0.4/go.mod h1:yAh5jjEFzFFXowajIFxkdgSQTngj0CZsnyqRvwZkwsQ= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2 h1:eY9dn8+vbi4tKz5Qo6v2eYzo7kUS51QINcR5jNpbZS8= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= @@ -853,9 +864,11 @@ golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96b golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8= golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211029224645-99673261e6eb/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM= golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -957,10 +970,12 @@ golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220817070843-5a390386f1f2/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE= golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= diff --git a/idl/empty_room.thrift b/idl/empty_room.thrift new file mode 100644 index 0000000..ca635b7 --- /dev/null +++ b/idl/empty_room.thrift @@ -0,0 +1,25 @@ +namespace go empty_room + +struct BaseResp { + 1: i64 code, + 2: string msg, +} + +struct EmptyRoomRequest{ + 1: required string token, + 2: required string time, + 3: required string start, + 4: required string end, + 5: required string building, + 6: optional string account, + 7: optional string password, +} + +struct EmptyRoomResponse{ + 1: required BaseResp base, + 2: required list room_name, +} + +service EmptyRoomService{ + EmptyRoomResponse GetEmptyRoom(1:EmptyRoomRequest req), +} \ No newline at end of file diff --git a/kitex_gen/empty_room/empty_room.go b/kitex_gen/empty_room/empty_room.go new file mode 100644 index 0000000..1f72d4a --- /dev/null +++ b/kitex_gen/empty_room/empty_room.go @@ -0,0 +1,1538 @@ +// Code generated by thriftgo (0.3.4). DO NOT EDIT. + +package empty_room + +import ( + "context" + "fmt" + "github.com/apache/thrift/lib/go/thrift" + "strings" +) + +type BaseResp struct { + Code int64 `thrift:"code,1" frugal:"1,default,i64" json:"code"` + Msg string `thrift:"msg,2" frugal:"2,default,string" json:"msg"` +} + +func NewBaseResp() *BaseResp { + return &BaseResp{} +} + +func (p *BaseResp) InitDefault() { + *p = BaseResp{} +} + +func (p *BaseResp) GetCode() (v int64) { + return p.Code +} + +func (p *BaseResp) GetMsg() (v string) { + return p.Msg +} +func (p *BaseResp) SetCode(val int64) { + p.Code = val +} +func (p *BaseResp) SetMsg(val string) { + p.Msg = val +} + +var fieldIDToName_BaseResp = map[int16]string{ + 1: "code", + 2: "msg", +} + +func (p *BaseResp) 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.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRING { + 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_BaseResp[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 *BaseResp) ReadField1(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + p.Code = v + } + return nil +} +func (p *BaseResp) ReadField2(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadString(); err != nil { + return err + } else { + p.Msg = v + } + return nil +} + +func (p *BaseResp) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("BaseResp"); 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 *BaseResp) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("code", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(p.Code); 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 *BaseResp) writeField2(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("msg", thrift.STRING, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(p.Msg); 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 *BaseResp) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("BaseResp(%+v)", *p) + +} + +func (p *BaseResp) DeepEqual(ano *BaseResp) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Code) { + return false + } + if !p.Field2DeepEqual(ano.Msg) { + return false + } + return true +} + +func (p *BaseResp) Field1DeepEqual(src int64) bool { + + if p.Code != src { + return false + } + return true +} +func (p *BaseResp) Field2DeepEqual(src string) bool { + + if strings.Compare(p.Msg, src) != 0 { + return false + } + return true +} + +type EmptyRoomRequest struct { + Token string `thrift:"token,1,required" frugal:"1,required,string" json:"token"` + Time string `thrift:"time,2,required" frugal:"2,required,string" json:"time"` + Start string `thrift:"start,3,required" frugal:"3,required,string" json:"start"` + End string `thrift:"end,4,required" frugal:"4,required,string" json:"end"` + Building string `thrift:"building,5,required" frugal:"5,required,string" json:"building"` + Account *string `thrift:"account,6,optional" frugal:"6,optional,string" json:"account,omitempty"` + Password *string `thrift:"password,7,optional" frugal:"7,optional,string" json:"password,omitempty"` +} + +func NewEmptyRoomRequest() *EmptyRoomRequest { + return &EmptyRoomRequest{} +} + +func (p *EmptyRoomRequest) InitDefault() { + *p = EmptyRoomRequest{} +} + +func (p *EmptyRoomRequest) GetToken() (v string) { + return p.Token +} + +func (p *EmptyRoomRequest) GetTime() (v string) { + return p.Time +} + +func (p *EmptyRoomRequest) GetStart() (v string) { + return p.Start +} + +func (p *EmptyRoomRequest) GetEnd() (v string) { + return p.End +} + +func (p *EmptyRoomRequest) GetBuilding() (v string) { + return p.Building +} + +var EmptyRoomRequest_Account_DEFAULT string + +func (p *EmptyRoomRequest) GetAccount() (v string) { + if !p.IsSetAccount() { + return EmptyRoomRequest_Account_DEFAULT + } + return *p.Account +} + +var EmptyRoomRequest_Password_DEFAULT string + +func (p *EmptyRoomRequest) GetPassword() (v string) { + if !p.IsSetPassword() { + return EmptyRoomRequest_Password_DEFAULT + } + return *p.Password +} +func (p *EmptyRoomRequest) SetToken(val string) { + p.Token = val +} +func (p *EmptyRoomRequest) SetTime(val string) { + p.Time = val +} +func (p *EmptyRoomRequest) SetStart(val string) { + p.Start = val +} +func (p *EmptyRoomRequest) SetEnd(val string) { + p.End = val +} +func (p *EmptyRoomRequest) SetBuilding(val string) { + p.Building = val +} +func (p *EmptyRoomRequest) SetAccount(val *string) { + p.Account = val +} +func (p *EmptyRoomRequest) SetPassword(val *string) { + p.Password = val +} + +var fieldIDToName_EmptyRoomRequest = map[int16]string{ + 1: "token", + 2: "time", + 3: "start", + 4: "end", + 5: "building", + 6: "account", + 7: "password", +} + +func (p *EmptyRoomRequest) IsSetAccount() bool { + return p.Account != nil +} + +func (p *EmptyRoomRequest) IsSetPassword() bool { + return p.Password != nil +} + +func (p *EmptyRoomRequest) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + var issetToken bool = false + var issetTime bool = false + var issetStart bool = false + var issetEnd bool = false + var issetBuilding bool = false + + 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.STRING { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + issetToken = true + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRING { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + issetTime = true + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 3: + if fieldTypeId == thrift.STRING { + if err = p.ReadField3(iprot); err != nil { + goto ReadFieldError + } + issetStart = true + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 4: + if fieldTypeId == thrift.STRING { + if err = p.ReadField4(iprot); err != nil { + goto ReadFieldError + } + issetEnd = true + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 5: + if fieldTypeId == thrift.STRING { + if err = p.ReadField5(iprot); err != nil { + goto ReadFieldError + } + issetBuilding = true + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 6: + if fieldTypeId == thrift.STRING { + if err = p.ReadField6(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 7: + if fieldTypeId == thrift.STRING { + if err = p.ReadField7(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 + } + + if !issetToken { + fieldId = 1 + goto RequiredFieldNotSetError + } + + if !issetTime { + fieldId = 2 + goto RequiredFieldNotSetError + } + + if !issetStart { + fieldId = 3 + goto RequiredFieldNotSetError + } + + if !issetEnd { + fieldId = 4 + goto RequiredFieldNotSetError + } + + if !issetBuilding { + fieldId = 5 + goto RequiredFieldNotSetError + } + 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_EmptyRoomRequest[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) +RequiredFieldNotSetError: + return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("required field %s is not set", fieldIDToName_EmptyRoomRequest[fieldId])) +} + +func (p *EmptyRoomRequest) ReadField1(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadString(); err != nil { + return err + } else { + p.Token = v + } + return nil +} +func (p *EmptyRoomRequest) ReadField2(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadString(); err != nil { + return err + } else { + p.Time = v + } + return nil +} +func (p *EmptyRoomRequest) ReadField3(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadString(); err != nil { + return err + } else { + p.Start = v + } + return nil +} +func (p *EmptyRoomRequest) ReadField4(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadString(); err != nil { + return err + } else { + p.End = v + } + return nil +} +func (p *EmptyRoomRequest) ReadField5(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadString(); err != nil { + return err + } else { + p.Building = v + } + return nil +} +func (p *EmptyRoomRequest) ReadField6(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadString(); err != nil { + return err + } else { + p.Account = &v + } + return nil +} +func (p *EmptyRoomRequest) ReadField7(iprot thrift.TProtocol) error { + + if v, err := iprot.ReadString(); err != nil { + return err + } else { + p.Password = &v + } + return nil +} + +func (p *EmptyRoomRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("EmptyRoomRequest"); 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 = p.writeField4(oprot); err != nil { + fieldId = 4 + goto WriteFieldError + } + if err = p.writeField5(oprot); err != nil { + fieldId = 5 + goto WriteFieldError + } + if err = p.writeField6(oprot); err != nil { + fieldId = 6 + goto WriteFieldError + } + if err = p.writeField7(oprot); err != nil { + fieldId = 7 + 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 *EmptyRoomRequest) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("token", thrift.STRING, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(p.Token); 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 *EmptyRoomRequest) writeField2(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("time", thrift.STRING, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(p.Time); 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 *EmptyRoomRequest) writeField3(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("start", thrift.STRING, 3); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(p.Start); 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 *EmptyRoomRequest) writeField4(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("end", thrift.STRING, 4); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(p.End); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err) +} + +func (p *EmptyRoomRequest) writeField5(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("building", thrift.STRING, 5); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(p.Building); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err) +} + +func (p *EmptyRoomRequest) writeField6(oprot thrift.TProtocol) (err error) { + if p.IsSetAccount() { + if err = oprot.WriteFieldBegin("account", thrift.STRING, 6); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Account); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 6 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err) +} + +func (p *EmptyRoomRequest) writeField7(oprot thrift.TProtocol) (err error) { + if p.IsSetPassword() { + if err = oprot.WriteFieldBegin("password", thrift.STRING, 7); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Password); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 7 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 7 end error: ", p), err) +} + +func (p *EmptyRoomRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("EmptyRoomRequest(%+v)", *p) + +} + +func (p *EmptyRoomRequest) DeepEqual(ano *EmptyRoomRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Token) { + return false + } + if !p.Field2DeepEqual(ano.Time) { + return false + } + if !p.Field3DeepEqual(ano.Start) { + return false + } + if !p.Field4DeepEqual(ano.End) { + return false + } + if !p.Field5DeepEqual(ano.Building) { + return false + } + if !p.Field6DeepEqual(ano.Account) { + return false + } + if !p.Field7DeepEqual(ano.Password) { + return false + } + return true +} + +func (p *EmptyRoomRequest) Field1DeepEqual(src string) bool { + + if strings.Compare(p.Token, src) != 0 { + return false + } + return true +} +func (p *EmptyRoomRequest) Field2DeepEqual(src string) bool { + + if strings.Compare(p.Time, src) != 0 { + return false + } + return true +} +func (p *EmptyRoomRequest) Field3DeepEqual(src string) bool { + + if strings.Compare(p.Start, src) != 0 { + return false + } + return true +} +func (p *EmptyRoomRequest) Field4DeepEqual(src string) bool { + + if strings.Compare(p.End, src) != 0 { + return false + } + return true +} +func (p *EmptyRoomRequest) Field5DeepEqual(src string) bool { + + if strings.Compare(p.Building, src) != 0 { + return false + } + return true +} +func (p *EmptyRoomRequest) Field6DeepEqual(src *string) bool { + + if p.Account == src { + return true + } else if p.Account == nil || src == nil { + return false + } + if strings.Compare(*p.Account, *src) != 0 { + return false + } + return true +} +func (p *EmptyRoomRequest) Field7DeepEqual(src *string) bool { + + if p.Password == src { + return true + } else if p.Password == nil || src == nil { + return false + } + if strings.Compare(*p.Password, *src) != 0 { + return false + } + return true +} + +type EmptyRoomResponse struct { + Base *BaseResp `thrift:"base,1,required" frugal:"1,required,BaseResp" json:"base"` + RoomName []string `thrift:"room_name,2,required" frugal:"2,required,list" json:"room_name"` +} + +func NewEmptyRoomResponse() *EmptyRoomResponse { + return &EmptyRoomResponse{} +} + +func (p *EmptyRoomResponse) InitDefault() { + *p = EmptyRoomResponse{} +} + +var EmptyRoomResponse_Base_DEFAULT *BaseResp + +func (p *EmptyRoomResponse) GetBase() (v *BaseResp) { + if !p.IsSetBase() { + return EmptyRoomResponse_Base_DEFAULT + } + return p.Base +} + +func (p *EmptyRoomResponse) GetRoomName() (v []string) { + return p.RoomName +} +func (p *EmptyRoomResponse) SetBase(val *BaseResp) { + p.Base = val +} +func (p *EmptyRoomResponse) SetRoomName(val []string) { + p.RoomName = val +} + +var fieldIDToName_EmptyRoomResponse = map[int16]string{ + 1: "base", + 2: "room_name", +} + +func (p *EmptyRoomResponse) IsSetBase() bool { + return p.Base != nil +} + +func (p *EmptyRoomResponse) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + var issetBase bool = false + var issetRoomName bool = false + + 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 + } + issetBase = true + } 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 + } + issetRoomName = true + } 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 + } + + if !issetBase { + fieldId = 1 + goto RequiredFieldNotSetError + } + + if !issetRoomName { + fieldId = 2 + goto RequiredFieldNotSetError + } + 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_EmptyRoomResponse[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) +RequiredFieldNotSetError: + return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("required field %s is not set", fieldIDToName_EmptyRoomResponse[fieldId])) +} + +func (p *EmptyRoomResponse) ReadField1(iprot thrift.TProtocol) error { + p.Base = NewBaseResp() + if err := p.Base.Read(iprot); err != nil { + return err + } + return nil +} +func (p *EmptyRoomResponse) ReadField2(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + p.RoomName = make([]string, 0, size) + for i := 0; i < size; i++ { + + var _elem string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _elem = v + } + + p.RoomName = append(p.RoomName, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + return nil +} + +func (p *EmptyRoomResponse) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("EmptyRoomResponse"); 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 *EmptyRoomResponse) 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 *EmptyRoomResponse) writeField2(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("room_name", thrift.LIST, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.STRING, len(p.RoomName)); err != nil { + return err + } + for _, v := range p.RoomName { + if err := oprot.WriteString(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 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} + +func (p *EmptyRoomResponse) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("EmptyRoomResponse(%+v)", *p) + +} + +func (p *EmptyRoomResponse) DeepEqual(ano *EmptyRoomResponse) 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.RoomName) { + return false + } + return true +} + +func (p *EmptyRoomResponse) Field1DeepEqual(src *BaseResp) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} +func (p *EmptyRoomResponse) Field2DeepEqual(src []string) bool { + + if len(p.RoomName) != len(src) { + return false + } + for i, v := range p.RoomName { + _src := src[i] + if strings.Compare(v, _src) != 0 { + return false + } + } + return true +} + +type EmptyRoomService interface { + GetEmptyRoom(ctx context.Context, req *EmptyRoomRequest) (r *EmptyRoomResponse, err error) +} + +type EmptyRoomServiceClient struct { + c thrift.TClient +} + +func NewEmptyRoomServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *EmptyRoomServiceClient { + return &EmptyRoomServiceClient{ + c: thrift.NewTStandardClient(f.GetProtocol(t), f.GetProtocol(t)), + } +} + +func NewEmptyRoomServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *EmptyRoomServiceClient { + return &EmptyRoomServiceClient{ + c: thrift.NewTStandardClient(iprot, oprot), + } +} + +func NewEmptyRoomServiceClient(c thrift.TClient) *EmptyRoomServiceClient { + return &EmptyRoomServiceClient{ + c: c, + } +} + +func (p *EmptyRoomServiceClient) Client_() thrift.TClient { + return p.c +} + +func (p *EmptyRoomServiceClient) GetEmptyRoom(ctx context.Context, req *EmptyRoomRequest) (r *EmptyRoomResponse, err error) { + var _args EmptyRoomServiceGetEmptyRoomArgs + _args.Req = req + var _result EmptyRoomServiceGetEmptyRoomResult + if err = p.Client_().Call(ctx, "GetEmptyRoom", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +type EmptyRoomServiceProcessor struct { + processorMap map[string]thrift.TProcessorFunction + handler EmptyRoomService +} + +func (p *EmptyRoomServiceProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) { + p.processorMap[key] = processor +} + +func (p *EmptyRoomServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) { + processor, ok = p.processorMap[key] + return processor, ok +} + +func (p *EmptyRoomServiceProcessor) ProcessorMap() map[string]thrift.TProcessorFunction { + return p.processorMap +} + +func NewEmptyRoomServiceProcessor(handler EmptyRoomService) *EmptyRoomServiceProcessor { + self := &EmptyRoomServiceProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)} + self.AddToProcessorMap("GetEmptyRoom", &emptyRoomServiceProcessorGetEmptyRoom{handler: handler}) + return self +} +func (p *EmptyRoomServiceProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + name, _, seqId, err := iprot.ReadMessageBegin() + if err != nil { + return false, err + } + if processor, ok := p.GetProcessorFunction(name); ok { + return processor.Process(ctx, seqId, iprot, oprot) + } + iprot.Skip(thrift.STRUCT) + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name) + oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, x +} + +type emptyRoomServiceProcessorGetEmptyRoom struct { + handler EmptyRoomService +} + +func (p *emptyRoomServiceProcessorGetEmptyRoom) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := EmptyRoomServiceGetEmptyRoomArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("GetEmptyRoom", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := EmptyRoomServiceGetEmptyRoomResult{} + var retval *EmptyRoomResponse + if retval, err2 = p.handler.GetEmptyRoom(ctx, args.Req); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetEmptyRoom: "+err2.Error()) + oprot.WriteMessageBegin("GetEmptyRoom", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("GetEmptyRoom", 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 EmptyRoomServiceGetEmptyRoomArgs struct { + Req *EmptyRoomRequest `thrift:"req,1" frugal:"1,default,EmptyRoomRequest" json:"req"` +} + +func NewEmptyRoomServiceGetEmptyRoomArgs() *EmptyRoomServiceGetEmptyRoomArgs { + return &EmptyRoomServiceGetEmptyRoomArgs{} +} + +func (p *EmptyRoomServiceGetEmptyRoomArgs) InitDefault() { + *p = EmptyRoomServiceGetEmptyRoomArgs{} +} + +var EmptyRoomServiceGetEmptyRoomArgs_Req_DEFAULT *EmptyRoomRequest + +func (p *EmptyRoomServiceGetEmptyRoomArgs) GetReq() (v *EmptyRoomRequest) { + if !p.IsSetReq() { + return EmptyRoomServiceGetEmptyRoomArgs_Req_DEFAULT + } + return p.Req +} +func (p *EmptyRoomServiceGetEmptyRoomArgs) SetReq(val *EmptyRoomRequest) { + p.Req = val +} + +var fieldIDToName_EmptyRoomServiceGetEmptyRoomArgs = map[int16]string{ + 1: "req", +} + +func (p *EmptyRoomServiceGetEmptyRoomArgs) IsSetReq() bool { + return p.Req != nil +} + +func (p *EmptyRoomServiceGetEmptyRoomArgs) 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_EmptyRoomServiceGetEmptyRoomArgs[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 *EmptyRoomServiceGetEmptyRoomArgs) ReadField1(iprot thrift.TProtocol) error { + p.Req = NewEmptyRoomRequest() + if err := p.Req.Read(iprot); err != nil { + return err + } + return nil +} + +func (p *EmptyRoomServiceGetEmptyRoomArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("GetEmptyRoom_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 *EmptyRoomServiceGetEmptyRoomArgs) 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 *EmptyRoomServiceGetEmptyRoomArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("EmptyRoomServiceGetEmptyRoomArgs(%+v)", *p) + +} + +func (p *EmptyRoomServiceGetEmptyRoomArgs) DeepEqual(ano *EmptyRoomServiceGetEmptyRoomArgs) 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 *EmptyRoomServiceGetEmptyRoomArgs) Field1DeepEqual(src *EmptyRoomRequest) bool { + + if !p.Req.DeepEqual(src) { + return false + } + return true +} + +type EmptyRoomServiceGetEmptyRoomResult struct { + Success *EmptyRoomResponse `thrift:"success,0,optional" frugal:"0,optional,EmptyRoomResponse" json:"success,omitempty"` +} + +func NewEmptyRoomServiceGetEmptyRoomResult() *EmptyRoomServiceGetEmptyRoomResult { + return &EmptyRoomServiceGetEmptyRoomResult{} +} + +func (p *EmptyRoomServiceGetEmptyRoomResult) InitDefault() { + *p = EmptyRoomServiceGetEmptyRoomResult{} +} + +var EmptyRoomServiceGetEmptyRoomResult_Success_DEFAULT *EmptyRoomResponse + +func (p *EmptyRoomServiceGetEmptyRoomResult) GetSuccess() (v *EmptyRoomResponse) { + if !p.IsSetSuccess() { + return EmptyRoomServiceGetEmptyRoomResult_Success_DEFAULT + } + return p.Success +} +func (p *EmptyRoomServiceGetEmptyRoomResult) SetSuccess(x interface{}) { + p.Success = x.(*EmptyRoomResponse) +} + +var fieldIDToName_EmptyRoomServiceGetEmptyRoomResult = map[int16]string{ + 0: "success", +} + +func (p *EmptyRoomServiceGetEmptyRoomResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *EmptyRoomServiceGetEmptyRoomResult) 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 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_EmptyRoomServiceGetEmptyRoomResult[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 *EmptyRoomServiceGetEmptyRoomResult) ReadField0(iprot thrift.TProtocol) error { + p.Success = NewEmptyRoomResponse() + if err := p.Success.Read(iprot); err != nil { + return err + } + return nil +} + +func (p *EmptyRoomServiceGetEmptyRoomResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("GetEmptyRoom_result"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + 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 *EmptyRoomServiceGetEmptyRoomResult) 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 *EmptyRoomServiceGetEmptyRoomResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("EmptyRoomServiceGetEmptyRoomResult(%+v)", *p) + +} + +func (p *EmptyRoomServiceGetEmptyRoomResult) DeepEqual(ano *EmptyRoomServiceGetEmptyRoomResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field0DeepEqual(ano.Success) { + return false + } + return true +} + +func (p *EmptyRoomServiceGetEmptyRoomResult) Field0DeepEqual(src *EmptyRoomResponse) bool { + + if !p.Success.DeepEqual(src) { + return false + } + return true +} diff --git a/kitex_gen/empty_room/emptyroomservice/client.go b/kitex_gen/empty_room/emptyroomservice/client.go new file mode 100644 index 0000000..9e26ab2 --- /dev/null +++ b/kitex_gen/empty_room/emptyroomservice/client.go @@ -0,0 +1,49 @@ +// Code generated by Kitex v0.8.0. DO NOT EDIT. + +package emptyroomservice + +import ( + "context" + client "github.com/cloudwego/kitex/client" + callopt "github.com/cloudwego/kitex/client/callopt" + empty_room "github.com/west2-online/fzuhelper-server/kitex_gen/empty_room" +) + +// Client is designed to provide IDL-compatible methods with call-option parameter for kitex framework. +type Client interface { + GetEmptyRoom(ctx context.Context, req *empty_room.EmptyRoomRequest, callOptions ...callopt.Option) (r *empty_room.EmptyRoomResponse, err error) +} + +// NewClient creates a client for the service defined in IDL. +func NewClient(destService string, opts ...client.Option) (Client, error) { + var options []client.Option + options = append(options, client.WithDestService(destService)) + + options = append(options, opts...) + + kc, err := client.NewClient(serviceInfo(), options...) + if err != nil { + return nil, err + } + return &kEmptyRoomServiceClient{ + kClient: newServiceClient(kc), + }, nil +} + +// MustNewClient creates a client for the service defined in IDL. It panics if any error occurs. +func MustNewClient(destService string, opts ...client.Option) Client { + kc, err := NewClient(destService, opts...) + if err != nil { + panic(err) + } + return kc +} + +type kEmptyRoomServiceClient struct { + *kClient +} + +func (p *kEmptyRoomServiceClient) GetEmptyRoom(ctx context.Context, req *empty_room.EmptyRoomRequest, callOptions ...callopt.Option) (r *empty_room.EmptyRoomResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.GetEmptyRoom(ctx, req) +} diff --git a/kitex_gen/empty_room/emptyroomservice/emptyroomservice.go b/kitex_gen/empty_room/emptyroomservice/emptyroomservice.go new file mode 100644 index 0000000..e265370 --- /dev/null +++ b/kitex_gen/empty_room/emptyroomservice/emptyroomservice.go @@ -0,0 +1,75 @@ +// Code generated by Kitex v0.8.0. DO NOT EDIT. + +package emptyroomservice + +import ( + "context" + client "github.com/cloudwego/kitex/client" + kitex "github.com/cloudwego/kitex/pkg/serviceinfo" + empty_room "github.com/west2-online/fzuhelper-server/kitex_gen/empty_room" +) + +func serviceInfo() *kitex.ServiceInfo { + return emptyRoomServiceServiceInfo +} + +var emptyRoomServiceServiceInfo = NewServiceInfo() + +func NewServiceInfo() *kitex.ServiceInfo { + serviceName := "EmptyRoomService" + handlerType := (*empty_room.EmptyRoomService)(nil) + methods := map[string]kitex.MethodInfo{ + "GetEmptyRoom": kitex.NewMethodInfo(getEmptyRoomHandler, newEmptyRoomServiceGetEmptyRoomArgs, newEmptyRoomServiceGetEmptyRoomResult, false), + } + extra := map[string]interface{}{ + "PackageName": "empty_room", + "ServiceFilePath": `../../idl/empty_room.thrift`, + } + svcInfo := &kitex.ServiceInfo{ + ServiceName: serviceName, + HandlerType: handlerType, + Methods: methods, + PayloadCodec: kitex.Thrift, + KiteXGenVersion: "v0.8.0", + Extra: extra, + } + return svcInfo +} + +func getEmptyRoomHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*empty_room.EmptyRoomServiceGetEmptyRoomArgs) + realResult := result.(*empty_room.EmptyRoomServiceGetEmptyRoomResult) + success, err := handler.(empty_room.EmptyRoomService).GetEmptyRoom(ctx, realArg.Req) + if err != nil { + return err + } + realResult.Success = success + return nil +} +func newEmptyRoomServiceGetEmptyRoomArgs() interface{} { + return empty_room.NewEmptyRoomServiceGetEmptyRoomArgs() +} + +func newEmptyRoomServiceGetEmptyRoomResult() interface{} { + return empty_room.NewEmptyRoomServiceGetEmptyRoomResult() +} + +type kClient struct { + c client.Client +} + +func newServiceClient(c client.Client) *kClient { + return &kClient{ + c: c, + } +} + +func (p *kClient) GetEmptyRoom(ctx context.Context, req *empty_room.EmptyRoomRequest) (r *empty_room.EmptyRoomResponse, err error) { + var _args empty_room.EmptyRoomServiceGetEmptyRoomArgs + _args.Req = req + var _result empty_room.EmptyRoomServiceGetEmptyRoomResult + if err = p.c.Call(ctx, "GetEmptyRoom", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} diff --git a/kitex_gen/empty_room/emptyroomservice/invoker.go b/kitex_gen/empty_room/emptyroomservice/invoker.go new file mode 100644 index 0000000..a9cccd0 --- /dev/null +++ b/kitex_gen/empty_room/emptyroomservice/invoker.go @@ -0,0 +1,24 @@ +// Code generated by Kitex v0.8.0. DO NOT EDIT. + +package emptyroomservice + +import ( + server "github.com/cloudwego/kitex/server" + empty_room "github.com/west2-online/fzuhelper-server/kitex_gen/empty_room" +) + +// NewInvoker creates a server.Invoker with the given handler and options. +func NewInvoker(handler empty_room.EmptyRoomService, opts ...server.Option) server.Invoker { + var options []server.Option + + options = append(options, opts...) + + s := server.NewInvoker(options...) + if err := s.RegisterService(serviceInfo(), handler); err != nil { + panic(err) + } + if err := s.Init(); err != nil { + panic(err) + } + return s +} diff --git a/kitex_gen/empty_room/emptyroomservice/server.go b/kitex_gen/empty_room/emptyroomservice/server.go new file mode 100644 index 0000000..5d94f75 --- /dev/null +++ b/kitex_gen/empty_room/emptyroomservice/server.go @@ -0,0 +1,20 @@ +// Code generated by Kitex v0.8.0. DO NOT EDIT. +package emptyroomservice + +import ( + server "github.com/cloudwego/kitex/server" + empty_room "github.com/west2-online/fzuhelper-server/kitex_gen/empty_room" +) + +// NewServer creates a server.Server with the given handler and options. +func NewServer(handler empty_room.EmptyRoomService, opts ...server.Option) server.Server { + var options []server.Option + + options = append(options, opts...) + + svr := server.NewServer(options...) + if err := svr.RegisterService(serviceInfo(), handler); err != nil { + panic(err) + } + return svr +} diff --git a/kitex_gen/empty_room/k-consts.go b/kitex_gen/empty_room/k-consts.go new file mode 100644 index 0000000..2c7747e --- /dev/null +++ b/kitex_gen/empty_room/k-consts.go @@ -0,0 +1,4 @@ +package empty_room + +// KitexUnusedProtection is used to prevent 'imported and not used' error. +var KitexUnusedProtection = struct{}{} diff --git a/kitex_gen/empty_room/k-empty_room.go b/kitex_gen/empty_room/k-empty_room.go new file mode 100644 index 0000000..4277fbd --- /dev/null +++ b/kitex_gen/empty_room/k-empty_room.go @@ -0,0 +1,1146 @@ +// Code generated by Kitex v0.8.0. DO NOT EDIT. + +package empty_room + +import ( + "bytes" + "fmt" + "reflect" + "strings" + + "github.com/apache/thrift/lib/go/thrift" + + "github.com/cloudwego/kitex/pkg/protocol/bthrift" +) + +// unused protection +var ( + _ = fmt.Formatter(nil) + _ = (*bytes.Buffer)(nil) + _ = (*strings.Builder)(nil) + _ = reflect.Type(nil) + _ = thrift.TProtocol(nil) + _ = bthrift.BinaryWriter(nil) +) + +func (p *BaseResp) 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.I64 { + 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.STRING { + 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_BaseResp[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 *BaseResp) FastReadField1(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.Code = v + + } + return offset, nil +} + +func (p *BaseResp) FastReadField2(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.Msg = v + + } + return offset, nil +} + +// for compatibility +func (p *BaseResp) FastWrite(buf []byte) int { + return 0 +} + +func (p *BaseResp) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "BaseResp") + 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:]) + return offset +} + +func (p *BaseResp) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("BaseResp") + if p != nil { + l += p.field1Length() + l += p.field2Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *BaseResp) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "code", thrift.I64, 1) + offset += bthrift.Binary.WriteI64(buf[offset:], p.Code) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *BaseResp) fastWriteField2(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "msg", thrift.STRING, 2) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, p.Msg) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *BaseResp) field1Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("code", thrift.I64, 1) + l += bthrift.Binary.I64Length(p.Code) + + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *BaseResp) field2Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("msg", thrift.STRING, 2) + l += bthrift.Binary.StringLengthNocopy(p.Msg) + + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *EmptyRoomRequest) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + var issetToken bool = false + var issetTime bool = false + var issetStart bool = false + var issetEnd bool = false + var issetBuilding bool = false + _, 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.STRING { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + issetToken = true + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + issetTime = true + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 3: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField3(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + issetStart = true + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 4: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField4(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + issetEnd = true + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 5: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField5(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + issetBuilding = true + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 6: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField6(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 7: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField7(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 + } + + if !issetToken { + fieldId = 1 + goto RequiredFieldNotSetError + } + + if !issetTime { + fieldId = 2 + goto RequiredFieldNotSetError + } + + if !issetStart { + fieldId = 3 + goto RequiredFieldNotSetError + } + + if !issetEnd { + fieldId = 4 + goto RequiredFieldNotSetError + } + + if !issetBuilding { + fieldId = 5 + goto RequiredFieldNotSetError + } + 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_EmptyRoomRequest[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) +RequiredFieldNotSetError: + return offset, thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("required field %s is not set", fieldIDToName_EmptyRoomRequest[fieldId])) +} + +func (p *EmptyRoomRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.Token = v + + } + return offset, nil +} + +func (p *EmptyRoomRequest) FastReadField2(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.Time = v + + } + return offset, nil +} + +func (p *EmptyRoomRequest) FastReadField3(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.Start = v + + } + return offset, nil +} + +func (p *EmptyRoomRequest) FastReadField4(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.End = v + + } + return offset, nil +} + +func (p *EmptyRoomRequest) FastReadField5(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.Building = v + + } + return offset, nil +} + +func (p *EmptyRoomRequest) FastReadField6(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.Account = &v + + } + return offset, nil +} + +func (p *EmptyRoomRequest) FastReadField7(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.Password = &v + + } + return offset, nil +} + +// for compatibility +func (p *EmptyRoomRequest) FastWrite(buf []byte) int { + return 0 +} + +func (p *EmptyRoomRequest) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "EmptyRoomRequest") + if p != nil { + offset += p.fastWriteField1(buf[offset:], binaryWriter) + offset += p.fastWriteField2(buf[offset:], binaryWriter) + offset += p.fastWriteField3(buf[offset:], binaryWriter) + offset += p.fastWriteField4(buf[offset:], binaryWriter) + offset += p.fastWriteField5(buf[offset:], binaryWriter) + offset += p.fastWriteField6(buf[offset:], binaryWriter) + offset += p.fastWriteField7(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *EmptyRoomRequest) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("EmptyRoomRequest") + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field3Length() + l += p.field4Length() + l += p.field5Length() + l += p.field6Length() + l += p.field7Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *EmptyRoomRequest) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "token", thrift.STRING, 1) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, p.Token) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *EmptyRoomRequest) fastWriteField2(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "time", thrift.STRING, 2) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, p.Time) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *EmptyRoomRequest) fastWriteField3(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "start", thrift.STRING, 3) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, p.Start) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *EmptyRoomRequest) fastWriteField4(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "end", thrift.STRING, 4) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, p.End) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *EmptyRoomRequest) fastWriteField5(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "building", thrift.STRING, 5) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, p.Building) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *EmptyRoomRequest) fastWriteField6(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetAccount() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "account", thrift.STRING, 6) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.Account) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *EmptyRoomRequest) fastWriteField7(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetPassword() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "password", thrift.STRING, 7) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.Password) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *EmptyRoomRequest) field1Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("token", thrift.STRING, 1) + l += bthrift.Binary.StringLengthNocopy(p.Token) + + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *EmptyRoomRequest) field2Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("time", thrift.STRING, 2) + l += bthrift.Binary.StringLengthNocopy(p.Time) + + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *EmptyRoomRequest) field3Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("start", thrift.STRING, 3) + l += bthrift.Binary.StringLengthNocopy(p.Start) + + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *EmptyRoomRequest) field4Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("end", thrift.STRING, 4) + l += bthrift.Binary.StringLengthNocopy(p.End) + + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *EmptyRoomRequest) field5Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("building", thrift.STRING, 5) + l += bthrift.Binary.StringLengthNocopy(p.Building) + + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *EmptyRoomRequest) field6Length() int { + l := 0 + if p.IsSetAccount() { + l += bthrift.Binary.FieldBeginLength("account", thrift.STRING, 6) + l += bthrift.Binary.StringLengthNocopy(*p.Account) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *EmptyRoomRequest) field7Length() int { + l := 0 + if p.IsSetPassword() { + l += bthrift.Binary.FieldBeginLength("password", thrift.STRING, 7) + l += bthrift.Binary.StringLengthNocopy(*p.Password) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *EmptyRoomResponse) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + var issetBase bool = false + var issetRoomName bool = false + _, 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 + } + issetBase = true + } 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 + } + issetRoomName = true + } 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 + } + + if !issetBase { + fieldId = 1 + goto RequiredFieldNotSetError + } + + if !issetRoomName { + fieldId = 2 + goto RequiredFieldNotSetError + } + 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_EmptyRoomResponse[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) +RequiredFieldNotSetError: + return offset, thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("required field %s is not set", fieldIDToName_EmptyRoomResponse[fieldId])) +} + +func (p *EmptyRoomResponse) FastReadField1(buf []byte) (int, error) { + offset := 0 + + tmp := NewBaseResp() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Base = tmp + return offset, nil +} + +func (p *EmptyRoomResponse) FastReadField2(buf []byte) (int, error) { + offset := 0 + + _, size, l, err := bthrift.Binary.ReadListBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + p.RoomName = make([]string, 0, size) + for i := 0; i < size; i++ { + var _elem string + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + _elem = v + + } + + p.RoomName = append(p.RoomName, _elem) + } + if l, err := bthrift.Binary.ReadListEnd(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + return offset, nil +} + +// for compatibility +func (p *EmptyRoomResponse) FastWrite(buf []byte) int { + return 0 +} + +func (p *EmptyRoomResponse) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "EmptyRoomResponse") + 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:]) + return offset +} + +func (p *EmptyRoomResponse) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("EmptyRoomResponse") + if p != nil { + l += p.field1Length() + l += p.field2Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *EmptyRoomResponse) 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 *EmptyRoomResponse) fastWriteField2(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "room_name", thrift.LIST, 2) + listBeginOffset := offset + offset += bthrift.Binary.ListBeginLength(thrift.STRING, 0) + var length int + for _, v := range p.RoomName { + length++ + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, v) + + } + bthrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRING, length) + offset += bthrift.Binary.WriteListEnd(buf[offset:]) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *EmptyRoomResponse) field1Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("base", thrift.STRUCT, 1) + l += p.Base.BLength() + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *EmptyRoomResponse) field2Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("room_name", thrift.LIST, 2) + l += bthrift.Binary.ListBeginLength(thrift.STRING, len(p.RoomName)) + for _, v := range p.RoomName { + l += bthrift.Binary.StringLengthNocopy(v) + + } + l += bthrift.Binary.ListEndLength() + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *EmptyRoomServiceGetEmptyRoomArgs) 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_EmptyRoomServiceGetEmptyRoomArgs[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 *EmptyRoomServiceGetEmptyRoomArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + + tmp := NewEmptyRoomRequest() + 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 *EmptyRoomServiceGetEmptyRoomArgs) FastWrite(buf []byte) int { + return 0 +} + +func (p *EmptyRoomServiceGetEmptyRoomArgs) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "GetEmptyRoom_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 *EmptyRoomServiceGetEmptyRoomArgs) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("GetEmptyRoom_args") + if p != nil { + l += p.field1Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *EmptyRoomServiceGetEmptyRoomArgs) 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 *EmptyRoomServiceGetEmptyRoomArgs) field1Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("req", thrift.STRUCT, 1) + l += p.Req.BLength() + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *EmptyRoomServiceGetEmptyRoomResult) 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_EmptyRoomServiceGetEmptyRoomResult[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 *EmptyRoomServiceGetEmptyRoomResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + + tmp := NewEmptyRoomResponse() + 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 *EmptyRoomServiceGetEmptyRoomResult) FastWrite(buf []byte) int { + return 0 +} + +func (p *EmptyRoomServiceGetEmptyRoomResult) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "GetEmptyRoom_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 *EmptyRoomServiceGetEmptyRoomResult) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("GetEmptyRoom_result") + if p != nil { + l += p.field0Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *EmptyRoomServiceGetEmptyRoomResult) 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 *EmptyRoomServiceGetEmptyRoomResult) 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 *EmptyRoomServiceGetEmptyRoomArgs) GetFirstArgument() interface{} { + return p.Req +} + +func (p *EmptyRoomServiceGetEmptyRoomResult) GetResult() interface{} { + return p.Success +} diff --git a/pkg/constants/constants.go b/pkg/constants/constants.go index d1d0acc..c4234bd 100644 --- a/pkg/constants/constants.go +++ b/pkg/constants/constants.go @@ -14,10 +14,14 @@ const ( // service name TemplateServiceName = "template" + EmptyRoomService = "empty_room" // db table name TemplateServiceTableName = "template" + // redis + RedisDBEmptyRoom = 1 + // snowflake SnowflakeWorkerID = 0 SnowflakeDatacenterID = 0 @@ -31,4 +35,8 @@ const ( MaxGoroutines = 10 MaxOpenConns = 100 ConnMaxLifetime = 10 * time.Second + + // default account and password + DefaultAccount = "032005102" + DefaultPassword = "123456789c" ) diff --git a/pkg/utils/jwt.go b/pkg/utils/jwt.go new file mode 100644 index 0000000..1b11de6 --- /dev/null +++ b/pkg/utils/jwt.go @@ -0,0 +1,44 @@ +package utils + +import ( + "time" + + "github.com/golang-jwt/jwt" + "github.com/west2-online/fzuhelper-server/pkg/constants" +) + +type Claims struct { + UserId int64 `json:"user_id"` + jwt.StandardClaims +} + +func CreateToken(userId int64) (string, error) { + expireTime := time.Now().Add(24 * 7 * time.Hour) // 过期时间为7天 + nowTime := time.Now() // 当前时间 + claims := Claims{ + UserId: userId, + StandardClaims: jwt.StandardClaims{ + ExpiresAt: expireTime.Unix(), // 过期时间戳 + IssuedAt: nowTime.Unix(), // 当前时间戳 + Issuer: "tiktok", // 颁发者签名 + }, + } + tokenStruct := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + return tokenStruct.SignedString([]byte(constants.JWTValue)) +} + +func CheckToken(token string) (*Claims, error) { + response, err := jwt.ParseWithClaims(token, &Claims{}, func(token *jwt.Token) (interface{}, error) { + return []byte(constants.JWTValue), nil + }) + + if err != nil { + return nil, err + } + + if resp, ok := response.Claims.(*Claims); ok && response.Valid { + return resp, nil + } + + return nil, err +}