1// Copyright 2019 Google LLC. 2// Use of this source code is governed by a BSD-style 3// license that can be found in the LICENSE file. 4 5// Code generated file. DO NOT EDIT. 6 7// Package gamesmanagement provides access to the Google Play Game Services Management API. 8// 9// For product documentation, see: https://developers.google.com/games/services 10// 11// Creating a client 12// 13// Usage example: 14// 15// import "google.golang.org/api/gamesmanagement/v1management" 16// ... 17// ctx := context.Background() 18// gamesmanagementService, err := gamesmanagement.NewService(ctx) 19// 20// In this example, Google Application Default Credentials are used for authentication. 21// 22// For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials. 23// 24// Other authentication options 25// 26// To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey: 27// 28// gamesmanagementService, err := gamesmanagement.NewService(ctx, option.WithAPIKey("AIza...")) 29// 30// To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource: 31// 32// config := &oauth2.Config{...} 33// // ... 34// token, err := config.Exchange(ctx, ...) 35// gamesmanagementService, err := gamesmanagement.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token))) 36// 37// See https://godoc.org/google.golang.org/api/option/ for details on options. 38package gamesmanagement // import "google.golang.org/api/gamesmanagement/v1management" 39 40import ( 41 "bytes" 42 "context" 43 "encoding/json" 44 "errors" 45 "fmt" 46 "io" 47 "net/http" 48 "net/url" 49 "strconv" 50 "strings" 51 52 googleapi "google.golang.org/api/googleapi" 53 gensupport "google.golang.org/api/internal/gensupport" 54 option "google.golang.org/api/option" 55 htransport "google.golang.org/api/transport/http" 56) 57 58// Always reference these packages, just in case the auto-generated code 59// below doesn't. 60var _ = bytes.NewBuffer 61var _ = strconv.Itoa 62var _ = fmt.Sprintf 63var _ = json.NewDecoder 64var _ = io.Copy 65var _ = url.Parse 66var _ = gensupport.MarshalJSON 67var _ = googleapi.Version 68var _ = errors.New 69var _ = strings.Replace 70var _ = context.Canceled 71 72const apiId = "gamesManagement:v1management" 73const apiName = "gamesManagement" 74const apiVersion = "v1management" 75const basePath = "https://www.googleapis.com/games/v1management/" 76 77// OAuth2 scopes used by this API. 78const ( 79 // Create, edit, and delete your Google Play Games activity 80 GamesScope = "https://www.googleapis.com/auth/games" 81) 82 83// NewService creates a new Service. 84func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) { 85 scopesOption := option.WithScopes( 86 "https://www.googleapis.com/auth/games", 87 ) 88 // NOTE: prepend, so we don't override user-specified scopes. 89 opts = append([]option.ClientOption{scopesOption}, opts...) 90 client, endpoint, err := htransport.NewClient(ctx, opts...) 91 if err != nil { 92 return nil, err 93 } 94 s, err := New(client) 95 if err != nil { 96 return nil, err 97 } 98 if endpoint != "" { 99 s.BasePath = endpoint 100 } 101 return s, nil 102} 103 104// New creates a new Service. It uses the provided http.Client for requests. 105// 106// Deprecated: please use NewService instead. 107// To provide a custom HTTP client, use option.WithHTTPClient. 108// If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead. 109func New(client *http.Client) (*Service, error) { 110 if client == nil { 111 return nil, errors.New("client is nil") 112 } 113 s := &Service{client: client, BasePath: basePath} 114 s.Achievements = NewAchievementsService(s) 115 s.Applications = NewApplicationsService(s) 116 s.Events = NewEventsService(s) 117 s.Players = NewPlayersService(s) 118 s.Rooms = NewRoomsService(s) 119 s.Scores = NewScoresService(s) 120 s.TurnBasedMatches = NewTurnBasedMatchesService(s) 121 return s, nil 122} 123 124type Service struct { 125 client *http.Client 126 BasePath string // API endpoint base URL 127 UserAgent string // optional additional User-Agent fragment 128 129 Achievements *AchievementsService 130 131 Applications *ApplicationsService 132 133 Events *EventsService 134 135 Players *PlayersService 136 137 Rooms *RoomsService 138 139 Scores *ScoresService 140 141 TurnBasedMatches *TurnBasedMatchesService 142} 143 144func (s *Service) userAgent() string { 145 if s.UserAgent == "" { 146 return googleapi.UserAgent 147 } 148 return googleapi.UserAgent + " " + s.UserAgent 149} 150 151func NewAchievementsService(s *Service) *AchievementsService { 152 rs := &AchievementsService{s: s} 153 return rs 154} 155 156type AchievementsService struct { 157 s *Service 158} 159 160func NewApplicationsService(s *Service) *ApplicationsService { 161 rs := &ApplicationsService{s: s} 162 return rs 163} 164 165type ApplicationsService struct { 166 s *Service 167} 168 169func NewEventsService(s *Service) *EventsService { 170 rs := &EventsService{s: s} 171 return rs 172} 173 174type EventsService struct { 175 s *Service 176} 177 178func NewPlayersService(s *Service) *PlayersService { 179 rs := &PlayersService{s: s} 180 return rs 181} 182 183type PlayersService struct { 184 s *Service 185} 186 187func NewRoomsService(s *Service) *RoomsService { 188 rs := &RoomsService{s: s} 189 return rs 190} 191 192type RoomsService struct { 193 s *Service 194} 195 196func NewScoresService(s *Service) *ScoresService { 197 rs := &ScoresService{s: s} 198 return rs 199} 200 201type ScoresService struct { 202 s *Service 203} 204 205func NewTurnBasedMatchesService(s *Service) *TurnBasedMatchesService { 206 rs := &TurnBasedMatchesService{s: s} 207 return rs 208} 209 210type TurnBasedMatchesService struct { 211 s *Service 212} 213 214// AchievementResetAllResponse: This is a JSON template for achievement 215// reset all response. 216type AchievementResetAllResponse struct { 217 // Kind: Uniquely identifies the type of this resource. Value is always 218 // the fixed string gamesManagement#achievementResetAllResponse. 219 Kind string `json:"kind,omitempty"` 220 221 // Results: The achievement reset results. 222 Results []*AchievementResetResponse `json:"results,omitempty"` 223 224 // ServerResponse contains the HTTP response code and headers from the 225 // server. 226 googleapi.ServerResponse `json:"-"` 227 228 // ForceSendFields is a list of field names (e.g. "Kind") to 229 // unconditionally include in API requests. By default, fields with 230 // empty values are omitted from API requests. However, any non-pointer, 231 // non-interface field appearing in ForceSendFields will be sent to the 232 // server regardless of whether the field is empty or not. This may be 233 // used to include empty fields in Patch requests. 234 ForceSendFields []string `json:"-"` 235 236 // NullFields is a list of field names (e.g. "Kind") to include in API 237 // requests with the JSON null value. By default, fields with empty 238 // values are omitted from API requests. However, any field with an 239 // empty value appearing in NullFields will be sent to the server as 240 // null. It is an error if a field in this list has a non-empty value. 241 // This may be used to include null fields in Patch requests. 242 NullFields []string `json:"-"` 243} 244 245func (s *AchievementResetAllResponse) MarshalJSON() ([]byte, error) { 246 type NoMethod AchievementResetAllResponse 247 raw := NoMethod(*s) 248 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 249} 250 251// AchievementResetMultipleForAllRequest: This is a JSON template for 252// multiple achievements reset all request. 253type AchievementResetMultipleForAllRequest struct { 254 // AchievementIds: The IDs of achievements to reset. 255 AchievementIds []string `json:"achievement_ids,omitempty"` 256 257 // Kind: Uniquely identifies the type of this resource. Value is always 258 // the fixed string 259 // gamesManagement#achievementResetMultipleForAllRequest. 260 Kind string `json:"kind,omitempty"` 261 262 // ForceSendFields is a list of field names (e.g. "AchievementIds") to 263 // unconditionally include in API requests. By default, fields with 264 // empty values are omitted from API requests. However, any non-pointer, 265 // non-interface field appearing in ForceSendFields will be sent to the 266 // server regardless of whether the field is empty or not. This may be 267 // used to include empty fields in Patch requests. 268 ForceSendFields []string `json:"-"` 269 270 // NullFields is a list of field names (e.g. "AchievementIds") to 271 // include in API requests with the JSON null value. By default, fields 272 // with empty values are omitted from API requests. However, any field 273 // with an empty value appearing in NullFields will be sent to the 274 // server as null. It is an error if a field in this list has a 275 // non-empty value. This may be used to include null fields in Patch 276 // requests. 277 NullFields []string `json:"-"` 278} 279 280func (s *AchievementResetMultipleForAllRequest) MarshalJSON() ([]byte, error) { 281 type NoMethod AchievementResetMultipleForAllRequest 282 raw := NoMethod(*s) 283 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 284} 285 286// AchievementResetResponse: This is a JSON template for an achievement 287// reset response. 288type AchievementResetResponse struct { 289 // CurrentState: The current state of the achievement. This is the same 290 // as the initial state of the achievement. 291 // Possible values are: 292 // - "HIDDEN"- Achievement is hidden. 293 // - "REVEALED" - Achievement is revealed. 294 // - "UNLOCKED" - Achievement is unlocked. 295 CurrentState string `json:"currentState,omitempty"` 296 297 // DefinitionId: The ID of an achievement for which player state has 298 // been updated. 299 DefinitionId string `json:"definitionId,omitempty"` 300 301 // Kind: Uniquely identifies the type of this resource. Value is always 302 // the fixed string gamesManagement#achievementResetResponse. 303 Kind string `json:"kind,omitempty"` 304 305 // UpdateOccurred: Flag to indicate if the requested update actually 306 // occurred. 307 UpdateOccurred bool `json:"updateOccurred,omitempty"` 308 309 // ServerResponse contains the HTTP response code and headers from the 310 // server. 311 googleapi.ServerResponse `json:"-"` 312 313 // ForceSendFields is a list of field names (e.g. "CurrentState") to 314 // unconditionally include in API requests. By default, fields with 315 // empty values are omitted from API requests. However, any non-pointer, 316 // non-interface field appearing in ForceSendFields will be sent to the 317 // server regardless of whether the field is empty or not. This may be 318 // used to include empty fields in Patch requests. 319 ForceSendFields []string `json:"-"` 320 321 // NullFields is a list of field names (e.g. "CurrentState") to include 322 // in API requests with the JSON null value. By default, fields with 323 // empty values are omitted from API requests. However, any field with 324 // an empty value appearing in NullFields will be sent to the server as 325 // null. It is an error if a field in this list has a non-empty value. 326 // This may be used to include null fields in Patch requests. 327 NullFields []string `json:"-"` 328} 329 330func (s *AchievementResetResponse) MarshalJSON() ([]byte, error) { 331 type NoMethod AchievementResetResponse 332 raw := NoMethod(*s) 333 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 334} 335 336// EventsResetMultipleForAllRequest: This is a JSON template for 337// multiple events reset all request. 338type EventsResetMultipleForAllRequest struct { 339 // EventIds: The IDs of events to reset. 340 EventIds []string `json:"event_ids,omitempty"` 341 342 // Kind: Uniquely identifies the type of this resource. Value is always 343 // the fixed string gamesManagement#eventsResetMultipleForAllRequest. 344 Kind string `json:"kind,omitempty"` 345 346 // ForceSendFields is a list of field names (e.g. "EventIds") to 347 // unconditionally include in API requests. By default, fields with 348 // empty values are omitted from API requests. However, any non-pointer, 349 // non-interface field appearing in ForceSendFields will be sent to the 350 // server regardless of whether the field is empty or not. This may be 351 // used to include empty fields in Patch requests. 352 ForceSendFields []string `json:"-"` 353 354 // NullFields is a list of field names (e.g. "EventIds") to include in 355 // API requests with the JSON null value. By default, fields with empty 356 // values are omitted from API requests. However, any field with an 357 // empty value appearing in NullFields will be sent to the server as 358 // null. It is an error if a field in this list has a non-empty value. 359 // This may be used to include null fields in Patch requests. 360 NullFields []string `json:"-"` 361} 362 363func (s *EventsResetMultipleForAllRequest) MarshalJSON() ([]byte, error) { 364 type NoMethod EventsResetMultipleForAllRequest 365 raw := NoMethod(*s) 366 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 367} 368 369// GamesPlayedResource: This is a JSON template for metadata about a 370// player playing a game with the currently authenticated user. 371type GamesPlayedResource struct { 372 // AutoMatched: True if the player was auto-matched with the currently 373 // authenticated user. 374 AutoMatched bool `json:"autoMatched,omitempty"` 375 376 // TimeMillis: The last time the player played the game in milliseconds 377 // since the epoch in UTC. 378 TimeMillis int64 `json:"timeMillis,omitempty,string"` 379 380 // ForceSendFields is a list of field names (e.g. "AutoMatched") to 381 // unconditionally include in API requests. By default, fields with 382 // empty values are omitted from API requests. However, any non-pointer, 383 // non-interface field appearing in ForceSendFields will be sent to the 384 // server regardless of whether the field is empty or not. This may be 385 // used to include empty fields in Patch requests. 386 ForceSendFields []string `json:"-"` 387 388 // NullFields is a list of field names (e.g. "AutoMatched") to include 389 // in API requests with the JSON null value. By default, fields with 390 // empty values are omitted from API requests. However, any field with 391 // an empty value appearing in NullFields will be sent to the server as 392 // null. It is an error if a field in this list has a non-empty value. 393 // This may be used to include null fields in Patch requests. 394 NullFields []string `json:"-"` 395} 396 397func (s *GamesPlayedResource) MarshalJSON() ([]byte, error) { 398 type NoMethod GamesPlayedResource 399 raw := NoMethod(*s) 400 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 401} 402 403// GamesPlayerExperienceInfoResource: This is a JSON template for 1P/3P 404// metadata about the player's experience. 405type GamesPlayerExperienceInfoResource struct { 406 // CurrentExperiencePoints: The current number of experience points for 407 // the player. 408 CurrentExperiencePoints int64 `json:"currentExperiencePoints,omitempty,string"` 409 410 // CurrentLevel: The current level of the player. 411 CurrentLevel *GamesPlayerLevelResource `json:"currentLevel,omitempty"` 412 413 // LastLevelUpTimestampMillis: The timestamp when the player was leveled 414 // up, in millis since Unix epoch UTC. 415 LastLevelUpTimestampMillis int64 `json:"lastLevelUpTimestampMillis,omitempty,string"` 416 417 // NextLevel: The next level of the player. If the current level is the 418 // maximum level, this should be same as the current level. 419 NextLevel *GamesPlayerLevelResource `json:"nextLevel,omitempty"` 420 421 // ForceSendFields is a list of field names (e.g. 422 // "CurrentExperiencePoints") to unconditionally include in API 423 // requests. By default, fields with empty values are omitted from API 424 // requests. However, any non-pointer, non-interface field appearing in 425 // ForceSendFields will be sent to the server regardless of whether the 426 // field is empty or not. This may be used to include empty fields in 427 // Patch requests. 428 ForceSendFields []string `json:"-"` 429 430 // NullFields is a list of field names (e.g. "CurrentExperiencePoints") 431 // to include in API requests with the JSON null value. By default, 432 // fields with empty values are omitted from API requests. However, any 433 // field with an empty value appearing in NullFields will be sent to the 434 // server as null. It is an error if a field in this list has a 435 // non-empty value. This may be used to include null fields in Patch 436 // requests. 437 NullFields []string `json:"-"` 438} 439 440func (s *GamesPlayerExperienceInfoResource) MarshalJSON() ([]byte, error) { 441 type NoMethod GamesPlayerExperienceInfoResource 442 raw := NoMethod(*s) 443 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 444} 445 446// GamesPlayerLevelResource: This is a JSON template for 1P/3P metadata 447// about a user's level. 448type GamesPlayerLevelResource struct { 449 // Level: The level for the user. 450 Level int64 `json:"level,omitempty"` 451 452 // MaxExperiencePoints: The maximum experience points for this level. 453 MaxExperiencePoints int64 `json:"maxExperiencePoints,omitempty,string"` 454 455 // MinExperiencePoints: The minimum experience points for this level. 456 MinExperiencePoints int64 `json:"minExperiencePoints,omitempty,string"` 457 458 // ForceSendFields is a list of field names (e.g. "Level") to 459 // unconditionally include in API requests. By default, fields with 460 // empty values are omitted from API requests. However, any non-pointer, 461 // non-interface field appearing in ForceSendFields will be sent to the 462 // server regardless of whether the field is empty or not. This may be 463 // used to include empty fields in Patch requests. 464 ForceSendFields []string `json:"-"` 465 466 // NullFields is a list of field names (e.g. "Level") to include in API 467 // requests with the JSON null value. By default, fields with empty 468 // values are omitted from API requests. However, any field with an 469 // empty value appearing in NullFields will be sent to the server as 470 // null. It is an error if a field in this list has a non-empty value. 471 // This may be used to include null fields in Patch requests. 472 NullFields []string `json:"-"` 473} 474 475func (s *GamesPlayerLevelResource) MarshalJSON() ([]byte, error) { 476 type NoMethod GamesPlayerLevelResource 477 raw := NoMethod(*s) 478 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 479} 480 481// HiddenPlayer: This is a JSON template for the HiddenPlayer resource. 482type HiddenPlayer struct { 483 // HiddenTimeMillis: The time this player was hidden. 484 HiddenTimeMillis int64 `json:"hiddenTimeMillis,omitempty,string"` 485 486 // Kind: Uniquely identifies the type of this resource. Value is always 487 // the fixed string gamesManagement#hiddenPlayer. 488 Kind string `json:"kind,omitempty"` 489 490 // Player: The player information. 491 Player *Player `json:"player,omitempty"` 492 493 // ForceSendFields is a list of field names (e.g. "HiddenTimeMillis") to 494 // unconditionally include in API requests. By default, fields with 495 // empty values are omitted from API requests. However, any non-pointer, 496 // non-interface field appearing in ForceSendFields will be sent to the 497 // server regardless of whether the field is empty or not. This may be 498 // used to include empty fields in Patch requests. 499 ForceSendFields []string `json:"-"` 500 501 // NullFields is a list of field names (e.g. "HiddenTimeMillis") to 502 // include in API requests with the JSON null value. By default, fields 503 // with empty values are omitted from API requests. However, any field 504 // with an empty value appearing in NullFields will be sent to the 505 // server as null. It is an error if a field in this list has a 506 // non-empty value. This may be used to include null fields in Patch 507 // requests. 508 NullFields []string `json:"-"` 509} 510 511func (s *HiddenPlayer) MarshalJSON() ([]byte, error) { 512 type NoMethod HiddenPlayer 513 raw := NoMethod(*s) 514 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 515} 516 517// HiddenPlayerList: This is a JSON template for a list of hidden 518// players. 519type HiddenPlayerList struct { 520 // Items: The players. 521 Items []*HiddenPlayer `json:"items,omitempty"` 522 523 // Kind: Uniquely identifies the type of this resource. Value is always 524 // the fixed string gamesManagement#hiddenPlayerList. 525 Kind string `json:"kind,omitempty"` 526 527 // NextPageToken: The pagination token for the next page of results. 528 NextPageToken string `json:"nextPageToken,omitempty"` 529 530 // ServerResponse contains the HTTP response code and headers from the 531 // server. 532 googleapi.ServerResponse `json:"-"` 533 534 // ForceSendFields is a list of field names (e.g. "Items") to 535 // unconditionally include in API requests. By default, fields with 536 // empty values are omitted from API requests. However, any non-pointer, 537 // non-interface field appearing in ForceSendFields will be sent to the 538 // server regardless of whether the field is empty or not. This may be 539 // used to include empty fields in Patch requests. 540 ForceSendFields []string `json:"-"` 541 542 // NullFields is a list of field names (e.g. "Items") to include in API 543 // requests with the JSON null value. By default, fields with empty 544 // values are omitted from API requests. However, any field with an 545 // empty value appearing in NullFields will be sent to the server as 546 // null. It is an error if a field in this list has a non-empty value. 547 // This may be used to include null fields in Patch requests. 548 NullFields []string `json:"-"` 549} 550 551func (s *HiddenPlayerList) MarshalJSON() ([]byte, error) { 552 type NoMethod HiddenPlayerList 553 raw := NoMethod(*s) 554 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 555} 556 557// Player: This is a JSON template for a Player resource. 558type Player struct { 559 // AvatarImageUrl: The base URL for the image that represents the 560 // player. 561 AvatarImageUrl string `json:"avatarImageUrl,omitempty"` 562 563 // BannerUrlLandscape: The url to the landscape mode player banner 564 // image. 565 BannerUrlLandscape string `json:"bannerUrlLandscape,omitempty"` 566 567 // BannerUrlPortrait: The url to the portrait mode player banner image. 568 BannerUrlPortrait string `json:"bannerUrlPortrait,omitempty"` 569 570 // DisplayName: The name to display for the player. 571 DisplayName string `json:"displayName,omitempty"` 572 573 // ExperienceInfo: An object to represent Play Game experience 574 // information for the player. 575 ExperienceInfo *GamesPlayerExperienceInfoResource `json:"experienceInfo,omitempty"` 576 577 // Kind: Uniquely identifies the type of this resource. Value is always 578 // the fixed string gamesManagement#player. 579 Kind string `json:"kind,omitempty"` 580 581 // LastPlayedWith: Details about the last time this player played a 582 // multiplayer game with the currently authenticated player. Populated 583 // for PLAYED_WITH player collection members. 584 LastPlayedWith *GamesPlayedResource `json:"lastPlayedWith,omitempty"` 585 586 // Name: An object representation of the individual components of the 587 // player's name. For some players, these fields may not be present. 588 Name *PlayerName `json:"name,omitempty"` 589 590 // OriginalPlayerId: The player ID that was used for this player the 591 // first time they signed into the game in question. This is only 592 // populated for calls to player.get for the requesting player, only if 593 // the player ID has subsequently changed, and only to clients that 594 // support remapping player IDs. 595 OriginalPlayerId string `json:"originalPlayerId,omitempty"` 596 597 // PlayerId: The ID of the player. 598 PlayerId string `json:"playerId,omitempty"` 599 600 PlayerStattus string `json:"playerStattus,omitempty"` 601 602 // ProfileSettings: The player's profile settings. Controls whether or 603 // not the player's profile is visible to other players. 604 ProfileSettings *ProfileSettings `json:"profileSettings,omitempty"` 605 606 // Title: The player's title rewarded for their game activities. 607 Title string `json:"title,omitempty"` 608 609 // ForceSendFields is a list of field names (e.g. "AvatarImageUrl") to 610 // unconditionally include in API requests. By default, fields with 611 // empty values are omitted from API requests. However, any non-pointer, 612 // non-interface field appearing in ForceSendFields will be sent to the 613 // server regardless of whether the field is empty or not. This may be 614 // used to include empty fields in Patch requests. 615 ForceSendFields []string `json:"-"` 616 617 // NullFields is a list of field names (e.g. "AvatarImageUrl") to 618 // include in API requests with the JSON null value. By default, fields 619 // with empty values are omitted from API requests. However, any field 620 // with an empty value appearing in NullFields will be sent to the 621 // server as null. It is an error if a field in this list has a 622 // non-empty value. This may be used to include null fields in Patch 623 // requests. 624 NullFields []string `json:"-"` 625} 626 627func (s *Player) MarshalJSON() ([]byte, error) { 628 type NoMethod Player 629 raw := NoMethod(*s) 630 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 631} 632 633// PlayerName: An object representation of the individual components of 634// the player's name. For some players, these fields may not be present. 635type PlayerName struct { 636 // FamilyName: The family name of this player. In some places, this is 637 // known as the last name. 638 FamilyName string `json:"familyName,omitempty"` 639 640 // GivenName: The given name of this player. In some places, this is 641 // known as the first name. 642 GivenName string `json:"givenName,omitempty"` 643 644 // ForceSendFields is a list of field names (e.g. "FamilyName") to 645 // unconditionally include in API requests. By default, fields with 646 // empty values are omitted from API requests. However, any non-pointer, 647 // non-interface field appearing in ForceSendFields will be sent to the 648 // server regardless of whether the field is empty or not. This may be 649 // used to include empty fields in Patch requests. 650 ForceSendFields []string `json:"-"` 651 652 // NullFields is a list of field names (e.g. "FamilyName") to include in 653 // API requests with the JSON null value. By default, fields with empty 654 // values are omitted from API requests. However, any field with an 655 // empty value appearing in NullFields will be sent to the server as 656 // null. It is an error if a field in this list has a non-empty value. 657 // This may be used to include null fields in Patch requests. 658 NullFields []string `json:"-"` 659} 660 661func (s *PlayerName) MarshalJSON() ([]byte, error) { 662 type NoMethod PlayerName 663 raw := NoMethod(*s) 664 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 665} 666 667// PlayerScoreResetAllResponse: This is a JSON template for a list of 668// leaderboard reset resources. 669type PlayerScoreResetAllResponse struct { 670 // Kind: Uniquely identifies the type of this resource. Value is always 671 // the fixed string gamesManagement#playerScoreResetResponse. 672 Kind string `json:"kind,omitempty"` 673 674 // Results: The leaderboard reset results. 675 Results []*PlayerScoreResetResponse `json:"results,omitempty"` 676 677 // ServerResponse contains the HTTP response code and headers from the 678 // server. 679 googleapi.ServerResponse `json:"-"` 680 681 // ForceSendFields is a list of field names (e.g. "Kind") to 682 // unconditionally include in API requests. By default, fields with 683 // empty values are omitted from API requests. However, any non-pointer, 684 // non-interface field appearing in ForceSendFields will be sent to the 685 // server regardless of whether the field is empty or not. This may be 686 // used to include empty fields in Patch requests. 687 ForceSendFields []string `json:"-"` 688 689 // NullFields is a list of field names (e.g. "Kind") to include in API 690 // requests with the JSON null value. By default, fields with empty 691 // values are omitted from API requests. However, any field with an 692 // empty value appearing in NullFields will be sent to the server as 693 // null. It is an error if a field in this list has a non-empty value. 694 // This may be used to include null fields in Patch requests. 695 NullFields []string `json:"-"` 696} 697 698func (s *PlayerScoreResetAllResponse) MarshalJSON() ([]byte, error) { 699 type NoMethod PlayerScoreResetAllResponse 700 raw := NoMethod(*s) 701 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 702} 703 704// PlayerScoreResetResponse: This is a JSON template for a list of reset 705// leaderboard entry resources. 706type PlayerScoreResetResponse struct { 707 // DefinitionId: The ID of an leaderboard for which player state has 708 // been updated. 709 DefinitionId string `json:"definitionId,omitempty"` 710 711 // Kind: Uniquely identifies the type of this resource. Value is always 712 // the fixed string gamesManagement#playerScoreResetResponse. 713 Kind string `json:"kind,omitempty"` 714 715 // ResetScoreTimeSpans: The time spans of the updated score. 716 // Possible values are: 717 // - "ALL_TIME" - The score is an all-time score. 718 // - "WEEKLY" - The score is a weekly score. 719 // - "DAILY" - The score is a daily score. 720 ResetScoreTimeSpans []string `json:"resetScoreTimeSpans,omitempty"` 721 722 // ServerResponse contains the HTTP response code and headers from the 723 // server. 724 googleapi.ServerResponse `json:"-"` 725 726 // ForceSendFields is a list of field names (e.g. "DefinitionId") to 727 // unconditionally include in API requests. By default, fields with 728 // empty values are omitted from API requests. However, any non-pointer, 729 // non-interface field appearing in ForceSendFields will be sent to the 730 // server regardless of whether the field is empty or not. This may be 731 // used to include empty fields in Patch requests. 732 ForceSendFields []string `json:"-"` 733 734 // NullFields is a list of field names (e.g. "DefinitionId") to include 735 // in API requests with the JSON null value. By default, fields with 736 // empty values are omitted from API requests. However, any field with 737 // an empty value appearing in NullFields will be sent to the server as 738 // null. It is an error if a field in this list has a non-empty value. 739 // This may be used to include null fields in Patch requests. 740 NullFields []string `json:"-"` 741} 742 743func (s *PlayerScoreResetResponse) MarshalJSON() ([]byte, error) { 744 type NoMethod PlayerScoreResetResponse 745 raw := NoMethod(*s) 746 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 747} 748 749// ProfileSettings: This is a JSON template for profile settings 750type ProfileSettings struct { 751 // Kind: Uniquely identifies the type of this resource. Value is always 752 // the fixed string gamesManagement#profileSettings. 753 Kind string `json:"kind,omitempty"` 754 755 ProfileVisible bool `json:"profileVisible,omitempty"` 756 757 // ForceSendFields is a list of field names (e.g. "Kind") to 758 // unconditionally include in API requests. By default, fields with 759 // empty values are omitted from API requests. However, any non-pointer, 760 // non-interface field appearing in ForceSendFields will be sent to the 761 // server regardless of whether the field is empty or not. This may be 762 // used to include empty fields in Patch requests. 763 ForceSendFields []string `json:"-"` 764 765 // NullFields is a list of field names (e.g. "Kind") to include in API 766 // requests with the JSON null value. By default, fields with empty 767 // values are omitted from API requests. However, any field with an 768 // empty value appearing in NullFields will be sent to the server as 769 // null. It is an error if a field in this list has a non-empty value. 770 // This may be used to include null fields in Patch requests. 771 NullFields []string `json:"-"` 772} 773 774func (s *ProfileSettings) MarshalJSON() ([]byte, error) { 775 type NoMethod ProfileSettings 776 raw := NoMethod(*s) 777 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 778} 779 780// ScoresResetMultipleForAllRequest: This is a JSON template for 781// multiple scores reset all request. 782type ScoresResetMultipleForAllRequest struct { 783 // Kind: Uniquely identifies the type of this resource. Value is always 784 // the fixed string gamesManagement#scoresResetMultipleForAllRequest. 785 Kind string `json:"kind,omitempty"` 786 787 // LeaderboardIds: The IDs of leaderboards to reset. 788 LeaderboardIds []string `json:"leaderboard_ids,omitempty"` 789 790 // ForceSendFields is a list of field names (e.g. "Kind") to 791 // unconditionally include in API requests. By default, fields with 792 // empty values are omitted from API requests. However, any non-pointer, 793 // non-interface field appearing in ForceSendFields will be sent to the 794 // server regardless of whether the field is empty or not. This may be 795 // used to include empty fields in Patch requests. 796 ForceSendFields []string `json:"-"` 797 798 // NullFields is a list of field names (e.g. "Kind") to include in API 799 // requests with the JSON null value. By default, fields with empty 800 // values are omitted from API requests. However, any field with an 801 // empty value appearing in NullFields will be sent to the server as 802 // null. It is an error if a field in this list has a non-empty value. 803 // This may be used to include null fields in Patch requests. 804 NullFields []string `json:"-"` 805} 806 807func (s *ScoresResetMultipleForAllRequest) MarshalJSON() ([]byte, error) { 808 type NoMethod ScoresResetMultipleForAllRequest 809 raw := NoMethod(*s) 810 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) 811} 812 813// method id "gamesManagement.achievements.reset": 814 815type AchievementsResetCall struct { 816 s *Service 817 achievementId string 818 urlParams_ gensupport.URLParams 819 ctx_ context.Context 820 header_ http.Header 821} 822 823// Reset: Resets the achievement with the given ID for the currently 824// authenticated player. This method is only accessible to whitelisted 825// tester accounts for your application. 826func (r *AchievementsService) Reset(achievementId string) *AchievementsResetCall { 827 c := &AchievementsResetCall{s: r.s, urlParams_: make(gensupport.URLParams)} 828 c.achievementId = achievementId 829 return c 830} 831 832// Fields allows partial responses to be retrieved. See 833// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 834// for more information. 835func (c *AchievementsResetCall) Fields(s ...googleapi.Field) *AchievementsResetCall { 836 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 837 return c 838} 839 840// Context sets the context to be used in this call's Do method. Any 841// pending HTTP request will be aborted if the provided context is 842// canceled. 843func (c *AchievementsResetCall) Context(ctx context.Context) *AchievementsResetCall { 844 c.ctx_ = ctx 845 return c 846} 847 848// Header returns an http.Header that can be modified by the caller to 849// add HTTP headers to the request. 850func (c *AchievementsResetCall) Header() http.Header { 851 if c.header_ == nil { 852 c.header_ = make(http.Header) 853 } 854 return c.header_ 855} 856 857func (c *AchievementsResetCall) doRequest(alt string) (*http.Response, error) { 858 reqHeaders := make(http.Header) 859 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 860 for k, v := range c.header_ { 861 reqHeaders[k] = v 862 } 863 reqHeaders.Set("User-Agent", c.s.userAgent()) 864 var body io.Reader = nil 865 c.urlParams_.Set("alt", alt) 866 c.urlParams_.Set("prettyPrint", "false") 867 urls := googleapi.ResolveRelative(c.s.BasePath, "achievements/{achievementId}/reset") 868 urls += "?" + c.urlParams_.Encode() 869 req, err := http.NewRequest("POST", urls, body) 870 if err != nil { 871 return nil, err 872 } 873 req.Header = reqHeaders 874 googleapi.Expand(req.URL, map[string]string{ 875 "achievementId": c.achievementId, 876 }) 877 return gensupport.SendRequest(c.ctx_, c.s.client, req) 878} 879 880// Do executes the "gamesManagement.achievements.reset" call. 881// Exactly one of *AchievementResetResponse or error will be non-nil. 882// Any non-2xx status code is an error. Response headers are in either 883// *AchievementResetResponse.ServerResponse.Header or (if a response was 884// returned at all) in error.(*googleapi.Error).Header. Use 885// googleapi.IsNotModified to check whether the returned error was 886// because http.StatusNotModified was returned. 887func (c *AchievementsResetCall) Do(opts ...googleapi.CallOption) (*AchievementResetResponse, error) { 888 gensupport.SetOptions(c.urlParams_, opts...) 889 res, err := c.doRequest("json") 890 if res != nil && res.StatusCode == http.StatusNotModified { 891 if res.Body != nil { 892 res.Body.Close() 893 } 894 return nil, &googleapi.Error{ 895 Code: res.StatusCode, 896 Header: res.Header, 897 } 898 } 899 if err != nil { 900 return nil, err 901 } 902 defer googleapi.CloseBody(res) 903 if err := googleapi.CheckResponse(res); err != nil { 904 return nil, err 905 } 906 ret := &AchievementResetResponse{ 907 ServerResponse: googleapi.ServerResponse{ 908 Header: res.Header, 909 HTTPStatusCode: res.StatusCode, 910 }, 911 } 912 target := &ret 913 if err := gensupport.DecodeResponse(target, res); err != nil { 914 return nil, err 915 } 916 return ret, nil 917 // { 918 // "description": "Resets the achievement with the given ID for the currently authenticated player. This method is only accessible to whitelisted tester accounts for your application.", 919 // "httpMethod": "POST", 920 // "id": "gamesManagement.achievements.reset", 921 // "parameterOrder": [ 922 // "achievementId" 923 // ], 924 // "parameters": { 925 // "achievementId": { 926 // "description": "The ID of the achievement used by this method.", 927 // "location": "path", 928 // "required": true, 929 // "type": "string" 930 // } 931 // }, 932 // "path": "achievements/{achievementId}/reset", 933 // "response": { 934 // "$ref": "AchievementResetResponse" 935 // }, 936 // "scopes": [ 937 // "https://www.googleapis.com/auth/games" 938 // ] 939 // } 940 941} 942 943// method id "gamesManagement.achievements.resetAll": 944 945type AchievementsResetAllCall struct { 946 s *Service 947 urlParams_ gensupport.URLParams 948 ctx_ context.Context 949 header_ http.Header 950} 951 952// ResetAll: Resets all achievements for the currently authenticated 953// player for your application. This method is only accessible to 954// whitelisted tester accounts for your application. 955func (r *AchievementsService) ResetAll() *AchievementsResetAllCall { 956 c := &AchievementsResetAllCall{s: r.s, urlParams_: make(gensupport.URLParams)} 957 return c 958} 959 960// Fields allows partial responses to be retrieved. See 961// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 962// for more information. 963func (c *AchievementsResetAllCall) Fields(s ...googleapi.Field) *AchievementsResetAllCall { 964 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 965 return c 966} 967 968// Context sets the context to be used in this call's Do method. Any 969// pending HTTP request will be aborted if the provided context is 970// canceled. 971func (c *AchievementsResetAllCall) Context(ctx context.Context) *AchievementsResetAllCall { 972 c.ctx_ = ctx 973 return c 974} 975 976// Header returns an http.Header that can be modified by the caller to 977// add HTTP headers to the request. 978func (c *AchievementsResetAllCall) Header() http.Header { 979 if c.header_ == nil { 980 c.header_ = make(http.Header) 981 } 982 return c.header_ 983} 984 985func (c *AchievementsResetAllCall) doRequest(alt string) (*http.Response, error) { 986 reqHeaders := make(http.Header) 987 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 988 for k, v := range c.header_ { 989 reqHeaders[k] = v 990 } 991 reqHeaders.Set("User-Agent", c.s.userAgent()) 992 var body io.Reader = nil 993 c.urlParams_.Set("alt", alt) 994 c.urlParams_.Set("prettyPrint", "false") 995 urls := googleapi.ResolveRelative(c.s.BasePath, "achievements/reset") 996 urls += "?" + c.urlParams_.Encode() 997 req, err := http.NewRequest("POST", urls, body) 998 if err != nil { 999 return nil, err 1000 } 1001 req.Header = reqHeaders 1002 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1003} 1004 1005// Do executes the "gamesManagement.achievements.resetAll" call. 1006// Exactly one of *AchievementResetAllResponse or error will be non-nil. 1007// Any non-2xx status code is an error. Response headers are in either 1008// *AchievementResetAllResponse.ServerResponse.Header or (if a response 1009// was returned at all) in error.(*googleapi.Error).Header. Use 1010// googleapi.IsNotModified to check whether the returned error was 1011// because http.StatusNotModified was returned. 1012func (c *AchievementsResetAllCall) Do(opts ...googleapi.CallOption) (*AchievementResetAllResponse, error) { 1013 gensupport.SetOptions(c.urlParams_, opts...) 1014 res, err := c.doRequest("json") 1015 if res != nil && res.StatusCode == http.StatusNotModified { 1016 if res.Body != nil { 1017 res.Body.Close() 1018 } 1019 return nil, &googleapi.Error{ 1020 Code: res.StatusCode, 1021 Header: res.Header, 1022 } 1023 } 1024 if err != nil { 1025 return nil, err 1026 } 1027 defer googleapi.CloseBody(res) 1028 if err := googleapi.CheckResponse(res); err != nil { 1029 return nil, err 1030 } 1031 ret := &AchievementResetAllResponse{ 1032 ServerResponse: googleapi.ServerResponse{ 1033 Header: res.Header, 1034 HTTPStatusCode: res.StatusCode, 1035 }, 1036 } 1037 target := &ret 1038 if err := gensupport.DecodeResponse(target, res); err != nil { 1039 return nil, err 1040 } 1041 return ret, nil 1042 // { 1043 // "description": "Resets all achievements for the currently authenticated player for your application. This method is only accessible to whitelisted tester accounts for your application.", 1044 // "httpMethod": "POST", 1045 // "id": "gamesManagement.achievements.resetAll", 1046 // "path": "achievements/reset", 1047 // "response": { 1048 // "$ref": "AchievementResetAllResponse" 1049 // }, 1050 // "scopes": [ 1051 // "https://www.googleapis.com/auth/games" 1052 // ] 1053 // } 1054 1055} 1056 1057// method id "gamesManagement.achievements.resetAllForAllPlayers": 1058 1059type AchievementsResetAllForAllPlayersCall struct { 1060 s *Service 1061 urlParams_ gensupport.URLParams 1062 ctx_ context.Context 1063 header_ http.Header 1064} 1065 1066// ResetAllForAllPlayers: Resets all draft achievements for all players. 1067// This method is only available to user accounts for your developer 1068// console. 1069func (r *AchievementsService) ResetAllForAllPlayers() *AchievementsResetAllForAllPlayersCall { 1070 c := &AchievementsResetAllForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1071 return c 1072} 1073 1074// Fields allows partial responses to be retrieved. See 1075// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1076// for more information. 1077func (c *AchievementsResetAllForAllPlayersCall) Fields(s ...googleapi.Field) *AchievementsResetAllForAllPlayersCall { 1078 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1079 return c 1080} 1081 1082// Context sets the context to be used in this call's Do method. Any 1083// pending HTTP request will be aborted if the provided context is 1084// canceled. 1085func (c *AchievementsResetAllForAllPlayersCall) Context(ctx context.Context) *AchievementsResetAllForAllPlayersCall { 1086 c.ctx_ = ctx 1087 return c 1088} 1089 1090// Header returns an http.Header that can be modified by the caller to 1091// add HTTP headers to the request. 1092func (c *AchievementsResetAllForAllPlayersCall) Header() http.Header { 1093 if c.header_ == nil { 1094 c.header_ = make(http.Header) 1095 } 1096 return c.header_ 1097} 1098 1099func (c *AchievementsResetAllForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 1100 reqHeaders := make(http.Header) 1101 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 1102 for k, v := range c.header_ { 1103 reqHeaders[k] = v 1104 } 1105 reqHeaders.Set("User-Agent", c.s.userAgent()) 1106 var body io.Reader = nil 1107 c.urlParams_.Set("alt", alt) 1108 c.urlParams_.Set("prettyPrint", "false") 1109 urls := googleapi.ResolveRelative(c.s.BasePath, "achievements/resetAllForAllPlayers") 1110 urls += "?" + c.urlParams_.Encode() 1111 req, err := http.NewRequest("POST", urls, body) 1112 if err != nil { 1113 return nil, err 1114 } 1115 req.Header = reqHeaders 1116 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1117} 1118 1119// Do executes the "gamesManagement.achievements.resetAllForAllPlayers" call. 1120func (c *AchievementsResetAllForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 1121 gensupport.SetOptions(c.urlParams_, opts...) 1122 res, err := c.doRequest("json") 1123 if err != nil { 1124 return err 1125 } 1126 defer googleapi.CloseBody(res) 1127 if err := googleapi.CheckResponse(res); err != nil { 1128 return err 1129 } 1130 return nil 1131 // { 1132 // "description": "Resets all draft achievements for all players. This method is only available to user accounts for your developer console.", 1133 // "httpMethod": "POST", 1134 // "id": "gamesManagement.achievements.resetAllForAllPlayers", 1135 // "path": "achievements/resetAllForAllPlayers", 1136 // "scopes": [ 1137 // "https://www.googleapis.com/auth/games" 1138 // ] 1139 // } 1140 1141} 1142 1143// method id "gamesManagement.achievements.resetForAllPlayers": 1144 1145type AchievementsResetForAllPlayersCall struct { 1146 s *Service 1147 achievementId string 1148 urlParams_ gensupport.URLParams 1149 ctx_ context.Context 1150 header_ http.Header 1151} 1152 1153// ResetForAllPlayers: Resets the achievement with the given ID for all 1154// players. This method is only available to user accounts for your 1155// developer console. Only draft achievements can be reset. 1156func (r *AchievementsService) ResetForAllPlayers(achievementId string) *AchievementsResetForAllPlayersCall { 1157 c := &AchievementsResetForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1158 c.achievementId = achievementId 1159 return c 1160} 1161 1162// Fields allows partial responses to be retrieved. See 1163// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1164// for more information. 1165func (c *AchievementsResetForAllPlayersCall) Fields(s ...googleapi.Field) *AchievementsResetForAllPlayersCall { 1166 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1167 return c 1168} 1169 1170// Context sets the context to be used in this call's Do method. Any 1171// pending HTTP request will be aborted if the provided context is 1172// canceled. 1173func (c *AchievementsResetForAllPlayersCall) Context(ctx context.Context) *AchievementsResetForAllPlayersCall { 1174 c.ctx_ = ctx 1175 return c 1176} 1177 1178// Header returns an http.Header that can be modified by the caller to 1179// add HTTP headers to the request. 1180func (c *AchievementsResetForAllPlayersCall) Header() http.Header { 1181 if c.header_ == nil { 1182 c.header_ = make(http.Header) 1183 } 1184 return c.header_ 1185} 1186 1187func (c *AchievementsResetForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 1188 reqHeaders := make(http.Header) 1189 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 1190 for k, v := range c.header_ { 1191 reqHeaders[k] = v 1192 } 1193 reqHeaders.Set("User-Agent", c.s.userAgent()) 1194 var body io.Reader = nil 1195 c.urlParams_.Set("alt", alt) 1196 c.urlParams_.Set("prettyPrint", "false") 1197 urls := googleapi.ResolveRelative(c.s.BasePath, "achievements/{achievementId}/resetForAllPlayers") 1198 urls += "?" + c.urlParams_.Encode() 1199 req, err := http.NewRequest("POST", urls, body) 1200 if err != nil { 1201 return nil, err 1202 } 1203 req.Header = reqHeaders 1204 googleapi.Expand(req.URL, map[string]string{ 1205 "achievementId": c.achievementId, 1206 }) 1207 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1208} 1209 1210// Do executes the "gamesManagement.achievements.resetForAllPlayers" call. 1211func (c *AchievementsResetForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 1212 gensupport.SetOptions(c.urlParams_, opts...) 1213 res, err := c.doRequest("json") 1214 if err != nil { 1215 return err 1216 } 1217 defer googleapi.CloseBody(res) 1218 if err := googleapi.CheckResponse(res); err != nil { 1219 return err 1220 } 1221 return nil 1222 // { 1223 // "description": "Resets the achievement with the given ID for all players. This method is only available to user accounts for your developer console. Only draft achievements can be reset.", 1224 // "httpMethod": "POST", 1225 // "id": "gamesManagement.achievements.resetForAllPlayers", 1226 // "parameterOrder": [ 1227 // "achievementId" 1228 // ], 1229 // "parameters": { 1230 // "achievementId": { 1231 // "description": "The ID of the achievement used by this method.", 1232 // "location": "path", 1233 // "required": true, 1234 // "type": "string" 1235 // } 1236 // }, 1237 // "path": "achievements/{achievementId}/resetForAllPlayers", 1238 // "scopes": [ 1239 // "https://www.googleapis.com/auth/games" 1240 // ] 1241 // } 1242 1243} 1244 1245// method id "gamesManagement.achievements.resetMultipleForAllPlayers": 1246 1247type AchievementsResetMultipleForAllPlayersCall struct { 1248 s *Service 1249 achievementresetmultipleforallrequest *AchievementResetMultipleForAllRequest 1250 urlParams_ gensupport.URLParams 1251 ctx_ context.Context 1252 header_ http.Header 1253} 1254 1255// ResetMultipleForAllPlayers: Resets achievements with the given IDs 1256// for all players. This method is only available to user accounts for 1257// your developer console. Only draft achievements may be reset. 1258func (r *AchievementsService) ResetMultipleForAllPlayers(achievementresetmultipleforallrequest *AchievementResetMultipleForAllRequest) *AchievementsResetMultipleForAllPlayersCall { 1259 c := &AchievementsResetMultipleForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1260 c.achievementresetmultipleforallrequest = achievementresetmultipleforallrequest 1261 return c 1262} 1263 1264// Fields allows partial responses to be retrieved. See 1265// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1266// for more information. 1267func (c *AchievementsResetMultipleForAllPlayersCall) Fields(s ...googleapi.Field) *AchievementsResetMultipleForAllPlayersCall { 1268 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1269 return c 1270} 1271 1272// Context sets the context to be used in this call's Do method. Any 1273// pending HTTP request will be aborted if the provided context is 1274// canceled. 1275func (c *AchievementsResetMultipleForAllPlayersCall) Context(ctx context.Context) *AchievementsResetMultipleForAllPlayersCall { 1276 c.ctx_ = ctx 1277 return c 1278} 1279 1280// Header returns an http.Header that can be modified by the caller to 1281// add HTTP headers to the request. 1282func (c *AchievementsResetMultipleForAllPlayersCall) Header() http.Header { 1283 if c.header_ == nil { 1284 c.header_ = make(http.Header) 1285 } 1286 return c.header_ 1287} 1288 1289func (c *AchievementsResetMultipleForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 1290 reqHeaders := make(http.Header) 1291 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 1292 for k, v := range c.header_ { 1293 reqHeaders[k] = v 1294 } 1295 reqHeaders.Set("User-Agent", c.s.userAgent()) 1296 var body io.Reader = nil 1297 body, err := googleapi.WithoutDataWrapper.JSONReader(c.achievementresetmultipleforallrequest) 1298 if err != nil { 1299 return nil, err 1300 } 1301 reqHeaders.Set("Content-Type", "application/json") 1302 c.urlParams_.Set("alt", alt) 1303 c.urlParams_.Set("prettyPrint", "false") 1304 urls := googleapi.ResolveRelative(c.s.BasePath, "achievements/resetMultipleForAllPlayers") 1305 urls += "?" + c.urlParams_.Encode() 1306 req, err := http.NewRequest("POST", urls, body) 1307 if err != nil { 1308 return nil, err 1309 } 1310 req.Header = reqHeaders 1311 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1312} 1313 1314// Do executes the "gamesManagement.achievements.resetMultipleForAllPlayers" call. 1315func (c *AchievementsResetMultipleForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 1316 gensupport.SetOptions(c.urlParams_, opts...) 1317 res, err := c.doRequest("json") 1318 if err != nil { 1319 return err 1320 } 1321 defer googleapi.CloseBody(res) 1322 if err := googleapi.CheckResponse(res); err != nil { 1323 return err 1324 } 1325 return nil 1326 // { 1327 // "description": "Resets achievements with the given IDs for all players. This method is only available to user accounts for your developer console. Only draft achievements may be reset.", 1328 // "httpMethod": "POST", 1329 // "id": "gamesManagement.achievements.resetMultipleForAllPlayers", 1330 // "path": "achievements/resetMultipleForAllPlayers", 1331 // "request": { 1332 // "$ref": "AchievementResetMultipleForAllRequest" 1333 // }, 1334 // "scopes": [ 1335 // "https://www.googleapis.com/auth/games" 1336 // ] 1337 // } 1338 1339} 1340 1341// method id "gamesManagement.applications.listHidden": 1342 1343type ApplicationsListHiddenCall struct { 1344 s *Service 1345 applicationId string 1346 urlParams_ gensupport.URLParams 1347 ifNoneMatch_ string 1348 ctx_ context.Context 1349 header_ http.Header 1350} 1351 1352// ListHidden: Get the list of players hidden from the given 1353// application. This method is only available to user accounts for your 1354// developer console. 1355func (r *ApplicationsService) ListHidden(applicationId string) *ApplicationsListHiddenCall { 1356 c := &ApplicationsListHiddenCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1357 c.applicationId = applicationId 1358 return c 1359} 1360 1361// MaxResults sets the optional parameter "maxResults": The maximum 1362// number of player resources to return in the response, used for 1363// paging. For any response, the actual number of player resources 1364// returned may be less than the specified maxResults. 1365func (c *ApplicationsListHiddenCall) MaxResults(maxResults int64) *ApplicationsListHiddenCall { 1366 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) 1367 return c 1368} 1369 1370// PageToken sets the optional parameter "pageToken": The token returned 1371// by the previous request. 1372func (c *ApplicationsListHiddenCall) PageToken(pageToken string) *ApplicationsListHiddenCall { 1373 c.urlParams_.Set("pageToken", pageToken) 1374 return c 1375} 1376 1377// Fields allows partial responses to be retrieved. See 1378// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1379// for more information. 1380func (c *ApplicationsListHiddenCall) Fields(s ...googleapi.Field) *ApplicationsListHiddenCall { 1381 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1382 return c 1383} 1384 1385// IfNoneMatch sets the optional parameter which makes the operation 1386// fail if the object's ETag matches the given value. This is useful for 1387// getting updates only after the object has changed since the last 1388// request. Use googleapi.IsNotModified to check whether the response 1389// error from Do is the result of In-None-Match. 1390func (c *ApplicationsListHiddenCall) IfNoneMatch(entityTag string) *ApplicationsListHiddenCall { 1391 c.ifNoneMatch_ = entityTag 1392 return c 1393} 1394 1395// Context sets the context to be used in this call's Do method. Any 1396// pending HTTP request will be aborted if the provided context is 1397// canceled. 1398func (c *ApplicationsListHiddenCall) Context(ctx context.Context) *ApplicationsListHiddenCall { 1399 c.ctx_ = ctx 1400 return c 1401} 1402 1403// Header returns an http.Header that can be modified by the caller to 1404// add HTTP headers to the request. 1405func (c *ApplicationsListHiddenCall) Header() http.Header { 1406 if c.header_ == nil { 1407 c.header_ = make(http.Header) 1408 } 1409 return c.header_ 1410} 1411 1412func (c *ApplicationsListHiddenCall) doRequest(alt string) (*http.Response, error) { 1413 reqHeaders := make(http.Header) 1414 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 1415 for k, v := range c.header_ { 1416 reqHeaders[k] = v 1417 } 1418 reqHeaders.Set("User-Agent", c.s.userAgent()) 1419 if c.ifNoneMatch_ != "" { 1420 reqHeaders.Set("If-None-Match", c.ifNoneMatch_) 1421 } 1422 var body io.Reader = nil 1423 c.urlParams_.Set("alt", alt) 1424 c.urlParams_.Set("prettyPrint", "false") 1425 urls := googleapi.ResolveRelative(c.s.BasePath, "applications/{applicationId}/players/hidden") 1426 urls += "?" + c.urlParams_.Encode() 1427 req, err := http.NewRequest("GET", urls, body) 1428 if err != nil { 1429 return nil, err 1430 } 1431 req.Header = reqHeaders 1432 googleapi.Expand(req.URL, map[string]string{ 1433 "applicationId": c.applicationId, 1434 }) 1435 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1436} 1437 1438// Do executes the "gamesManagement.applications.listHidden" call. 1439// Exactly one of *HiddenPlayerList or error will be non-nil. Any 1440// non-2xx status code is an error. Response headers are in either 1441// *HiddenPlayerList.ServerResponse.Header or (if a response was 1442// returned at all) in error.(*googleapi.Error).Header. Use 1443// googleapi.IsNotModified to check whether the returned error was 1444// because http.StatusNotModified was returned. 1445func (c *ApplicationsListHiddenCall) Do(opts ...googleapi.CallOption) (*HiddenPlayerList, error) { 1446 gensupport.SetOptions(c.urlParams_, opts...) 1447 res, err := c.doRequest("json") 1448 if res != nil && res.StatusCode == http.StatusNotModified { 1449 if res.Body != nil { 1450 res.Body.Close() 1451 } 1452 return nil, &googleapi.Error{ 1453 Code: res.StatusCode, 1454 Header: res.Header, 1455 } 1456 } 1457 if err != nil { 1458 return nil, err 1459 } 1460 defer googleapi.CloseBody(res) 1461 if err := googleapi.CheckResponse(res); err != nil { 1462 return nil, err 1463 } 1464 ret := &HiddenPlayerList{ 1465 ServerResponse: googleapi.ServerResponse{ 1466 Header: res.Header, 1467 HTTPStatusCode: res.StatusCode, 1468 }, 1469 } 1470 target := &ret 1471 if err := gensupport.DecodeResponse(target, res); err != nil { 1472 return nil, err 1473 } 1474 return ret, nil 1475 // { 1476 // "description": "Get the list of players hidden from the given application. This method is only available to user accounts for your developer console.", 1477 // "httpMethod": "GET", 1478 // "id": "gamesManagement.applications.listHidden", 1479 // "parameterOrder": [ 1480 // "applicationId" 1481 // ], 1482 // "parameters": { 1483 // "applicationId": { 1484 // "description": "The application ID from the Google Play developer console.", 1485 // "location": "path", 1486 // "required": true, 1487 // "type": "string" 1488 // }, 1489 // "maxResults": { 1490 // "description": "The maximum number of player resources to return in the response, used for paging. For any response, the actual number of player resources returned may be less than the specified maxResults.", 1491 // "format": "int32", 1492 // "location": "query", 1493 // "maximum": "50", 1494 // "minimum": "1", 1495 // "type": "integer" 1496 // }, 1497 // "pageToken": { 1498 // "description": "The token returned by the previous request.", 1499 // "location": "query", 1500 // "type": "string" 1501 // } 1502 // }, 1503 // "path": "applications/{applicationId}/players/hidden", 1504 // "response": { 1505 // "$ref": "HiddenPlayerList" 1506 // }, 1507 // "scopes": [ 1508 // "https://www.googleapis.com/auth/games" 1509 // ] 1510 // } 1511 1512} 1513 1514// Pages invokes f for each page of results. 1515// A non-nil error returned from f will halt the iteration. 1516// The provided context supersedes any context provided to the Context method. 1517func (c *ApplicationsListHiddenCall) Pages(ctx context.Context, f func(*HiddenPlayerList) error) error { 1518 c.ctx_ = ctx 1519 defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point 1520 for { 1521 x, err := c.Do() 1522 if err != nil { 1523 return err 1524 } 1525 if err := f(x); err != nil { 1526 return err 1527 } 1528 if x.NextPageToken == "" { 1529 return nil 1530 } 1531 c.PageToken(x.NextPageToken) 1532 } 1533} 1534 1535// method id "gamesManagement.events.reset": 1536 1537type EventsResetCall struct { 1538 s *Service 1539 eventId string 1540 urlParams_ gensupport.URLParams 1541 ctx_ context.Context 1542 header_ http.Header 1543} 1544 1545// Reset: Resets all player progress on the event with the given ID for 1546// the currently authenticated player. This method is only accessible to 1547// whitelisted tester accounts for your application. All quests for this 1548// player that use the event will also be reset. 1549func (r *EventsService) Reset(eventId string) *EventsResetCall { 1550 c := &EventsResetCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1551 c.eventId = eventId 1552 return c 1553} 1554 1555// Fields allows partial responses to be retrieved. See 1556// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1557// for more information. 1558func (c *EventsResetCall) Fields(s ...googleapi.Field) *EventsResetCall { 1559 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1560 return c 1561} 1562 1563// Context sets the context to be used in this call's Do method. Any 1564// pending HTTP request will be aborted if the provided context is 1565// canceled. 1566func (c *EventsResetCall) Context(ctx context.Context) *EventsResetCall { 1567 c.ctx_ = ctx 1568 return c 1569} 1570 1571// Header returns an http.Header that can be modified by the caller to 1572// add HTTP headers to the request. 1573func (c *EventsResetCall) Header() http.Header { 1574 if c.header_ == nil { 1575 c.header_ = make(http.Header) 1576 } 1577 return c.header_ 1578} 1579 1580func (c *EventsResetCall) doRequest(alt string) (*http.Response, error) { 1581 reqHeaders := make(http.Header) 1582 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 1583 for k, v := range c.header_ { 1584 reqHeaders[k] = v 1585 } 1586 reqHeaders.Set("User-Agent", c.s.userAgent()) 1587 var body io.Reader = nil 1588 c.urlParams_.Set("alt", alt) 1589 c.urlParams_.Set("prettyPrint", "false") 1590 urls := googleapi.ResolveRelative(c.s.BasePath, "events/{eventId}/reset") 1591 urls += "?" + c.urlParams_.Encode() 1592 req, err := http.NewRequest("POST", urls, body) 1593 if err != nil { 1594 return nil, err 1595 } 1596 req.Header = reqHeaders 1597 googleapi.Expand(req.URL, map[string]string{ 1598 "eventId": c.eventId, 1599 }) 1600 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1601} 1602 1603// Do executes the "gamesManagement.events.reset" call. 1604func (c *EventsResetCall) Do(opts ...googleapi.CallOption) error { 1605 gensupport.SetOptions(c.urlParams_, opts...) 1606 res, err := c.doRequest("json") 1607 if err != nil { 1608 return err 1609 } 1610 defer googleapi.CloseBody(res) 1611 if err := googleapi.CheckResponse(res); err != nil { 1612 return err 1613 } 1614 return nil 1615 // { 1616 // "description": "Resets all player progress on the event with the given ID for the currently authenticated player. This method is only accessible to whitelisted tester accounts for your application. All quests for this player that use the event will also be reset.", 1617 // "httpMethod": "POST", 1618 // "id": "gamesManagement.events.reset", 1619 // "parameterOrder": [ 1620 // "eventId" 1621 // ], 1622 // "parameters": { 1623 // "eventId": { 1624 // "description": "The ID of the event.", 1625 // "location": "path", 1626 // "required": true, 1627 // "type": "string" 1628 // } 1629 // }, 1630 // "path": "events/{eventId}/reset", 1631 // "scopes": [ 1632 // "https://www.googleapis.com/auth/games" 1633 // ] 1634 // } 1635 1636} 1637 1638// method id "gamesManagement.events.resetAll": 1639 1640type EventsResetAllCall struct { 1641 s *Service 1642 urlParams_ gensupport.URLParams 1643 ctx_ context.Context 1644 header_ http.Header 1645} 1646 1647// ResetAll: Resets all player progress on all events for the currently 1648// authenticated player. This method is only accessible to whitelisted 1649// tester accounts for your application. All quests for this player will 1650// also be reset. 1651func (r *EventsService) ResetAll() *EventsResetAllCall { 1652 c := &EventsResetAllCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1653 return c 1654} 1655 1656// Fields allows partial responses to be retrieved. See 1657// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1658// for more information. 1659func (c *EventsResetAllCall) Fields(s ...googleapi.Field) *EventsResetAllCall { 1660 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1661 return c 1662} 1663 1664// Context sets the context to be used in this call's Do method. Any 1665// pending HTTP request will be aborted if the provided context is 1666// canceled. 1667func (c *EventsResetAllCall) Context(ctx context.Context) *EventsResetAllCall { 1668 c.ctx_ = ctx 1669 return c 1670} 1671 1672// Header returns an http.Header that can be modified by the caller to 1673// add HTTP headers to the request. 1674func (c *EventsResetAllCall) Header() http.Header { 1675 if c.header_ == nil { 1676 c.header_ = make(http.Header) 1677 } 1678 return c.header_ 1679} 1680 1681func (c *EventsResetAllCall) doRequest(alt string) (*http.Response, error) { 1682 reqHeaders := make(http.Header) 1683 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 1684 for k, v := range c.header_ { 1685 reqHeaders[k] = v 1686 } 1687 reqHeaders.Set("User-Agent", c.s.userAgent()) 1688 var body io.Reader = nil 1689 c.urlParams_.Set("alt", alt) 1690 c.urlParams_.Set("prettyPrint", "false") 1691 urls := googleapi.ResolveRelative(c.s.BasePath, "events/reset") 1692 urls += "?" + c.urlParams_.Encode() 1693 req, err := http.NewRequest("POST", urls, body) 1694 if err != nil { 1695 return nil, err 1696 } 1697 req.Header = reqHeaders 1698 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1699} 1700 1701// Do executes the "gamesManagement.events.resetAll" call. 1702func (c *EventsResetAllCall) Do(opts ...googleapi.CallOption) error { 1703 gensupport.SetOptions(c.urlParams_, opts...) 1704 res, err := c.doRequest("json") 1705 if err != nil { 1706 return err 1707 } 1708 defer googleapi.CloseBody(res) 1709 if err := googleapi.CheckResponse(res); err != nil { 1710 return err 1711 } 1712 return nil 1713 // { 1714 // "description": "Resets all player progress on all events for the currently authenticated player. This method is only accessible to whitelisted tester accounts for your application. All quests for this player will also be reset.", 1715 // "httpMethod": "POST", 1716 // "id": "gamesManagement.events.resetAll", 1717 // "path": "events/reset", 1718 // "scopes": [ 1719 // "https://www.googleapis.com/auth/games" 1720 // ] 1721 // } 1722 1723} 1724 1725// method id "gamesManagement.events.resetAllForAllPlayers": 1726 1727type EventsResetAllForAllPlayersCall struct { 1728 s *Service 1729 urlParams_ gensupport.URLParams 1730 ctx_ context.Context 1731 header_ http.Header 1732} 1733 1734// ResetAllForAllPlayers: Resets all draft events for all players. This 1735// method is only available to user accounts for your developer console. 1736// All quests that use any of these events will also be reset. 1737func (r *EventsService) ResetAllForAllPlayers() *EventsResetAllForAllPlayersCall { 1738 c := &EventsResetAllForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1739 return c 1740} 1741 1742// Fields allows partial responses to be retrieved. See 1743// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1744// for more information. 1745func (c *EventsResetAllForAllPlayersCall) Fields(s ...googleapi.Field) *EventsResetAllForAllPlayersCall { 1746 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1747 return c 1748} 1749 1750// Context sets the context to be used in this call's Do method. Any 1751// pending HTTP request will be aborted if the provided context is 1752// canceled. 1753func (c *EventsResetAllForAllPlayersCall) Context(ctx context.Context) *EventsResetAllForAllPlayersCall { 1754 c.ctx_ = ctx 1755 return c 1756} 1757 1758// Header returns an http.Header that can be modified by the caller to 1759// add HTTP headers to the request. 1760func (c *EventsResetAllForAllPlayersCall) Header() http.Header { 1761 if c.header_ == nil { 1762 c.header_ = make(http.Header) 1763 } 1764 return c.header_ 1765} 1766 1767func (c *EventsResetAllForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 1768 reqHeaders := make(http.Header) 1769 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 1770 for k, v := range c.header_ { 1771 reqHeaders[k] = v 1772 } 1773 reqHeaders.Set("User-Agent", c.s.userAgent()) 1774 var body io.Reader = nil 1775 c.urlParams_.Set("alt", alt) 1776 c.urlParams_.Set("prettyPrint", "false") 1777 urls := googleapi.ResolveRelative(c.s.BasePath, "events/resetAllForAllPlayers") 1778 urls += "?" + c.urlParams_.Encode() 1779 req, err := http.NewRequest("POST", urls, body) 1780 if err != nil { 1781 return nil, err 1782 } 1783 req.Header = reqHeaders 1784 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1785} 1786 1787// Do executes the "gamesManagement.events.resetAllForAllPlayers" call. 1788func (c *EventsResetAllForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 1789 gensupport.SetOptions(c.urlParams_, opts...) 1790 res, err := c.doRequest("json") 1791 if err != nil { 1792 return err 1793 } 1794 defer googleapi.CloseBody(res) 1795 if err := googleapi.CheckResponse(res); err != nil { 1796 return err 1797 } 1798 return nil 1799 // { 1800 // "description": "Resets all draft events for all players. This method is only available to user accounts for your developer console. All quests that use any of these events will also be reset.", 1801 // "httpMethod": "POST", 1802 // "id": "gamesManagement.events.resetAllForAllPlayers", 1803 // "path": "events/resetAllForAllPlayers", 1804 // "scopes": [ 1805 // "https://www.googleapis.com/auth/games" 1806 // ] 1807 // } 1808 1809} 1810 1811// method id "gamesManagement.events.resetForAllPlayers": 1812 1813type EventsResetForAllPlayersCall struct { 1814 s *Service 1815 eventId string 1816 urlParams_ gensupport.URLParams 1817 ctx_ context.Context 1818 header_ http.Header 1819} 1820 1821// ResetForAllPlayers: Resets the event with the given ID for all 1822// players. This method is only available to user accounts for your 1823// developer console. Only draft events can be reset. All quests that 1824// use the event will also be reset. 1825func (r *EventsService) ResetForAllPlayers(eventId string) *EventsResetForAllPlayersCall { 1826 c := &EventsResetForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1827 c.eventId = eventId 1828 return c 1829} 1830 1831// Fields allows partial responses to be retrieved. See 1832// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1833// for more information. 1834func (c *EventsResetForAllPlayersCall) Fields(s ...googleapi.Field) *EventsResetForAllPlayersCall { 1835 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1836 return c 1837} 1838 1839// Context sets the context to be used in this call's Do method. Any 1840// pending HTTP request will be aborted if the provided context is 1841// canceled. 1842func (c *EventsResetForAllPlayersCall) Context(ctx context.Context) *EventsResetForAllPlayersCall { 1843 c.ctx_ = ctx 1844 return c 1845} 1846 1847// Header returns an http.Header that can be modified by the caller to 1848// add HTTP headers to the request. 1849func (c *EventsResetForAllPlayersCall) Header() http.Header { 1850 if c.header_ == nil { 1851 c.header_ = make(http.Header) 1852 } 1853 return c.header_ 1854} 1855 1856func (c *EventsResetForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 1857 reqHeaders := make(http.Header) 1858 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 1859 for k, v := range c.header_ { 1860 reqHeaders[k] = v 1861 } 1862 reqHeaders.Set("User-Agent", c.s.userAgent()) 1863 var body io.Reader = nil 1864 c.urlParams_.Set("alt", alt) 1865 c.urlParams_.Set("prettyPrint", "false") 1866 urls := googleapi.ResolveRelative(c.s.BasePath, "events/{eventId}/resetForAllPlayers") 1867 urls += "?" + c.urlParams_.Encode() 1868 req, err := http.NewRequest("POST", urls, body) 1869 if err != nil { 1870 return nil, err 1871 } 1872 req.Header = reqHeaders 1873 googleapi.Expand(req.URL, map[string]string{ 1874 "eventId": c.eventId, 1875 }) 1876 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1877} 1878 1879// Do executes the "gamesManagement.events.resetForAllPlayers" call. 1880func (c *EventsResetForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 1881 gensupport.SetOptions(c.urlParams_, opts...) 1882 res, err := c.doRequest("json") 1883 if err != nil { 1884 return err 1885 } 1886 defer googleapi.CloseBody(res) 1887 if err := googleapi.CheckResponse(res); err != nil { 1888 return err 1889 } 1890 return nil 1891 // { 1892 // "description": "Resets the event with the given ID for all players. This method is only available to user accounts for your developer console. Only draft events can be reset. All quests that use the event will also be reset.", 1893 // "httpMethod": "POST", 1894 // "id": "gamesManagement.events.resetForAllPlayers", 1895 // "parameterOrder": [ 1896 // "eventId" 1897 // ], 1898 // "parameters": { 1899 // "eventId": { 1900 // "description": "The ID of the event.", 1901 // "location": "path", 1902 // "required": true, 1903 // "type": "string" 1904 // } 1905 // }, 1906 // "path": "events/{eventId}/resetForAllPlayers", 1907 // "scopes": [ 1908 // "https://www.googleapis.com/auth/games" 1909 // ] 1910 // } 1911 1912} 1913 1914// method id "gamesManagement.events.resetMultipleForAllPlayers": 1915 1916type EventsResetMultipleForAllPlayersCall struct { 1917 s *Service 1918 eventsresetmultipleforallrequest *EventsResetMultipleForAllRequest 1919 urlParams_ gensupport.URLParams 1920 ctx_ context.Context 1921 header_ http.Header 1922} 1923 1924// ResetMultipleForAllPlayers: Resets events with the given IDs for all 1925// players. This method is only available to user accounts for your 1926// developer console. Only draft events may be reset. All quests that 1927// use any of the events will also be reset. 1928func (r *EventsService) ResetMultipleForAllPlayers(eventsresetmultipleforallrequest *EventsResetMultipleForAllRequest) *EventsResetMultipleForAllPlayersCall { 1929 c := &EventsResetMultipleForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 1930 c.eventsresetmultipleforallrequest = eventsresetmultipleforallrequest 1931 return c 1932} 1933 1934// Fields allows partial responses to be retrieved. See 1935// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 1936// for more information. 1937func (c *EventsResetMultipleForAllPlayersCall) Fields(s ...googleapi.Field) *EventsResetMultipleForAllPlayersCall { 1938 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 1939 return c 1940} 1941 1942// Context sets the context to be used in this call's Do method. Any 1943// pending HTTP request will be aborted if the provided context is 1944// canceled. 1945func (c *EventsResetMultipleForAllPlayersCall) Context(ctx context.Context) *EventsResetMultipleForAllPlayersCall { 1946 c.ctx_ = ctx 1947 return c 1948} 1949 1950// Header returns an http.Header that can be modified by the caller to 1951// add HTTP headers to the request. 1952func (c *EventsResetMultipleForAllPlayersCall) Header() http.Header { 1953 if c.header_ == nil { 1954 c.header_ = make(http.Header) 1955 } 1956 return c.header_ 1957} 1958 1959func (c *EventsResetMultipleForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 1960 reqHeaders := make(http.Header) 1961 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 1962 for k, v := range c.header_ { 1963 reqHeaders[k] = v 1964 } 1965 reqHeaders.Set("User-Agent", c.s.userAgent()) 1966 var body io.Reader = nil 1967 body, err := googleapi.WithoutDataWrapper.JSONReader(c.eventsresetmultipleforallrequest) 1968 if err != nil { 1969 return nil, err 1970 } 1971 reqHeaders.Set("Content-Type", "application/json") 1972 c.urlParams_.Set("alt", alt) 1973 c.urlParams_.Set("prettyPrint", "false") 1974 urls := googleapi.ResolveRelative(c.s.BasePath, "events/resetMultipleForAllPlayers") 1975 urls += "?" + c.urlParams_.Encode() 1976 req, err := http.NewRequest("POST", urls, body) 1977 if err != nil { 1978 return nil, err 1979 } 1980 req.Header = reqHeaders 1981 return gensupport.SendRequest(c.ctx_, c.s.client, req) 1982} 1983 1984// Do executes the "gamesManagement.events.resetMultipleForAllPlayers" call. 1985func (c *EventsResetMultipleForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 1986 gensupport.SetOptions(c.urlParams_, opts...) 1987 res, err := c.doRequest("json") 1988 if err != nil { 1989 return err 1990 } 1991 defer googleapi.CloseBody(res) 1992 if err := googleapi.CheckResponse(res); err != nil { 1993 return err 1994 } 1995 return nil 1996 // { 1997 // "description": "Resets events with the given IDs for all players. This method is only available to user accounts for your developer console. Only draft events may be reset. All quests that use any of the events will also be reset.", 1998 // "httpMethod": "POST", 1999 // "id": "gamesManagement.events.resetMultipleForAllPlayers", 2000 // "path": "events/resetMultipleForAllPlayers", 2001 // "request": { 2002 // "$ref": "EventsResetMultipleForAllRequest" 2003 // }, 2004 // "scopes": [ 2005 // "https://www.googleapis.com/auth/games" 2006 // ] 2007 // } 2008 2009} 2010 2011// method id "gamesManagement.players.hide": 2012 2013type PlayersHideCall struct { 2014 s *Service 2015 applicationId string 2016 playerId string 2017 urlParams_ gensupport.URLParams 2018 ctx_ context.Context 2019 header_ http.Header 2020} 2021 2022// Hide: Hide the given player's leaderboard scores from the given 2023// application. This method is only available to user accounts for your 2024// developer console. 2025func (r *PlayersService) Hide(applicationId string, playerId string) *PlayersHideCall { 2026 c := &PlayersHideCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2027 c.applicationId = applicationId 2028 c.playerId = playerId 2029 return c 2030} 2031 2032// Fields allows partial responses to be retrieved. See 2033// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2034// for more information. 2035func (c *PlayersHideCall) Fields(s ...googleapi.Field) *PlayersHideCall { 2036 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2037 return c 2038} 2039 2040// Context sets the context to be used in this call's Do method. Any 2041// pending HTTP request will be aborted if the provided context is 2042// canceled. 2043func (c *PlayersHideCall) Context(ctx context.Context) *PlayersHideCall { 2044 c.ctx_ = ctx 2045 return c 2046} 2047 2048// Header returns an http.Header that can be modified by the caller to 2049// add HTTP headers to the request. 2050func (c *PlayersHideCall) Header() http.Header { 2051 if c.header_ == nil { 2052 c.header_ = make(http.Header) 2053 } 2054 return c.header_ 2055} 2056 2057func (c *PlayersHideCall) doRequest(alt string) (*http.Response, error) { 2058 reqHeaders := make(http.Header) 2059 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 2060 for k, v := range c.header_ { 2061 reqHeaders[k] = v 2062 } 2063 reqHeaders.Set("User-Agent", c.s.userAgent()) 2064 var body io.Reader = nil 2065 c.urlParams_.Set("alt", alt) 2066 c.urlParams_.Set("prettyPrint", "false") 2067 urls := googleapi.ResolveRelative(c.s.BasePath, "applications/{applicationId}/players/hidden/{playerId}") 2068 urls += "?" + c.urlParams_.Encode() 2069 req, err := http.NewRequest("POST", urls, body) 2070 if err != nil { 2071 return nil, err 2072 } 2073 req.Header = reqHeaders 2074 googleapi.Expand(req.URL, map[string]string{ 2075 "applicationId": c.applicationId, 2076 "playerId": c.playerId, 2077 }) 2078 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2079} 2080 2081// Do executes the "gamesManagement.players.hide" call. 2082func (c *PlayersHideCall) Do(opts ...googleapi.CallOption) error { 2083 gensupport.SetOptions(c.urlParams_, opts...) 2084 res, err := c.doRequest("json") 2085 if err != nil { 2086 return err 2087 } 2088 defer googleapi.CloseBody(res) 2089 if err := googleapi.CheckResponse(res); err != nil { 2090 return err 2091 } 2092 return nil 2093 // { 2094 // "description": "Hide the given player's leaderboard scores from the given application. This method is only available to user accounts for your developer console.", 2095 // "httpMethod": "POST", 2096 // "id": "gamesManagement.players.hide", 2097 // "parameterOrder": [ 2098 // "applicationId", 2099 // "playerId" 2100 // ], 2101 // "parameters": { 2102 // "applicationId": { 2103 // "description": "The application ID from the Google Play developer console.", 2104 // "location": "path", 2105 // "required": true, 2106 // "type": "string" 2107 // }, 2108 // "playerId": { 2109 // "description": "A player ID. A value of me may be used in place of the authenticated player's ID.", 2110 // "location": "path", 2111 // "required": true, 2112 // "type": "string" 2113 // } 2114 // }, 2115 // "path": "applications/{applicationId}/players/hidden/{playerId}", 2116 // "scopes": [ 2117 // "https://www.googleapis.com/auth/games" 2118 // ] 2119 // } 2120 2121} 2122 2123// method id "gamesManagement.players.unhide": 2124 2125type PlayersUnhideCall struct { 2126 s *Service 2127 applicationId string 2128 playerId string 2129 urlParams_ gensupport.URLParams 2130 ctx_ context.Context 2131 header_ http.Header 2132} 2133 2134// Unhide: Unhide the given player's leaderboard scores from the given 2135// application. This method is only available to user accounts for your 2136// developer console. 2137func (r *PlayersService) Unhide(applicationId string, playerId string) *PlayersUnhideCall { 2138 c := &PlayersUnhideCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2139 c.applicationId = applicationId 2140 c.playerId = playerId 2141 return c 2142} 2143 2144// Fields allows partial responses to be retrieved. See 2145// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2146// for more information. 2147func (c *PlayersUnhideCall) Fields(s ...googleapi.Field) *PlayersUnhideCall { 2148 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2149 return c 2150} 2151 2152// Context sets the context to be used in this call's Do method. Any 2153// pending HTTP request will be aborted if the provided context is 2154// canceled. 2155func (c *PlayersUnhideCall) Context(ctx context.Context) *PlayersUnhideCall { 2156 c.ctx_ = ctx 2157 return c 2158} 2159 2160// Header returns an http.Header that can be modified by the caller to 2161// add HTTP headers to the request. 2162func (c *PlayersUnhideCall) Header() http.Header { 2163 if c.header_ == nil { 2164 c.header_ = make(http.Header) 2165 } 2166 return c.header_ 2167} 2168 2169func (c *PlayersUnhideCall) doRequest(alt string) (*http.Response, error) { 2170 reqHeaders := make(http.Header) 2171 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 2172 for k, v := range c.header_ { 2173 reqHeaders[k] = v 2174 } 2175 reqHeaders.Set("User-Agent", c.s.userAgent()) 2176 var body io.Reader = nil 2177 c.urlParams_.Set("alt", alt) 2178 c.urlParams_.Set("prettyPrint", "false") 2179 urls := googleapi.ResolveRelative(c.s.BasePath, "applications/{applicationId}/players/hidden/{playerId}") 2180 urls += "?" + c.urlParams_.Encode() 2181 req, err := http.NewRequest("DELETE", urls, body) 2182 if err != nil { 2183 return nil, err 2184 } 2185 req.Header = reqHeaders 2186 googleapi.Expand(req.URL, map[string]string{ 2187 "applicationId": c.applicationId, 2188 "playerId": c.playerId, 2189 }) 2190 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2191} 2192 2193// Do executes the "gamesManagement.players.unhide" call. 2194func (c *PlayersUnhideCall) Do(opts ...googleapi.CallOption) error { 2195 gensupport.SetOptions(c.urlParams_, opts...) 2196 res, err := c.doRequest("json") 2197 if err != nil { 2198 return err 2199 } 2200 defer googleapi.CloseBody(res) 2201 if err := googleapi.CheckResponse(res); err != nil { 2202 return err 2203 } 2204 return nil 2205 // { 2206 // "description": "Unhide the given player's leaderboard scores from the given application. This method is only available to user accounts for your developer console.", 2207 // "httpMethod": "DELETE", 2208 // "id": "gamesManagement.players.unhide", 2209 // "parameterOrder": [ 2210 // "applicationId", 2211 // "playerId" 2212 // ], 2213 // "parameters": { 2214 // "applicationId": { 2215 // "description": "The application ID from the Google Play developer console.", 2216 // "location": "path", 2217 // "required": true, 2218 // "type": "string" 2219 // }, 2220 // "playerId": { 2221 // "description": "A player ID. A value of me may be used in place of the authenticated player's ID.", 2222 // "location": "path", 2223 // "required": true, 2224 // "type": "string" 2225 // } 2226 // }, 2227 // "path": "applications/{applicationId}/players/hidden/{playerId}", 2228 // "scopes": [ 2229 // "https://www.googleapis.com/auth/games" 2230 // ] 2231 // } 2232 2233} 2234 2235// method id "gamesManagement.rooms.reset": 2236 2237type RoomsResetCall struct { 2238 s *Service 2239 urlParams_ gensupport.URLParams 2240 ctx_ context.Context 2241 header_ http.Header 2242} 2243 2244// Reset: Reset all rooms for the currently authenticated player for 2245// your application. This method is only accessible to whitelisted 2246// tester accounts for your application. 2247func (r *RoomsService) Reset() *RoomsResetCall { 2248 c := &RoomsResetCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2249 return c 2250} 2251 2252// Fields allows partial responses to be retrieved. See 2253// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2254// for more information. 2255func (c *RoomsResetCall) Fields(s ...googleapi.Field) *RoomsResetCall { 2256 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2257 return c 2258} 2259 2260// Context sets the context to be used in this call's Do method. Any 2261// pending HTTP request will be aborted if the provided context is 2262// canceled. 2263func (c *RoomsResetCall) Context(ctx context.Context) *RoomsResetCall { 2264 c.ctx_ = ctx 2265 return c 2266} 2267 2268// Header returns an http.Header that can be modified by the caller to 2269// add HTTP headers to the request. 2270func (c *RoomsResetCall) Header() http.Header { 2271 if c.header_ == nil { 2272 c.header_ = make(http.Header) 2273 } 2274 return c.header_ 2275} 2276 2277func (c *RoomsResetCall) doRequest(alt string) (*http.Response, error) { 2278 reqHeaders := make(http.Header) 2279 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 2280 for k, v := range c.header_ { 2281 reqHeaders[k] = v 2282 } 2283 reqHeaders.Set("User-Agent", c.s.userAgent()) 2284 var body io.Reader = nil 2285 c.urlParams_.Set("alt", alt) 2286 c.urlParams_.Set("prettyPrint", "false") 2287 urls := googleapi.ResolveRelative(c.s.BasePath, "rooms/reset") 2288 urls += "?" + c.urlParams_.Encode() 2289 req, err := http.NewRequest("POST", urls, body) 2290 if err != nil { 2291 return nil, err 2292 } 2293 req.Header = reqHeaders 2294 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2295} 2296 2297// Do executes the "gamesManagement.rooms.reset" call. 2298func (c *RoomsResetCall) Do(opts ...googleapi.CallOption) error { 2299 gensupport.SetOptions(c.urlParams_, opts...) 2300 res, err := c.doRequest("json") 2301 if err != nil { 2302 return err 2303 } 2304 defer googleapi.CloseBody(res) 2305 if err := googleapi.CheckResponse(res); err != nil { 2306 return err 2307 } 2308 return nil 2309 // { 2310 // "description": "Reset all rooms for the currently authenticated player for your application. This method is only accessible to whitelisted tester accounts for your application.", 2311 // "httpMethod": "POST", 2312 // "id": "gamesManagement.rooms.reset", 2313 // "path": "rooms/reset", 2314 // "scopes": [ 2315 // "https://www.googleapis.com/auth/games" 2316 // ] 2317 // } 2318 2319} 2320 2321// method id "gamesManagement.rooms.resetForAllPlayers": 2322 2323type RoomsResetForAllPlayersCall struct { 2324 s *Service 2325 urlParams_ gensupport.URLParams 2326 ctx_ context.Context 2327 header_ http.Header 2328} 2329 2330// ResetForAllPlayers: Deletes rooms where the only room participants 2331// are from whitelisted tester accounts for your application. This 2332// method is only available to user accounts for your developer console. 2333func (r *RoomsService) ResetForAllPlayers() *RoomsResetForAllPlayersCall { 2334 c := &RoomsResetForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2335 return c 2336} 2337 2338// Fields allows partial responses to be retrieved. See 2339// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2340// for more information. 2341func (c *RoomsResetForAllPlayersCall) Fields(s ...googleapi.Field) *RoomsResetForAllPlayersCall { 2342 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2343 return c 2344} 2345 2346// Context sets the context to be used in this call's Do method. Any 2347// pending HTTP request will be aborted if the provided context is 2348// canceled. 2349func (c *RoomsResetForAllPlayersCall) Context(ctx context.Context) *RoomsResetForAllPlayersCall { 2350 c.ctx_ = ctx 2351 return c 2352} 2353 2354// Header returns an http.Header that can be modified by the caller to 2355// add HTTP headers to the request. 2356func (c *RoomsResetForAllPlayersCall) Header() http.Header { 2357 if c.header_ == nil { 2358 c.header_ = make(http.Header) 2359 } 2360 return c.header_ 2361} 2362 2363func (c *RoomsResetForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 2364 reqHeaders := make(http.Header) 2365 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 2366 for k, v := range c.header_ { 2367 reqHeaders[k] = v 2368 } 2369 reqHeaders.Set("User-Agent", c.s.userAgent()) 2370 var body io.Reader = nil 2371 c.urlParams_.Set("alt", alt) 2372 c.urlParams_.Set("prettyPrint", "false") 2373 urls := googleapi.ResolveRelative(c.s.BasePath, "rooms/resetForAllPlayers") 2374 urls += "?" + c.urlParams_.Encode() 2375 req, err := http.NewRequest("POST", urls, body) 2376 if err != nil { 2377 return nil, err 2378 } 2379 req.Header = reqHeaders 2380 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2381} 2382 2383// Do executes the "gamesManagement.rooms.resetForAllPlayers" call. 2384func (c *RoomsResetForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 2385 gensupport.SetOptions(c.urlParams_, opts...) 2386 res, err := c.doRequest("json") 2387 if err != nil { 2388 return err 2389 } 2390 defer googleapi.CloseBody(res) 2391 if err := googleapi.CheckResponse(res); err != nil { 2392 return err 2393 } 2394 return nil 2395 // { 2396 // "description": "Deletes rooms where the only room participants are from whitelisted tester accounts for your application. This method is only available to user accounts for your developer console.", 2397 // "httpMethod": "POST", 2398 // "id": "gamesManagement.rooms.resetForAllPlayers", 2399 // "path": "rooms/resetForAllPlayers", 2400 // "scopes": [ 2401 // "https://www.googleapis.com/auth/games" 2402 // ] 2403 // } 2404 2405} 2406 2407// method id "gamesManagement.scores.reset": 2408 2409type ScoresResetCall struct { 2410 s *Service 2411 leaderboardId string 2412 urlParams_ gensupport.URLParams 2413 ctx_ context.Context 2414 header_ http.Header 2415} 2416 2417// Reset: Resets scores for the leaderboard with the given ID for the 2418// currently authenticated player. This method is only accessible to 2419// whitelisted tester accounts for your application. 2420func (r *ScoresService) Reset(leaderboardId string) *ScoresResetCall { 2421 c := &ScoresResetCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2422 c.leaderboardId = leaderboardId 2423 return c 2424} 2425 2426// Fields allows partial responses to be retrieved. See 2427// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2428// for more information. 2429func (c *ScoresResetCall) Fields(s ...googleapi.Field) *ScoresResetCall { 2430 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2431 return c 2432} 2433 2434// Context sets the context to be used in this call's Do method. Any 2435// pending HTTP request will be aborted if the provided context is 2436// canceled. 2437func (c *ScoresResetCall) Context(ctx context.Context) *ScoresResetCall { 2438 c.ctx_ = ctx 2439 return c 2440} 2441 2442// Header returns an http.Header that can be modified by the caller to 2443// add HTTP headers to the request. 2444func (c *ScoresResetCall) Header() http.Header { 2445 if c.header_ == nil { 2446 c.header_ = make(http.Header) 2447 } 2448 return c.header_ 2449} 2450 2451func (c *ScoresResetCall) doRequest(alt string) (*http.Response, error) { 2452 reqHeaders := make(http.Header) 2453 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 2454 for k, v := range c.header_ { 2455 reqHeaders[k] = v 2456 } 2457 reqHeaders.Set("User-Agent", c.s.userAgent()) 2458 var body io.Reader = nil 2459 c.urlParams_.Set("alt", alt) 2460 c.urlParams_.Set("prettyPrint", "false") 2461 urls := googleapi.ResolveRelative(c.s.BasePath, "leaderboards/{leaderboardId}/scores/reset") 2462 urls += "?" + c.urlParams_.Encode() 2463 req, err := http.NewRequest("POST", urls, body) 2464 if err != nil { 2465 return nil, err 2466 } 2467 req.Header = reqHeaders 2468 googleapi.Expand(req.URL, map[string]string{ 2469 "leaderboardId": c.leaderboardId, 2470 }) 2471 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2472} 2473 2474// Do executes the "gamesManagement.scores.reset" call. 2475// Exactly one of *PlayerScoreResetResponse or error will be non-nil. 2476// Any non-2xx status code is an error. Response headers are in either 2477// *PlayerScoreResetResponse.ServerResponse.Header or (if a response was 2478// returned at all) in error.(*googleapi.Error).Header. Use 2479// googleapi.IsNotModified to check whether the returned error was 2480// because http.StatusNotModified was returned. 2481func (c *ScoresResetCall) Do(opts ...googleapi.CallOption) (*PlayerScoreResetResponse, error) { 2482 gensupport.SetOptions(c.urlParams_, opts...) 2483 res, err := c.doRequest("json") 2484 if res != nil && res.StatusCode == http.StatusNotModified { 2485 if res.Body != nil { 2486 res.Body.Close() 2487 } 2488 return nil, &googleapi.Error{ 2489 Code: res.StatusCode, 2490 Header: res.Header, 2491 } 2492 } 2493 if err != nil { 2494 return nil, err 2495 } 2496 defer googleapi.CloseBody(res) 2497 if err := googleapi.CheckResponse(res); err != nil { 2498 return nil, err 2499 } 2500 ret := &PlayerScoreResetResponse{ 2501 ServerResponse: googleapi.ServerResponse{ 2502 Header: res.Header, 2503 HTTPStatusCode: res.StatusCode, 2504 }, 2505 } 2506 target := &ret 2507 if err := gensupport.DecodeResponse(target, res); err != nil { 2508 return nil, err 2509 } 2510 return ret, nil 2511 // { 2512 // "description": "Resets scores for the leaderboard with the given ID for the currently authenticated player. This method is only accessible to whitelisted tester accounts for your application.", 2513 // "httpMethod": "POST", 2514 // "id": "gamesManagement.scores.reset", 2515 // "parameterOrder": [ 2516 // "leaderboardId" 2517 // ], 2518 // "parameters": { 2519 // "leaderboardId": { 2520 // "description": "The ID of the leaderboard.", 2521 // "location": "path", 2522 // "required": true, 2523 // "type": "string" 2524 // } 2525 // }, 2526 // "path": "leaderboards/{leaderboardId}/scores/reset", 2527 // "response": { 2528 // "$ref": "PlayerScoreResetResponse" 2529 // }, 2530 // "scopes": [ 2531 // "https://www.googleapis.com/auth/games" 2532 // ] 2533 // } 2534 2535} 2536 2537// method id "gamesManagement.scores.resetAll": 2538 2539type ScoresResetAllCall struct { 2540 s *Service 2541 urlParams_ gensupport.URLParams 2542 ctx_ context.Context 2543 header_ http.Header 2544} 2545 2546// ResetAll: Resets all scores for all leaderboards for the currently 2547// authenticated players. This method is only accessible to whitelisted 2548// tester accounts for your application. 2549func (r *ScoresService) ResetAll() *ScoresResetAllCall { 2550 c := &ScoresResetAllCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2551 return c 2552} 2553 2554// Fields allows partial responses to be retrieved. See 2555// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2556// for more information. 2557func (c *ScoresResetAllCall) Fields(s ...googleapi.Field) *ScoresResetAllCall { 2558 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2559 return c 2560} 2561 2562// Context sets the context to be used in this call's Do method. Any 2563// pending HTTP request will be aborted if the provided context is 2564// canceled. 2565func (c *ScoresResetAllCall) Context(ctx context.Context) *ScoresResetAllCall { 2566 c.ctx_ = ctx 2567 return c 2568} 2569 2570// Header returns an http.Header that can be modified by the caller to 2571// add HTTP headers to the request. 2572func (c *ScoresResetAllCall) Header() http.Header { 2573 if c.header_ == nil { 2574 c.header_ = make(http.Header) 2575 } 2576 return c.header_ 2577} 2578 2579func (c *ScoresResetAllCall) doRequest(alt string) (*http.Response, error) { 2580 reqHeaders := make(http.Header) 2581 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 2582 for k, v := range c.header_ { 2583 reqHeaders[k] = v 2584 } 2585 reqHeaders.Set("User-Agent", c.s.userAgent()) 2586 var body io.Reader = nil 2587 c.urlParams_.Set("alt", alt) 2588 c.urlParams_.Set("prettyPrint", "false") 2589 urls := googleapi.ResolveRelative(c.s.BasePath, "scores/reset") 2590 urls += "?" + c.urlParams_.Encode() 2591 req, err := http.NewRequest("POST", urls, body) 2592 if err != nil { 2593 return nil, err 2594 } 2595 req.Header = reqHeaders 2596 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2597} 2598 2599// Do executes the "gamesManagement.scores.resetAll" call. 2600// Exactly one of *PlayerScoreResetAllResponse or error will be non-nil. 2601// Any non-2xx status code is an error. Response headers are in either 2602// *PlayerScoreResetAllResponse.ServerResponse.Header or (if a response 2603// was returned at all) in error.(*googleapi.Error).Header. Use 2604// googleapi.IsNotModified to check whether the returned error was 2605// because http.StatusNotModified was returned. 2606func (c *ScoresResetAllCall) Do(opts ...googleapi.CallOption) (*PlayerScoreResetAllResponse, error) { 2607 gensupport.SetOptions(c.urlParams_, opts...) 2608 res, err := c.doRequest("json") 2609 if res != nil && res.StatusCode == http.StatusNotModified { 2610 if res.Body != nil { 2611 res.Body.Close() 2612 } 2613 return nil, &googleapi.Error{ 2614 Code: res.StatusCode, 2615 Header: res.Header, 2616 } 2617 } 2618 if err != nil { 2619 return nil, err 2620 } 2621 defer googleapi.CloseBody(res) 2622 if err := googleapi.CheckResponse(res); err != nil { 2623 return nil, err 2624 } 2625 ret := &PlayerScoreResetAllResponse{ 2626 ServerResponse: googleapi.ServerResponse{ 2627 Header: res.Header, 2628 HTTPStatusCode: res.StatusCode, 2629 }, 2630 } 2631 target := &ret 2632 if err := gensupport.DecodeResponse(target, res); err != nil { 2633 return nil, err 2634 } 2635 return ret, nil 2636 // { 2637 // "description": "Resets all scores for all leaderboards for the currently authenticated players. This method is only accessible to whitelisted tester accounts for your application.", 2638 // "httpMethod": "POST", 2639 // "id": "gamesManagement.scores.resetAll", 2640 // "path": "scores/reset", 2641 // "response": { 2642 // "$ref": "PlayerScoreResetAllResponse" 2643 // }, 2644 // "scopes": [ 2645 // "https://www.googleapis.com/auth/games" 2646 // ] 2647 // } 2648 2649} 2650 2651// method id "gamesManagement.scores.resetAllForAllPlayers": 2652 2653type ScoresResetAllForAllPlayersCall struct { 2654 s *Service 2655 urlParams_ gensupport.URLParams 2656 ctx_ context.Context 2657 header_ http.Header 2658} 2659 2660// ResetAllForAllPlayers: Resets scores for all draft leaderboards for 2661// all players. This method is only available to user accounts for your 2662// developer console. 2663func (r *ScoresService) ResetAllForAllPlayers() *ScoresResetAllForAllPlayersCall { 2664 c := &ScoresResetAllForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2665 return c 2666} 2667 2668// Fields allows partial responses to be retrieved. See 2669// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2670// for more information. 2671func (c *ScoresResetAllForAllPlayersCall) Fields(s ...googleapi.Field) *ScoresResetAllForAllPlayersCall { 2672 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2673 return c 2674} 2675 2676// Context sets the context to be used in this call's Do method. Any 2677// pending HTTP request will be aborted if the provided context is 2678// canceled. 2679func (c *ScoresResetAllForAllPlayersCall) Context(ctx context.Context) *ScoresResetAllForAllPlayersCall { 2680 c.ctx_ = ctx 2681 return c 2682} 2683 2684// Header returns an http.Header that can be modified by the caller to 2685// add HTTP headers to the request. 2686func (c *ScoresResetAllForAllPlayersCall) Header() http.Header { 2687 if c.header_ == nil { 2688 c.header_ = make(http.Header) 2689 } 2690 return c.header_ 2691} 2692 2693func (c *ScoresResetAllForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 2694 reqHeaders := make(http.Header) 2695 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 2696 for k, v := range c.header_ { 2697 reqHeaders[k] = v 2698 } 2699 reqHeaders.Set("User-Agent", c.s.userAgent()) 2700 var body io.Reader = nil 2701 c.urlParams_.Set("alt", alt) 2702 c.urlParams_.Set("prettyPrint", "false") 2703 urls := googleapi.ResolveRelative(c.s.BasePath, "scores/resetAllForAllPlayers") 2704 urls += "?" + c.urlParams_.Encode() 2705 req, err := http.NewRequest("POST", urls, body) 2706 if err != nil { 2707 return nil, err 2708 } 2709 req.Header = reqHeaders 2710 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2711} 2712 2713// Do executes the "gamesManagement.scores.resetAllForAllPlayers" call. 2714func (c *ScoresResetAllForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 2715 gensupport.SetOptions(c.urlParams_, opts...) 2716 res, err := c.doRequest("json") 2717 if err != nil { 2718 return err 2719 } 2720 defer googleapi.CloseBody(res) 2721 if err := googleapi.CheckResponse(res); err != nil { 2722 return err 2723 } 2724 return nil 2725 // { 2726 // "description": "Resets scores for all draft leaderboards for all players. This method is only available to user accounts for your developer console.", 2727 // "httpMethod": "POST", 2728 // "id": "gamesManagement.scores.resetAllForAllPlayers", 2729 // "path": "scores/resetAllForAllPlayers", 2730 // "scopes": [ 2731 // "https://www.googleapis.com/auth/games" 2732 // ] 2733 // } 2734 2735} 2736 2737// method id "gamesManagement.scores.resetForAllPlayers": 2738 2739type ScoresResetForAllPlayersCall struct { 2740 s *Service 2741 leaderboardId string 2742 urlParams_ gensupport.URLParams 2743 ctx_ context.Context 2744 header_ http.Header 2745} 2746 2747// ResetForAllPlayers: Resets scores for the leaderboard with the given 2748// ID for all players. This method is only available to user accounts 2749// for your developer console. Only draft leaderboards can be reset. 2750func (r *ScoresService) ResetForAllPlayers(leaderboardId string) *ScoresResetForAllPlayersCall { 2751 c := &ScoresResetForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2752 c.leaderboardId = leaderboardId 2753 return c 2754} 2755 2756// Fields allows partial responses to be retrieved. See 2757// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2758// for more information. 2759func (c *ScoresResetForAllPlayersCall) Fields(s ...googleapi.Field) *ScoresResetForAllPlayersCall { 2760 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2761 return c 2762} 2763 2764// Context sets the context to be used in this call's Do method. Any 2765// pending HTTP request will be aborted if the provided context is 2766// canceled. 2767func (c *ScoresResetForAllPlayersCall) Context(ctx context.Context) *ScoresResetForAllPlayersCall { 2768 c.ctx_ = ctx 2769 return c 2770} 2771 2772// Header returns an http.Header that can be modified by the caller to 2773// add HTTP headers to the request. 2774func (c *ScoresResetForAllPlayersCall) Header() http.Header { 2775 if c.header_ == nil { 2776 c.header_ = make(http.Header) 2777 } 2778 return c.header_ 2779} 2780 2781func (c *ScoresResetForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 2782 reqHeaders := make(http.Header) 2783 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 2784 for k, v := range c.header_ { 2785 reqHeaders[k] = v 2786 } 2787 reqHeaders.Set("User-Agent", c.s.userAgent()) 2788 var body io.Reader = nil 2789 c.urlParams_.Set("alt", alt) 2790 c.urlParams_.Set("prettyPrint", "false") 2791 urls := googleapi.ResolveRelative(c.s.BasePath, "leaderboards/{leaderboardId}/scores/resetForAllPlayers") 2792 urls += "?" + c.urlParams_.Encode() 2793 req, err := http.NewRequest("POST", urls, body) 2794 if err != nil { 2795 return nil, err 2796 } 2797 req.Header = reqHeaders 2798 googleapi.Expand(req.URL, map[string]string{ 2799 "leaderboardId": c.leaderboardId, 2800 }) 2801 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2802} 2803 2804// Do executes the "gamesManagement.scores.resetForAllPlayers" call. 2805func (c *ScoresResetForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 2806 gensupport.SetOptions(c.urlParams_, opts...) 2807 res, err := c.doRequest("json") 2808 if err != nil { 2809 return err 2810 } 2811 defer googleapi.CloseBody(res) 2812 if err := googleapi.CheckResponse(res); err != nil { 2813 return err 2814 } 2815 return nil 2816 // { 2817 // "description": "Resets scores for the leaderboard with the given ID for all players. This method is only available to user accounts for your developer console. Only draft leaderboards can be reset.", 2818 // "httpMethod": "POST", 2819 // "id": "gamesManagement.scores.resetForAllPlayers", 2820 // "parameterOrder": [ 2821 // "leaderboardId" 2822 // ], 2823 // "parameters": { 2824 // "leaderboardId": { 2825 // "description": "The ID of the leaderboard.", 2826 // "location": "path", 2827 // "required": true, 2828 // "type": "string" 2829 // } 2830 // }, 2831 // "path": "leaderboards/{leaderboardId}/scores/resetForAllPlayers", 2832 // "scopes": [ 2833 // "https://www.googleapis.com/auth/games" 2834 // ] 2835 // } 2836 2837} 2838 2839// method id "gamesManagement.scores.resetMultipleForAllPlayers": 2840 2841type ScoresResetMultipleForAllPlayersCall struct { 2842 s *Service 2843 scoresresetmultipleforallrequest *ScoresResetMultipleForAllRequest 2844 urlParams_ gensupport.URLParams 2845 ctx_ context.Context 2846 header_ http.Header 2847} 2848 2849// ResetMultipleForAllPlayers: Resets scores for the leaderboards with 2850// the given IDs for all players. This method is only available to user 2851// accounts for your developer console. Only draft leaderboards may be 2852// reset. 2853func (r *ScoresService) ResetMultipleForAllPlayers(scoresresetmultipleforallrequest *ScoresResetMultipleForAllRequest) *ScoresResetMultipleForAllPlayersCall { 2854 c := &ScoresResetMultipleForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2855 c.scoresresetmultipleforallrequest = scoresresetmultipleforallrequest 2856 return c 2857} 2858 2859// Fields allows partial responses to be retrieved. See 2860// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2861// for more information. 2862func (c *ScoresResetMultipleForAllPlayersCall) Fields(s ...googleapi.Field) *ScoresResetMultipleForAllPlayersCall { 2863 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2864 return c 2865} 2866 2867// Context sets the context to be used in this call's Do method. Any 2868// pending HTTP request will be aborted if the provided context is 2869// canceled. 2870func (c *ScoresResetMultipleForAllPlayersCall) Context(ctx context.Context) *ScoresResetMultipleForAllPlayersCall { 2871 c.ctx_ = ctx 2872 return c 2873} 2874 2875// Header returns an http.Header that can be modified by the caller to 2876// add HTTP headers to the request. 2877func (c *ScoresResetMultipleForAllPlayersCall) Header() http.Header { 2878 if c.header_ == nil { 2879 c.header_ = make(http.Header) 2880 } 2881 return c.header_ 2882} 2883 2884func (c *ScoresResetMultipleForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 2885 reqHeaders := make(http.Header) 2886 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 2887 for k, v := range c.header_ { 2888 reqHeaders[k] = v 2889 } 2890 reqHeaders.Set("User-Agent", c.s.userAgent()) 2891 var body io.Reader = nil 2892 body, err := googleapi.WithoutDataWrapper.JSONReader(c.scoresresetmultipleforallrequest) 2893 if err != nil { 2894 return nil, err 2895 } 2896 reqHeaders.Set("Content-Type", "application/json") 2897 c.urlParams_.Set("alt", alt) 2898 c.urlParams_.Set("prettyPrint", "false") 2899 urls := googleapi.ResolveRelative(c.s.BasePath, "scores/resetMultipleForAllPlayers") 2900 urls += "?" + c.urlParams_.Encode() 2901 req, err := http.NewRequest("POST", urls, body) 2902 if err != nil { 2903 return nil, err 2904 } 2905 req.Header = reqHeaders 2906 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2907} 2908 2909// Do executes the "gamesManagement.scores.resetMultipleForAllPlayers" call. 2910func (c *ScoresResetMultipleForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 2911 gensupport.SetOptions(c.urlParams_, opts...) 2912 res, err := c.doRequest("json") 2913 if err != nil { 2914 return err 2915 } 2916 defer googleapi.CloseBody(res) 2917 if err := googleapi.CheckResponse(res); err != nil { 2918 return err 2919 } 2920 return nil 2921 // { 2922 // "description": "Resets scores for the leaderboards with the given IDs for all players. This method is only available to user accounts for your developer console. Only draft leaderboards may be reset.", 2923 // "httpMethod": "POST", 2924 // "id": "gamesManagement.scores.resetMultipleForAllPlayers", 2925 // "path": "scores/resetMultipleForAllPlayers", 2926 // "request": { 2927 // "$ref": "ScoresResetMultipleForAllRequest" 2928 // }, 2929 // "scopes": [ 2930 // "https://www.googleapis.com/auth/games" 2931 // ] 2932 // } 2933 2934} 2935 2936// method id "gamesManagement.turnBasedMatches.reset": 2937 2938type TurnBasedMatchesResetCall struct { 2939 s *Service 2940 urlParams_ gensupport.URLParams 2941 ctx_ context.Context 2942 header_ http.Header 2943} 2944 2945// Reset: Reset all turn-based match data for a user. This method is 2946// only accessible to whitelisted tester accounts for your application. 2947func (r *TurnBasedMatchesService) Reset() *TurnBasedMatchesResetCall { 2948 c := &TurnBasedMatchesResetCall{s: r.s, urlParams_: make(gensupport.URLParams)} 2949 return c 2950} 2951 2952// Fields allows partial responses to be retrieved. See 2953// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 2954// for more information. 2955func (c *TurnBasedMatchesResetCall) Fields(s ...googleapi.Field) *TurnBasedMatchesResetCall { 2956 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 2957 return c 2958} 2959 2960// Context sets the context to be used in this call's Do method. Any 2961// pending HTTP request will be aborted if the provided context is 2962// canceled. 2963func (c *TurnBasedMatchesResetCall) Context(ctx context.Context) *TurnBasedMatchesResetCall { 2964 c.ctx_ = ctx 2965 return c 2966} 2967 2968// Header returns an http.Header that can be modified by the caller to 2969// add HTTP headers to the request. 2970func (c *TurnBasedMatchesResetCall) Header() http.Header { 2971 if c.header_ == nil { 2972 c.header_ = make(http.Header) 2973 } 2974 return c.header_ 2975} 2976 2977func (c *TurnBasedMatchesResetCall) doRequest(alt string) (*http.Response, error) { 2978 reqHeaders := make(http.Header) 2979 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 2980 for k, v := range c.header_ { 2981 reqHeaders[k] = v 2982 } 2983 reqHeaders.Set("User-Agent", c.s.userAgent()) 2984 var body io.Reader = nil 2985 c.urlParams_.Set("alt", alt) 2986 c.urlParams_.Set("prettyPrint", "false") 2987 urls := googleapi.ResolveRelative(c.s.BasePath, "turnbasedmatches/reset") 2988 urls += "?" + c.urlParams_.Encode() 2989 req, err := http.NewRequest("POST", urls, body) 2990 if err != nil { 2991 return nil, err 2992 } 2993 req.Header = reqHeaders 2994 return gensupport.SendRequest(c.ctx_, c.s.client, req) 2995} 2996 2997// Do executes the "gamesManagement.turnBasedMatches.reset" call. 2998func (c *TurnBasedMatchesResetCall) Do(opts ...googleapi.CallOption) error { 2999 gensupport.SetOptions(c.urlParams_, opts...) 3000 res, err := c.doRequest("json") 3001 if err != nil { 3002 return err 3003 } 3004 defer googleapi.CloseBody(res) 3005 if err := googleapi.CheckResponse(res); err != nil { 3006 return err 3007 } 3008 return nil 3009 // { 3010 // "description": "Reset all turn-based match data for a user. This method is only accessible to whitelisted tester accounts for your application.", 3011 // "httpMethod": "POST", 3012 // "id": "gamesManagement.turnBasedMatches.reset", 3013 // "path": "turnbasedmatches/reset", 3014 // "scopes": [ 3015 // "https://www.googleapis.com/auth/games" 3016 // ] 3017 // } 3018 3019} 3020 3021// method id "gamesManagement.turnBasedMatches.resetForAllPlayers": 3022 3023type TurnBasedMatchesResetForAllPlayersCall struct { 3024 s *Service 3025 urlParams_ gensupport.URLParams 3026 ctx_ context.Context 3027 header_ http.Header 3028} 3029 3030// ResetForAllPlayers: Deletes turn-based matches where the only match 3031// participants are from whitelisted tester accounts for your 3032// application. This method is only available to user accounts for your 3033// developer console. 3034func (r *TurnBasedMatchesService) ResetForAllPlayers() *TurnBasedMatchesResetForAllPlayersCall { 3035 c := &TurnBasedMatchesResetForAllPlayersCall{s: r.s, urlParams_: make(gensupport.URLParams)} 3036 return c 3037} 3038 3039// Fields allows partial responses to be retrieved. See 3040// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse 3041// for more information. 3042func (c *TurnBasedMatchesResetForAllPlayersCall) Fields(s ...googleapi.Field) *TurnBasedMatchesResetForAllPlayersCall { 3043 c.urlParams_.Set("fields", googleapi.CombineFields(s)) 3044 return c 3045} 3046 3047// Context sets the context to be used in this call's Do method. Any 3048// pending HTTP request will be aborted if the provided context is 3049// canceled. 3050func (c *TurnBasedMatchesResetForAllPlayersCall) Context(ctx context.Context) *TurnBasedMatchesResetForAllPlayersCall { 3051 c.ctx_ = ctx 3052 return c 3053} 3054 3055// Header returns an http.Header that can be modified by the caller to 3056// add HTTP headers to the request. 3057func (c *TurnBasedMatchesResetForAllPlayersCall) Header() http.Header { 3058 if c.header_ == nil { 3059 c.header_ = make(http.Header) 3060 } 3061 return c.header_ 3062} 3063 3064func (c *TurnBasedMatchesResetForAllPlayersCall) doRequest(alt string) (*http.Response, error) { 3065 reqHeaders := make(http.Header) 3066 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.4 gdcl/20191114") 3067 for k, v := range c.header_ { 3068 reqHeaders[k] = v 3069 } 3070 reqHeaders.Set("User-Agent", c.s.userAgent()) 3071 var body io.Reader = nil 3072 c.urlParams_.Set("alt", alt) 3073 c.urlParams_.Set("prettyPrint", "false") 3074 urls := googleapi.ResolveRelative(c.s.BasePath, "turnbasedmatches/resetForAllPlayers") 3075 urls += "?" + c.urlParams_.Encode() 3076 req, err := http.NewRequest("POST", urls, body) 3077 if err != nil { 3078 return nil, err 3079 } 3080 req.Header = reqHeaders 3081 return gensupport.SendRequest(c.ctx_, c.s.client, req) 3082} 3083 3084// Do executes the "gamesManagement.turnBasedMatches.resetForAllPlayers" call. 3085func (c *TurnBasedMatchesResetForAllPlayersCall) Do(opts ...googleapi.CallOption) error { 3086 gensupport.SetOptions(c.urlParams_, opts...) 3087 res, err := c.doRequest("json") 3088 if err != nil { 3089 return err 3090 } 3091 defer googleapi.CloseBody(res) 3092 if err := googleapi.CheckResponse(res); err != nil { 3093 return err 3094 } 3095 return nil 3096 // { 3097 // "description": "Deletes turn-based matches where the only match participants are from whitelisted tester accounts for your application. This method is only available to user accounts for your developer console.", 3098 // "httpMethod": "POST", 3099 // "id": "gamesManagement.turnBasedMatches.resetForAllPlayers", 3100 // "path": "turnbasedmatches/resetForAllPlayers", 3101 // "scopes": [ 3102 // "https://www.googleapis.com/auth/games" 3103 // ] 3104 // } 3105 3106} 3107