diff --git a/stalker.pb.go b/stalker.pb.go index 1a7e3e0..ddee6af 100644 --- a/stalker.pb.go +++ b/stalker.pb.go @@ -1791,6 +1791,529 @@ func (x *GetLinkedSteamAccountRequest) GetGlobalUserId() int64 { return 0 } +// SteamOnlineSession represents a period when a user was online on Steam +type SteamOnlineSession struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + GlobalUserId int64 `protobuf:"varint,2,opt,name=global_user_id,json=globalUserId,proto3" json:"global_user_id,omitempty"` + SteamId string `protobuf:"bytes,3,opt,name=steam_id,json=steamId,proto3" json:"steam_id,omitempty"` + StartedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"` + EndedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=ended_at,json=endedAt,proto3" json:"ended_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SteamOnlineSession) Reset() { + *x = SteamOnlineSession{} + mi := &file_stalker_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SteamOnlineSession) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SteamOnlineSession) ProtoMessage() {} + +func (x *SteamOnlineSession) ProtoReflect() protoreflect.Message { + mi := &file_stalker_proto_msgTypes[25] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SteamOnlineSession.ProtoReflect.Descriptor instead. +func (*SteamOnlineSession) Descriptor() ([]byte, []int) { + return file_stalker_proto_rawDescGZIP(), []int{25} +} + +func (x *SteamOnlineSession) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *SteamOnlineSession) GetGlobalUserId() int64 { + if x != nil { + return x.GlobalUserId + } + return 0 +} + +func (x *SteamOnlineSession) GetSteamId() string { + if x != nil { + return x.SteamId + } + return "" +} + +func (x *SteamOnlineSession) GetStartedAt() *timestamppb.Timestamp { + if x != nil { + return x.StartedAt + } + return nil +} + +func (x *SteamOnlineSession) GetEndedAt() *timestamppb.Timestamp { + if x != nil { + return x.EndedAt + } + return nil +} + +// SteamGameSession represents a period when a user was playing a specific game +type SteamGameSession struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + GlobalUserId int64 `protobuf:"varint,2,opt,name=global_user_id,json=globalUserId,proto3" json:"global_user_id,omitempty"` + SteamId string `protobuf:"bytes,3,opt,name=steam_id,json=steamId,proto3" json:"steam_id,omitempty"` + OnlineSessionId int64 `protobuf:"varint,4,opt,name=online_session_id,json=onlineSessionId,proto3" json:"online_session_id,omitempty"` + GameId string `protobuf:"bytes,5,opt,name=game_id,json=gameId,proto3" json:"game_id,omitempty"` + GameName string `protobuf:"bytes,6,opt,name=game_name,json=gameName,proto3" json:"game_name,omitempty"` + StartedAt *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"` + EndedAt *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=ended_at,json=endedAt,proto3" json:"ended_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SteamGameSession) Reset() { + *x = SteamGameSession{} + mi := &file_stalker_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SteamGameSession) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SteamGameSession) ProtoMessage() {} + +func (x *SteamGameSession) ProtoReflect() protoreflect.Message { + mi := &file_stalker_proto_msgTypes[26] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SteamGameSession.ProtoReflect.Descriptor instead. +func (*SteamGameSession) Descriptor() ([]byte, []int) { + return file_stalker_proto_rawDescGZIP(), []int{26} +} + +func (x *SteamGameSession) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *SteamGameSession) GetGlobalUserId() int64 { + if x != nil { + return x.GlobalUserId + } + return 0 +} + +func (x *SteamGameSession) GetSteamId() string { + if x != nil { + return x.SteamId + } + return "" +} + +func (x *SteamGameSession) GetOnlineSessionId() int64 { + if x != nil { + return x.OnlineSessionId + } + return 0 +} + +func (x *SteamGameSession) GetGameId() string { + if x != nil { + return x.GameId + } + return "" +} + +func (x *SteamGameSession) GetGameName() string { + if x != nil { + return x.GameName + } + return "" +} + +func (x *SteamGameSession) GetStartedAt() *timestamppb.Timestamp { + if x != nil { + return x.StartedAt + } + return nil +} + +func (x *SteamGameSession) GetEndedAt() *timestamppb.Timestamp { + if x != nil { + return x.EndedAt + } + return nil +} + +// SteamStats represents aggregated Steam activity statistics +type SteamStats struct { + state protoimpl.MessageState `protogen:"open.v1"` + TotalOnlineSessions int64 `protobuf:"varint,1,opt,name=total_online_sessions,json=totalOnlineSessions,proto3" json:"total_online_sessions,omitempty"` + TotalOnlineMinutes int64 `protobuf:"varint,2,opt,name=total_online_minutes,json=totalOnlineMinutes,proto3" json:"total_online_minutes,omitempty"` + TotalGameSessions int64 `protobuf:"varint,3,opt,name=total_game_sessions,json=totalGameSessions,proto3" json:"total_game_sessions,omitempty"` + TotalGameMinutes int64 `protobuf:"varint,4,opt,name=total_game_minutes,json=totalGameMinutes,proto3" json:"total_game_minutes,omitempty"` + FavoriteGameId string `protobuf:"bytes,5,opt,name=favorite_game_id,json=favoriteGameId,proto3" json:"favorite_game_id,omitempty"` + FavoriteGameName string `protobuf:"bytes,6,opt,name=favorite_game_name,json=favoriteGameName,proto3" json:"favorite_game_name,omitempty"` + FavoriteGameMinutes int64 `protobuf:"varint,7,opt,name=favorite_game_minutes,json=favoriteGameMinutes,proto3" json:"favorite_game_minutes,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SteamStats) Reset() { + *x = SteamStats{} + mi := &file_stalker_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SteamStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SteamStats) ProtoMessage() {} + +func (x *SteamStats) ProtoReflect() protoreflect.Message { + mi := &file_stalker_proto_msgTypes[27] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SteamStats.ProtoReflect.Descriptor instead. +func (*SteamStats) Descriptor() ([]byte, []int) { + return file_stalker_proto_rawDescGZIP(), []int{27} +} + +func (x *SteamStats) GetTotalOnlineSessions() int64 { + if x != nil { + return x.TotalOnlineSessions + } + return 0 +} + +func (x *SteamStats) GetTotalOnlineMinutes() int64 { + if x != nil { + return x.TotalOnlineMinutes + } + return 0 +} + +func (x *SteamStats) GetTotalGameSessions() int64 { + if x != nil { + return x.TotalGameSessions + } + return 0 +} + +func (x *SteamStats) GetTotalGameMinutes() int64 { + if x != nil { + return x.TotalGameMinutes + } + return 0 +} + +func (x *SteamStats) GetFavoriteGameId() string { + if x != nil { + return x.FavoriteGameId + } + return "" +} + +func (x *SteamStats) GetFavoriteGameName() string { + if x != nil { + return x.FavoriteGameName + } + return "" +} + +func (x *SteamStats) GetFavoriteGameMinutes() int64 { + if x != nil { + return x.FavoriteGameMinutes + } + return 0 +} + +type GetSteamSessionsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + GlobalUserId int64 `protobuf:"varint,1,opt,name=global_user_id,json=globalUserId,proto3" json:"global_user_id,omitempty"` + From *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"` + To *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSteamSessionsRequest) Reset() { + *x = GetSteamSessionsRequest{} + mi := &file_stalker_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSteamSessionsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSteamSessionsRequest) ProtoMessage() {} + +func (x *GetSteamSessionsRequest) ProtoReflect() protoreflect.Message { + mi := &file_stalker_proto_msgTypes[28] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSteamSessionsRequest.ProtoReflect.Descriptor instead. +func (*GetSteamSessionsRequest) Descriptor() ([]byte, []int) { + return file_stalker_proto_rawDescGZIP(), []int{28} +} + +func (x *GetSteamSessionsRequest) GetGlobalUserId() int64 { + if x != nil { + return x.GlobalUserId + } + return 0 +} + +func (x *GetSteamSessionsRequest) GetFrom() *timestamppb.Timestamp { + if x != nil { + return x.From + } + return nil +} + +func (x *GetSteamSessionsRequest) GetTo() *timestamppb.Timestamp { + if x != nil { + return x.To + } + return nil +} + +type GetSteamSessionsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Sessions []*SteamOnlineSession `protobuf:"bytes,1,rep,name=sessions,proto3" json:"sessions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSteamSessionsResponse) Reset() { + *x = GetSteamSessionsResponse{} + mi := &file_stalker_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSteamSessionsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSteamSessionsResponse) ProtoMessage() {} + +func (x *GetSteamSessionsResponse) ProtoReflect() protoreflect.Message { + mi := &file_stalker_proto_msgTypes[29] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSteamSessionsResponse.ProtoReflect.Descriptor instead. +func (*GetSteamSessionsResponse) Descriptor() ([]byte, []int) { + return file_stalker_proto_rawDescGZIP(), []int{29} +} + +func (x *GetSteamSessionsResponse) GetSessions() []*SteamOnlineSession { + if x != nil { + return x.Sessions + } + return nil +} + +type GetSteamGameSessionsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + GlobalUserId int64 `protobuf:"varint,1,opt,name=global_user_id,json=globalUserId,proto3" json:"global_user_id,omitempty"` + From *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"` + To *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSteamGameSessionsRequest) Reset() { + *x = GetSteamGameSessionsRequest{} + mi := &file_stalker_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSteamGameSessionsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSteamGameSessionsRequest) ProtoMessage() {} + +func (x *GetSteamGameSessionsRequest) ProtoReflect() protoreflect.Message { + mi := &file_stalker_proto_msgTypes[30] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSteamGameSessionsRequest.ProtoReflect.Descriptor instead. +func (*GetSteamGameSessionsRequest) Descriptor() ([]byte, []int) { + return file_stalker_proto_rawDescGZIP(), []int{30} +} + +func (x *GetSteamGameSessionsRequest) GetGlobalUserId() int64 { + if x != nil { + return x.GlobalUserId + } + return 0 +} + +func (x *GetSteamGameSessionsRequest) GetFrom() *timestamppb.Timestamp { + if x != nil { + return x.From + } + return nil +} + +func (x *GetSteamGameSessionsRequest) GetTo() *timestamppb.Timestamp { + if x != nil { + return x.To + } + return nil +} + +type GetSteamGameSessionsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Sessions []*SteamGameSession `protobuf:"bytes,1,rep,name=sessions,proto3" json:"sessions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSteamGameSessionsResponse) Reset() { + *x = GetSteamGameSessionsResponse{} + mi := &file_stalker_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSteamGameSessionsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSteamGameSessionsResponse) ProtoMessage() {} + +func (x *GetSteamGameSessionsResponse) ProtoReflect() protoreflect.Message { + mi := &file_stalker_proto_msgTypes[31] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSteamGameSessionsResponse.ProtoReflect.Descriptor instead. +func (*GetSteamGameSessionsResponse) Descriptor() ([]byte, []int) { + return file_stalker_proto_rawDescGZIP(), []int{31} +} + +func (x *GetSteamGameSessionsResponse) GetSessions() []*SteamGameSession { + if x != nil { + return x.Sessions + } + return nil +} + +type GetSteamStatsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + GlobalUserId int64 `protobuf:"varint,1,opt,name=global_user_id,json=globalUserId,proto3" json:"global_user_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSteamStatsRequest) Reset() { + *x = GetSteamStatsRequest{} + mi := &file_stalker_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSteamStatsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSteamStatsRequest) ProtoMessage() {} + +func (x *GetSteamStatsRequest) ProtoReflect() protoreflect.Message { + mi := &file_stalker_proto_msgTypes[32] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSteamStatsRequest.ProtoReflect.Descriptor instead. +func (*GetSteamStatsRequest) Descriptor() ([]byte, []int) { + return file_stalker_proto_rawDescGZIP(), []int{32} +} + +func (x *GetSteamStatsRequest) GetGlobalUserId() int64 { + if x != nil { + return x.GlobalUserId + } + return 0 +} + var File_stalker_proto protoreflect.FileDescriptor const file_stalker_proto_rawDesc = "" + @@ -1965,7 +2488,48 @@ const file_stalker_proto_rawDesc = "" + "\vprofile_url\x18\x04 \x01(\tR\n" + "profileUrl\"D\n" + "\x1cGetLinkedSteamAccountRequest\x12$\n" + - "\x0eglobal_user_id\x18\x01 \x01(\x03R\fglobalUserId2\x9e\b\n" + + "\x0eglobal_user_id\x18\x01 \x01(\x03R\fglobalUserId\"\xd7\x01\n" + + "\x12SteamOnlineSession\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\x12$\n" + + "\x0eglobal_user_id\x18\x02 \x01(\x03R\fglobalUserId\x12\x19\n" + + "\bsteam_id\x18\x03 \x01(\tR\asteamId\x129\n" + + "\n" + + "started_at\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\tstartedAt\x125\n" + + "\bended_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\aendedAt\"\xb7\x02\n" + + "\x10SteamGameSession\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\x12$\n" + + "\x0eglobal_user_id\x18\x02 \x01(\x03R\fglobalUserId\x12\x19\n" + + "\bsteam_id\x18\x03 \x01(\tR\asteamId\x12*\n" + + "\x11online_session_id\x18\x04 \x01(\x03R\x0fonlineSessionId\x12\x17\n" + + "\agame_id\x18\x05 \x01(\tR\x06gameId\x12\x1b\n" + + "\tgame_name\x18\x06 \x01(\tR\bgameName\x129\n" + + "\n" + + "started_at\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\tstartedAt\x125\n" + + "\bended_at\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\aendedAt\"\xdc\x02\n" + + "\n" + + "SteamStats\x122\n" + + "\x15total_online_sessions\x18\x01 \x01(\x03R\x13totalOnlineSessions\x120\n" + + "\x14total_online_minutes\x18\x02 \x01(\x03R\x12totalOnlineMinutes\x12.\n" + + "\x13total_game_sessions\x18\x03 \x01(\x03R\x11totalGameSessions\x12,\n" + + "\x12total_game_minutes\x18\x04 \x01(\x03R\x10totalGameMinutes\x12(\n" + + "\x10favorite_game_id\x18\x05 \x01(\tR\x0efavoriteGameId\x12,\n" + + "\x12favorite_game_name\x18\x06 \x01(\tR\x10favoriteGameName\x122\n" + + "\x15favorite_game_minutes\x18\a \x01(\x03R\x13favoriteGameMinutes\"\x9b\x01\n" + + "\x17GetSteamSessionsRequest\x12$\n" + + "\x0eglobal_user_id\x18\x01 \x01(\x03R\fglobalUserId\x12.\n" + + "\x04from\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x04from\x12*\n" + + "\x02to\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\x02to\"S\n" + + "\x18GetSteamSessionsResponse\x127\n" + + "\bsessions\x18\x01 \x03(\v2\x1b.stalker.SteamOnlineSessionR\bsessions\"\x9f\x01\n" + + "\x1bGetSteamGameSessionsRequest\x12$\n" + + "\x0eglobal_user_id\x18\x01 \x01(\x03R\fglobalUserId\x12.\n" + + "\x04from\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x04from\x12*\n" + + "\x02to\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\x02to\"U\n" + + "\x1cGetSteamGameSessionsResponse\x125\n" + + "\bsessions\x18\x01 \x03(\v2\x19.stalker.SteamGameSessionR\bsessions\"<\n" + + "\x14GetSteamStatsRequest\x12$\n" + + "\x0eglobal_user_id\x18\x01 \x01(\x03R\fglobalUserId2\xa1\n" + + "\n" + "\x0eStalkerService\x12=\n" + "\fSearchPlayer\x12\x1c.stalker.SearchPlayerRequest\x1a\x0f.stalker.Player\x12?\n" + "\rGetPlayerByID\x12\x1d.stalker.GetPlayerByIDRequest\x1a\x0f.stalker.Player\x12W\n" + @@ -1979,7 +2543,10 @@ const file_stalker_proto_rawDesc = "" + "\x11LinkFaceITAccount\x12!.stalker.LinkFaceITAccountRequest\x1a\x16.stalker.LinkedAccount\x12X\n" + "\x16GetLinkedFaceITAccount\x12&.stalker.GetLinkedFaceITAccountRequest\x1a\x16.stalker.LinkedAccount\x12L\n" + "\x10LinkSteamAccount\x12 .stalker.LinkSteamAccountRequest\x1a\x16.stalker.LinkedAccount\x12V\n" + - "\x15GetLinkedSteamAccount\x12%.stalker.GetLinkedSteamAccountRequest\x1a\x16.stalker.LinkedAccountB\x1fZ\x1dstalker-service/proto/stalkerb\x06proto3" + "\x15GetLinkedSteamAccount\x12%.stalker.GetLinkedSteamAccountRequest\x1a\x16.stalker.LinkedAccount\x12W\n" + + "\x10GetSteamSessions\x12 .stalker.GetSteamSessionsRequest\x1a!.stalker.GetSteamSessionsResponse\x12c\n" + + "\x14GetSteamGameSessions\x12$.stalker.GetSteamGameSessionsRequest\x1a%.stalker.GetSteamGameSessionsResponse\x12C\n" + + "\rGetSteamStats\x12\x1d.stalker.GetSteamStatsRequest\x1a\x13.stalker.SteamStatsB\x1fZ\x1dstalker-service/proto/stalkerb\x06proto3" var ( file_stalker_proto_rawDescOnce sync.Once @@ -1993,7 +2560,7 @@ func file_stalker_proto_rawDescGZIP() []byte { return file_stalker_proto_rawDescData } -var file_stalker_proto_msgTypes = make([]protoimpl.MessageInfo, 28) +var file_stalker_proto_msgTypes = make([]protoimpl.MessageInfo, 36) var file_stalker_proto_goTypes = []any{ (*Player)(nil), // 0: stalker.Player (*MatchStats)(nil), // 1: stalker.MatchStats @@ -2020,64 +2587,88 @@ var file_stalker_proto_goTypes = []any{ (*GetLinkedFaceITAccountRequest)(nil), // 22: stalker.GetLinkedFaceITAccountRequest (*LinkSteamAccountRequest)(nil), // 23: stalker.LinkSteamAccountRequest (*GetLinkedSteamAccountRequest)(nil), // 24: stalker.GetLinkedSteamAccountRequest - nil, // 25: stalker.MatchResult.TeamsEntry - nil, // 26: stalker.MatchResults.ScoreEntry - nil, // 27: stalker.MatchDetails.TeamsEntry - (*timestamppb.Timestamp)(nil), // 28: google.protobuf.Timestamp - (*emptypb.Empty)(nil), // 29: google.protobuf.Empty + (*SteamOnlineSession)(nil), // 25: stalker.SteamOnlineSession + (*SteamGameSession)(nil), // 26: stalker.SteamGameSession + (*SteamStats)(nil), // 27: stalker.SteamStats + (*GetSteamSessionsRequest)(nil), // 28: stalker.GetSteamSessionsRequest + (*GetSteamSessionsResponse)(nil), // 29: stalker.GetSteamSessionsResponse + (*GetSteamGameSessionsRequest)(nil), // 30: stalker.GetSteamGameSessionsRequest + (*GetSteamGameSessionsResponse)(nil), // 31: stalker.GetSteamGameSessionsResponse + (*GetSteamStatsRequest)(nil), // 32: stalker.GetSteamStatsRequest + nil, // 33: stalker.MatchResult.TeamsEntry + nil, // 34: stalker.MatchResults.ScoreEntry + nil, // 35: stalker.MatchDetails.TeamsEntry + (*timestamppb.Timestamp)(nil), // 36: google.protobuf.Timestamp + (*emptypb.Empty)(nil), // 37: google.protobuf.Empty } var file_stalker_proto_depIdxs = []int32{ 1, // 0: stalker.TeamPlayer.stats:type_name -> stalker.MatchStats 2, // 1: stalker.Team.players:type_name -> stalker.TeamPlayer - 25, // 2: stalker.MatchResult.teams:type_name -> stalker.MatchResult.TeamsEntry + 33, // 2: stalker.MatchResult.teams:type_name -> stalker.MatchResult.TeamsEntry 5, // 3: stalker.MatchResult.results:type_name -> stalker.MatchResults 1, // 4: stalker.MatchResult.player_stats:type_name -> stalker.MatchStats - 26, // 5: stalker.MatchResults.score:type_name -> stalker.MatchResults.ScoreEntry - 27, // 6: stalker.MatchDetails.teams:type_name -> stalker.MatchDetails.TeamsEntry + 34, // 5: stalker.MatchResults.score:type_name -> stalker.MatchResults.ScoreEntry + 35, // 6: stalker.MatchDetails.teams:type_name -> stalker.MatchDetails.TeamsEntry 5, // 7: stalker.MatchDetails.results:type_name -> stalker.MatchResults - 28, // 8: stalker.FaceITMatch.match_start_time:type_name -> google.protobuf.Timestamp - 28, // 9: stalker.FaceITMatch.match_end_time:type_name -> google.protobuf.Timestamp - 28, // 10: stalker.FaceITMatch.synced_at:type_name -> google.protobuf.Timestamp - 28, // 11: stalker.FaceITMatch.updated_at:type_name -> google.protobuf.Timestamp - 28, // 12: stalker.LinkedAccount.linked_at:type_name -> google.protobuf.Timestamp - 28, // 13: stalker.LinkedAccount.updated_at:type_name -> google.protobuf.Timestamp + 36, // 8: stalker.FaceITMatch.match_start_time:type_name -> google.protobuf.Timestamp + 36, // 9: stalker.FaceITMatch.match_end_time:type_name -> google.protobuf.Timestamp + 36, // 10: stalker.FaceITMatch.synced_at:type_name -> google.protobuf.Timestamp + 36, // 11: stalker.FaceITMatch.updated_at:type_name -> google.protobuf.Timestamp + 36, // 12: stalker.LinkedAccount.linked_at:type_name -> google.protobuf.Timestamp + 36, // 13: stalker.LinkedAccount.updated_at:type_name -> google.protobuf.Timestamp 4, // 14: stalker.GetPlayerMatchesResponse.matches:type_name -> stalker.MatchResult 7, // 15: stalker.SaveMatchesRequest.matches:type_name -> stalker.FaceITMatch 7, // 16: stalker.GetUserMatchesResponse.matches:type_name -> stalker.FaceITMatch - 28, // 17: stalker.GetMatchesSinceRequest.since:type_name -> google.protobuf.Timestamp - 3, // 18: stalker.MatchResult.TeamsEntry.value:type_name -> stalker.Team - 3, // 19: stalker.MatchDetails.TeamsEntry.value:type_name -> stalker.Team - 10, // 20: stalker.StalkerService.SearchPlayer:input_type -> stalker.SearchPlayerRequest - 11, // 21: stalker.StalkerService.GetPlayerByID:input_type -> stalker.GetPlayerByIDRequest - 12, // 22: stalker.StalkerService.GetPlayerMatches:input_type -> stalker.GetPlayerMatchesRequest - 14, // 23: stalker.StalkerService.GetMatchDetails:input_type -> stalker.GetMatchDetailsRequest - 15, // 24: stalker.StalkerService.SaveMatches:input_type -> stalker.SaveMatchesRequest - 16, // 25: stalker.StalkerService.GetUserMatches:input_type -> stalker.GetUserMatchesRequest - 18, // 26: stalker.StalkerService.GetUserMatchStats:input_type -> stalker.GetUserMatchStatsRequest - 19, // 27: stalker.StalkerService.GetMatchesSince:input_type -> stalker.GetMatchesSinceRequest - 20, // 28: stalker.StalkerService.GetMatchesLastNDays:input_type -> stalker.GetMatchesLastNDaysRequest - 21, // 29: stalker.StalkerService.LinkFaceITAccount:input_type -> stalker.LinkFaceITAccountRequest - 22, // 30: stalker.StalkerService.GetLinkedFaceITAccount:input_type -> stalker.GetLinkedFaceITAccountRequest - 23, // 31: stalker.StalkerService.LinkSteamAccount:input_type -> stalker.LinkSteamAccountRequest - 24, // 32: stalker.StalkerService.GetLinkedSteamAccount:input_type -> stalker.GetLinkedSteamAccountRequest - 0, // 33: stalker.StalkerService.SearchPlayer:output_type -> stalker.Player - 0, // 34: stalker.StalkerService.GetPlayerByID:output_type -> stalker.Player - 13, // 35: stalker.StalkerService.GetPlayerMatches:output_type -> stalker.GetPlayerMatchesResponse - 6, // 36: stalker.StalkerService.GetMatchDetails:output_type -> stalker.MatchDetails - 29, // 37: stalker.StalkerService.SaveMatches:output_type -> google.protobuf.Empty - 17, // 38: stalker.StalkerService.GetUserMatches:output_type -> stalker.GetUserMatchesResponse - 9, // 39: stalker.StalkerService.GetUserMatchStats:output_type -> stalker.UserMatchStats - 17, // 40: stalker.StalkerService.GetMatchesSince:output_type -> stalker.GetUserMatchesResponse - 17, // 41: stalker.StalkerService.GetMatchesLastNDays:output_type -> stalker.GetUserMatchesResponse - 8, // 42: stalker.StalkerService.LinkFaceITAccount:output_type -> stalker.LinkedAccount - 8, // 43: stalker.StalkerService.GetLinkedFaceITAccount:output_type -> stalker.LinkedAccount - 8, // 44: stalker.StalkerService.LinkSteamAccount:output_type -> stalker.LinkedAccount - 8, // 45: stalker.StalkerService.GetLinkedSteamAccount:output_type -> stalker.LinkedAccount - 33, // [33:46] is the sub-list for method output_type - 20, // [20:33] is the sub-list for method input_type - 20, // [20:20] is the sub-list for extension type_name - 20, // [20:20] is the sub-list for extension extendee - 0, // [0:20] is the sub-list for field type_name + 36, // 17: stalker.GetMatchesSinceRequest.since:type_name -> google.protobuf.Timestamp + 36, // 18: stalker.SteamOnlineSession.started_at:type_name -> google.protobuf.Timestamp + 36, // 19: stalker.SteamOnlineSession.ended_at:type_name -> google.protobuf.Timestamp + 36, // 20: stalker.SteamGameSession.started_at:type_name -> google.protobuf.Timestamp + 36, // 21: stalker.SteamGameSession.ended_at:type_name -> google.protobuf.Timestamp + 36, // 22: stalker.GetSteamSessionsRequest.from:type_name -> google.protobuf.Timestamp + 36, // 23: stalker.GetSteamSessionsRequest.to:type_name -> google.protobuf.Timestamp + 25, // 24: stalker.GetSteamSessionsResponse.sessions:type_name -> stalker.SteamOnlineSession + 36, // 25: stalker.GetSteamGameSessionsRequest.from:type_name -> google.protobuf.Timestamp + 36, // 26: stalker.GetSteamGameSessionsRequest.to:type_name -> google.protobuf.Timestamp + 26, // 27: stalker.GetSteamGameSessionsResponse.sessions:type_name -> stalker.SteamGameSession + 3, // 28: stalker.MatchResult.TeamsEntry.value:type_name -> stalker.Team + 3, // 29: stalker.MatchDetails.TeamsEntry.value:type_name -> stalker.Team + 10, // 30: stalker.StalkerService.SearchPlayer:input_type -> stalker.SearchPlayerRequest + 11, // 31: stalker.StalkerService.GetPlayerByID:input_type -> stalker.GetPlayerByIDRequest + 12, // 32: stalker.StalkerService.GetPlayerMatches:input_type -> stalker.GetPlayerMatchesRequest + 14, // 33: stalker.StalkerService.GetMatchDetails:input_type -> stalker.GetMatchDetailsRequest + 15, // 34: stalker.StalkerService.SaveMatches:input_type -> stalker.SaveMatchesRequest + 16, // 35: stalker.StalkerService.GetUserMatches:input_type -> stalker.GetUserMatchesRequest + 18, // 36: stalker.StalkerService.GetUserMatchStats:input_type -> stalker.GetUserMatchStatsRequest + 19, // 37: stalker.StalkerService.GetMatchesSince:input_type -> stalker.GetMatchesSinceRequest + 20, // 38: stalker.StalkerService.GetMatchesLastNDays:input_type -> stalker.GetMatchesLastNDaysRequest + 21, // 39: stalker.StalkerService.LinkFaceITAccount:input_type -> stalker.LinkFaceITAccountRequest + 22, // 40: stalker.StalkerService.GetLinkedFaceITAccount:input_type -> stalker.GetLinkedFaceITAccountRequest + 23, // 41: stalker.StalkerService.LinkSteamAccount:input_type -> stalker.LinkSteamAccountRequest + 24, // 42: stalker.StalkerService.GetLinkedSteamAccount:input_type -> stalker.GetLinkedSteamAccountRequest + 28, // 43: stalker.StalkerService.GetSteamSessions:input_type -> stalker.GetSteamSessionsRequest + 30, // 44: stalker.StalkerService.GetSteamGameSessions:input_type -> stalker.GetSteamGameSessionsRequest + 32, // 45: stalker.StalkerService.GetSteamStats:input_type -> stalker.GetSteamStatsRequest + 0, // 46: stalker.StalkerService.SearchPlayer:output_type -> stalker.Player + 0, // 47: stalker.StalkerService.GetPlayerByID:output_type -> stalker.Player + 13, // 48: stalker.StalkerService.GetPlayerMatches:output_type -> stalker.GetPlayerMatchesResponse + 6, // 49: stalker.StalkerService.GetMatchDetails:output_type -> stalker.MatchDetails + 37, // 50: stalker.StalkerService.SaveMatches:output_type -> google.protobuf.Empty + 17, // 51: stalker.StalkerService.GetUserMatches:output_type -> stalker.GetUserMatchesResponse + 9, // 52: stalker.StalkerService.GetUserMatchStats:output_type -> stalker.UserMatchStats + 17, // 53: stalker.StalkerService.GetMatchesSince:output_type -> stalker.GetUserMatchesResponse + 17, // 54: stalker.StalkerService.GetMatchesLastNDays:output_type -> stalker.GetUserMatchesResponse + 8, // 55: stalker.StalkerService.LinkFaceITAccount:output_type -> stalker.LinkedAccount + 8, // 56: stalker.StalkerService.GetLinkedFaceITAccount:output_type -> stalker.LinkedAccount + 8, // 57: stalker.StalkerService.LinkSteamAccount:output_type -> stalker.LinkedAccount + 8, // 58: stalker.StalkerService.GetLinkedSteamAccount:output_type -> stalker.LinkedAccount + 29, // 59: stalker.StalkerService.GetSteamSessions:output_type -> stalker.GetSteamSessionsResponse + 31, // 60: stalker.StalkerService.GetSteamGameSessions:output_type -> stalker.GetSteamGameSessionsResponse + 27, // 61: stalker.StalkerService.GetSteamStats:output_type -> stalker.SteamStats + 46, // [46:62] is the sub-list for method output_type + 30, // [30:46] is the sub-list for method input_type + 30, // [30:30] is the sub-list for extension type_name + 30, // [30:30] is the sub-list for extension extendee + 0, // [0:30] is the sub-list for field type_name } func init() { file_stalker_proto_init() } @@ -2091,7 +2682,7 @@ func file_stalker_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_stalker_proto_rawDesc), len(file_stalker_proto_rawDesc)), NumEnums: 0, - NumMessages: 28, + NumMessages: 36, NumExtensions: 0, NumServices: 1, }, diff --git a/stalker.proto b/stalker.proto index ee83320..def34b4 100644 --- a/stalker.proto +++ b/stalker.proto @@ -29,6 +29,11 @@ service StalkerService { rpc GetLinkedFaceITAccount(GetLinkedFaceITAccountRequest) returns (LinkedAccount); rpc LinkSteamAccount(LinkSteamAccountRequest) returns (LinkedAccount); rpc GetLinkedSteamAccount(GetLinkedSteamAccountRequest) returns (LinkedAccount); + + // Steam session tracking + rpc GetSteamSessions(GetSteamSessionsRequest) returns (GetSteamSessionsResponse); + rpc GetSteamGameSessions(GetSteamGameSessionsRequest) returns (GetSteamGameSessionsResponse); + rpc GetSteamStats(GetSteamStatsRequest) returns (SteamStats); } // Player represents a FaceIT player @@ -225,3 +230,59 @@ message LinkSteamAccountRequest { message GetLinkedSteamAccountRequest { int64 global_user_id = 1; } + +// SteamOnlineSession represents a period when a user was online on Steam +message SteamOnlineSession { + int64 id = 1; + int64 global_user_id = 2; + string steam_id = 3; + google.protobuf.Timestamp started_at = 4; + google.protobuf.Timestamp ended_at = 5; +} + +// SteamGameSession represents a period when a user was playing a specific game +message SteamGameSession { + int64 id = 1; + int64 global_user_id = 2; + string steam_id = 3; + int64 online_session_id = 4; + string game_id = 5; + string game_name = 6; + google.protobuf.Timestamp started_at = 7; + google.protobuf.Timestamp ended_at = 8; +} + +// SteamStats represents aggregated Steam activity statistics +message SteamStats { + int64 total_online_sessions = 1; + int64 total_online_minutes = 2; + int64 total_game_sessions = 3; + int64 total_game_minutes = 4; + string favorite_game_id = 5; + string favorite_game_name = 6; + int64 favorite_game_minutes = 7; +} + +message GetSteamSessionsRequest { + int64 global_user_id = 1; + google.protobuf.Timestamp from = 2; + google.protobuf.Timestamp to = 3; +} + +message GetSteamSessionsResponse { + repeated SteamOnlineSession sessions = 1; +} + +message GetSteamGameSessionsRequest { + int64 global_user_id = 1; + google.protobuf.Timestamp from = 2; + google.protobuf.Timestamp to = 3; +} + +message GetSteamGameSessionsResponse { + repeated SteamGameSession sessions = 1; +} + +message GetSteamStatsRequest { + int64 global_user_id = 1; +} diff --git a/stalker_grpc.pb.go b/stalker_grpc.pb.go index c18af41..ca04525 100644 --- a/stalker_grpc.pb.go +++ b/stalker_grpc.pb.go @@ -33,6 +33,9 @@ const ( StalkerService_GetLinkedFaceITAccount_FullMethodName = "/stalker.StalkerService/GetLinkedFaceITAccount" StalkerService_LinkSteamAccount_FullMethodName = "/stalker.StalkerService/LinkSteamAccount" StalkerService_GetLinkedSteamAccount_FullMethodName = "/stalker.StalkerService/GetLinkedSteamAccount" + StalkerService_GetSteamSessions_FullMethodName = "/stalker.StalkerService/GetSteamSessions" + StalkerService_GetSteamGameSessions_FullMethodName = "/stalker.StalkerService/GetSteamGameSessions" + StalkerService_GetSteamStats_FullMethodName = "/stalker.StalkerService/GetSteamStats" ) // StalkerServiceClient is the client API for StalkerService service. @@ -58,6 +61,10 @@ type StalkerServiceClient interface { GetLinkedFaceITAccount(ctx context.Context, in *GetLinkedFaceITAccountRequest, opts ...grpc.CallOption) (*LinkedAccount, error) LinkSteamAccount(ctx context.Context, in *LinkSteamAccountRequest, opts ...grpc.CallOption) (*LinkedAccount, error) GetLinkedSteamAccount(ctx context.Context, in *GetLinkedSteamAccountRequest, opts ...grpc.CallOption) (*LinkedAccount, error) + // Steam session tracking + GetSteamSessions(ctx context.Context, in *GetSteamSessionsRequest, opts ...grpc.CallOption) (*GetSteamSessionsResponse, error) + GetSteamGameSessions(ctx context.Context, in *GetSteamGameSessionsRequest, opts ...grpc.CallOption) (*GetSteamGameSessionsResponse, error) + GetSteamStats(ctx context.Context, in *GetSteamStatsRequest, opts ...grpc.CallOption) (*SteamStats, error) } type stalkerServiceClient struct { @@ -198,6 +205,36 @@ func (c *stalkerServiceClient) GetLinkedSteamAccount(ctx context.Context, in *Ge return out, nil } +func (c *stalkerServiceClient) GetSteamSessions(ctx context.Context, in *GetSteamSessionsRequest, opts ...grpc.CallOption) (*GetSteamSessionsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetSteamSessionsResponse) + err := c.cc.Invoke(ctx, StalkerService_GetSteamSessions_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *stalkerServiceClient) GetSteamGameSessions(ctx context.Context, in *GetSteamGameSessionsRequest, opts ...grpc.CallOption) (*GetSteamGameSessionsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetSteamGameSessionsResponse) + err := c.cc.Invoke(ctx, StalkerService_GetSteamGameSessions_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *stalkerServiceClient) GetSteamStats(ctx context.Context, in *GetSteamStatsRequest, opts ...grpc.CallOption) (*SteamStats, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SteamStats) + err := c.cc.Invoke(ctx, StalkerService_GetSteamStats_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + // StalkerServiceServer is the server API for StalkerService service. // All implementations must embed UnimplementedStalkerServiceServer // for forward compatibility. @@ -221,6 +258,10 @@ type StalkerServiceServer interface { GetLinkedFaceITAccount(context.Context, *GetLinkedFaceITAccountRequest) (*LinkedAccount, error) LinkSteamAccount(context.Context, *LinkSteamAccountRequest) (*LinkedAccount, error) GetLinkedSteamAccount(context.Context, *GetLinkedSteamAccountRequest) (*LinkedAccount, error) + // Steam session tracking + GetSteamSessions(context.Context, *GetSteamSessionsRequest) (*GetSteamSessionsResponse, error) + GetSteamGameSessions(context.Context, *GetSteamGameSessionsRequest) (*GetSteamGameSessionsResponse, error) + GetSteamStats(context.Context, *GetSteamStatsRequest) (*SteamStats, error) mustEmbedUnimplementedStalkerServiceServer() } @@ -270,6 +311,15 @@ func (UnimplementedStalkerServiceServer) LinkSteamAccount(context.Context, *Link func (UnimplementedStalkerServiceServer) GetLinkedSteamAccount(context.Context, *GetLinkedSteamAccountRequest) (*LinkedAccount, error) { return nil, status.Error(codes.Unimplemented, "method GetLinkedSteamAccount not implemented") } +func (UnimplementedStalkerServiceServer) GetSteamSessions(context.Context, *GetSteamSessionsRequest) (*GetSteamSessionsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetSteamSessions not implemented") +} +func (UnimplementedStalkerServiceServer) GetSteamGameSessions(context.Context, *GetSteamGameSessionsRequest) (*GetSteamGameSessionsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetSteamGameSessions not implemented") +} +func (UnimplementedStalkerServiceServer) GetSteamStats(context.Context, *GetSteamStatsRequest) (*SteamStats, error) { + return nil, status.Error(codes.Unimplemented, "method GetSteamStats not implemented") +} func (UnimplementedStalkerServiceServer) mustEmbedUnimplementedStalkerServiceServer() {} func (UnimplementedStalkerServiceServer) testEmbeddedByValue() {} @@ -525,6 +575,60 @@ func _StalkerService_GetLinkedSteamAccount_Handler(srv interface{}, ctx context. return interceptor(ctx, in, info, handler) } +func _StalkerService_GetSteamSessions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetSteamSessionsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StalkerServiceServer).GetSteamSessions(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: StalkerService_GetSteamSessions_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StalkerServiceServer).GetSteamSessions(ctx, req.(*GetSteamSessionsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _StalkerService_GetSteamGameSessions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetSteamGameSessionsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StalkerServiceServer).GetSteamGameSessions(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: StalkerService_GetSteamGameSessions_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StalkerServiceServer).GetSteamGameSessions(ctx, req.(*GetSteamGameSessionsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _StalkerService_GetSteamStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetSteamStatsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(StalkerServiceServer).GetSteamStats(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: StalkerService_GetSteamStats_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(StalkerServiceServer).GetSteamStats(ctx, req.(*GetSteamStatsRequest)) + } + return interceptor(ctx, in, info, handler) +} + // StalkerService_ServiceDesc is the grpc.ServiceDesc for StalkerService service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -584,6 +688,18 @@ var StalkerService_ServiceDesc = grpc.ServiceDesc{ MethodName: "GetLinkedSteamAccount", Handler: _StalkerService_GetLinkedSteamAccount_Handler, }, + { + MethodName: "GetSteamSessions", + Handler: _StalkerService_GetSteamSessions_Handler, + }, + { + MethodName: "GetSteamGameSessions", + Handler: _StalkerService_GetSteamGameSessions_Handler, + }, + { + MethodName: "GetSteamStats", + Handler: _StalkerService_GetSteamStats_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "stalker.proto",