Ta strona została przetłumaczona przez Cloud Translation API.

Rozpocznij

Do automatycznej interakcji z autoryzowanymi kupującymi możesz używać 3 interfejsów API:

Interfejs API Marketplace: umożliwia zarządzanie ofertami, pakietami aukcji i dostępem klientów.
Interfejs API określania stawek w czasie rzeczywistym: umożliwia zarządzanie określaniem stawek, w tym limitami zapytań, kierowaniem i kreacjami.
(Wycofany)Ad Exchange Buyer API II: ten interfejs API został wycofany. Wszystkie zasoby oprócz tych związanych z rozwiązywaniem problemów z RTB zostały wycofane.

Oto kilka przykładów zadań, które możesz wykonać za pomocą interfejsów API Authorized Buyers:

Uzyskać dostęp do informacji o koncie określania stawek w czasie rzeczywistym.
Przesyłanie kreacji do sprawdzenia i zarządzanie nimi.
Pobieraj dane dotyczące rozwiązywania problemów z określaniem stawek w czasie rzeczywistym.
zarządzać listami użytkowników programu Authorized Buyers.
Zarządzaj konfiguracjami kierowania wstępnego.
Skonfiguruj dostęp klientów do Marketplace.
Wyświetlaj propozycje umów na Rynku i zarządzaj nimi.

Jeśli nie wiesz, czym jest Authorized Buyers, zapoznaj się z Centrum pomocy Authorized Buyers i interfejsem użytkownika.

Szybkie linki

Konfigurowanie uwierzytelniania

Interfejsy API Google używają protokołu OAuth 2.0 do uwierzytelniania i autoryzacji. Oto, jak skonfigurować uwierzytelnianie w interfejsie Real-time Bidding API za pomocą protokołu OAuth 2.0.

W tym przykładzie użyto konta usługi. Więcej informacji o kontroli dostępu znajdziesz w dokumentacji zarządzania dostępem do Google Cloud Identity.

Otwórz stronę Interfejsy API włączone w Konsoli interfejsów API Google.
W menu projektu wybierz projekt lub utwórz nowy.

Uwaga: aby uniknąć utraty dostępu, zalecamy przypisanie do projektu wielu osób z dostępem administracyjnym.
Sprawdź, czy API do określania stawek w czasie rzeczywistym jest wymieniony na liście włączonych interfejsów API. Jeśli go tam nie ma, kliknij kartę Interfejsy API Google, wyszukaj i wybierz interfejs API Real-time Bidding, a potem kliknij Włącz interfejs API.
Następnie na pasku bocznym po lewej stronie wybierz Dane logowania.
Kliknij menu Utwórz dane logowania, a następnie Klucz konta usługi.
W menu Konto usługi wybierz Nowe konto usługi.
Wpisz nazwę konta usługi. Identyfikator konta usługi jest generowany automatycznie na podstawie nazwy konta i nazwy projektu.
Zanotuj identyfikator konta usługi: będzie on potrzebny do przyznania dostępu do nowego konta usługi w interfejsie autoryzowanych kupujących w kroku 11.
W polu Typ klucza wybierz zalecany plik JSON.
Kliknij Utwórz. Plik JSON z parą kluczy publicznych i prywatnych konta zostanie zapisany w folderze Pobrane. Zachowaj wygenerowany plik JSON w bezpiecznym miejscu.
Aby konto usługi mogło działać, musisz przyznać mu dostęp w interfejsie Authorized Buyers. Wybierz Ustawienia > Ustawienia konta, a następnie Zarządzanie użytkownikami > Użytkownicy konta i kliknij +Konto usługi. Wpisz identyfikator konta usługi zapisany w kroku 8. Spowoduje to utworzenie nowego użytkownika z rolą konta usługi.

Upewnij się, że wiele osób ma dostęp administracyjny do Twojego projektu w chmurze, na wypadek gdyby trzeba było zmienić uprawnienia.

Poproś o dostęp do interfejsu API

Podczas procesu autoryzacji OAuth 2.0 Twoja aplikacja może określać zakresy żądań dostępu do określonych funkcji w imieniu innych kont Google. Użyj tych zakresów, aby w imieniu konta Authorized Buyers uzyskać uprawnienia do odczytu i zapisu dowolnych interfejsów API Authorized Buyers:

API Marketplace: https://www.googleapis.com/auth/authorized-buyers-marketplace
Real-time Bidding API: https://www.googleapis.com/auth/realtime-bidding
Ad Exchange Buyer API II: https://www.googleapis.com/auth/adexchange.buyer

Wywoływanie interfejsu API

Oto kilka przykładów, które ułatwią Ci rozpoczęcie pracy w obsługiwanych językach:

Marketplace API

Java

/*
 * Copyright 2021 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.api.services.samples.authorizedbuyers.marketplace.v1;

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.authorizedbuyersmarketplace.v1.AuthorizedBuyersMarketplace;
import com.google.api.services.authorizedbuyersmarketplace.v1.AuthorizedBuyersMarketplaceScopes;
import com.google.api.services.authorizedbuyersmarketplace.v1.model.Client;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.ServiceAccountCredentials;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * A sample application that authenticates and runs a request against the Authorized Buyers
 * Marketplace API.
 */
public class FirstApiRequest {

  /**
   * Be sure to specify the name of your application. If the application name is {@code null} or
   * blank, the application will log a warning. Suggested format is "MyCompany-ProductName/1.0".
   */
  private static final String APPLICATION_NAME = "APPLICATION_NAME_HERE";

  // Full path to JSON Key file - include file name.
  private static final java.io.File JSON_FILE = new java.io.File("INSERT_PATH_TO_JSON_FILE");

  // Name of the buyer resource for which the API call is being made.
  private static final String BUYER_NAME = "INSERT_BUYER_RESOURCE_NAME";

  // Global instance of the HTTP transport.
  private static HttpTransport httpTransport;

  // Global instance of the JSON factory.
  private static final JsonFactory jsonFactory = GsonFactory.getDefaultInstance();

  public static void main(String[] args) throws Exception {
    // Create credentials using the JSON key file.
    GoogleCredentials credentials = null;

    try (FileInputStream serviceAccountStream = new FileInputStream((JSON_FILE))) {
      Set<String> scopes = new HashSet<>(AuthorizedBuyersMarketplaceScopes.all());
      credentials = ServiceAccountCredentials.fromStream(serviceAccountStream).createScoped(scopes);
    } catch (IOException ex) {
      System.out.println("Can't complete authorization step. Did you specify a JSON key file?");
      System.out.println(ex);
      System.exit(1);
    }

    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(credentials);
    httpTransport = GoogleNetHttpTransport.newTrustedTransport();

    // Use the credentials to create a client for the API service.
    AuthorizedBuyersMarketplace marketplaceClient =
        new AuthorizedBuyersMarketplace.Builder(httpTransport, jsonFactory, requestInitializer)
            .setApplicationName(APPLICATION_NAME)
            .build();

    // Call the buyers.clients.list method to get a list of clients for the given buyer.
    List<Client> clients =
        marketplaceClient.buyers().clients().list(BUYER_NAME).execute().getClients();

    if (clients != null && clients.size() > 0) {
      System.out.printf("Listing of clients associated with buyer \"%s\"%n", BUYER_NAME);
      for (Client client : clients) {
        System.out.printf("* Client name: %s\n", client.getName());
      }
    } else {
      System.out.printf(
          "No clients were found that were associated with buyer \"%s\"%n.", BUYER_NAME);
    }
  }
}

Python

#!/usr/bin/python
#
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Sample application that authenticates and makes an API request."""

import pprint
from googleapiclient.discovery import build
from google.oauth2 import service_account

# A Service Account key file can be generated via the Google Developers
# Console.
KEY_FILE = 'PATH_TO_JSON_KEY_FILE'  # Path to Service Account JSON key file.

# Authorized Buyers Marketplace API authorization scope.
SCOPE = 'https://www.googleapis.com/auth/authorized-buyers-marketplace'
VERSION = 'v1'  # Version of Authorized Buyers Marketplace API to use.

# Name of the buyer resource for which the API call is being made.
BUYER_NAME = 'BUYER_RESOURCE_NAME'


def main():
  # Create credentials using the Service Account JSON key file.
  credentials = service_account.Credentials.from_service_account_file(
      KEY_FILE, scopes=[SCOPE])

  # Build a client for the authorizedbuyersmarketplace API service.
  marketplace = build('authorizedbuyersmarketplace', VERSION, credentials=credentials)

  # Call the buyers.clients.list method to get a list of clients for the
  # given buyer.
  request = marketplace.buyers().clients().list(parent=BUYER_NAME)

  pprint.pprint(request.execute())


if __name__ == '__main__':
  main()

.NET

/* Copyright 2021 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using Google.Apis.AuthorizedBuyersMarketplace.v1;
using Google.Apis.AuthorizedBuyersMarketplace.v1.Data;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Json;
using Google.Apis.Services;

using System;
using System.Collections.Generic;

namespace Google.Apis.AuthorizedBuyersMarketplace.Examples.v1
{
    /// <summary>
    /// Self contained sample to return a list of clients for a given buyer account.
    /// Primarily used by the Getting Started guide:
    /// https://developers.google.com/authorized-buyers/apis/getting_started
    ///
    /// Note: To run this sample, you will need to configure it as the StartupObject in
    /// Google.Apis.AuthorizedBuyersMarketplace.Examples.csproj.
    /// </summary>
    internal class FirstApiRequest
    {
        private static void Main(string[] args)
        {
            // See the README.md for details of these fields.
            // Retrieved from https://console.developers.google.com
            var ServiceKeyFilePath = "PATH TO JSON KEY FILE HERE";

            // Name of the buyer resource for which the API call is being made.
            var buyerName = "INSERT_BUYER_RESOURCE_NAME_HERE";

            // Retrieve credential parameters from the key JSON file.
            var credentialParameters = NewtonsoftJsonSerializer.Instance
                .Deserialize<JsonCredentialParameters>(
                    System.IO.File.ReadAllText(ServiceKeyFilePath));

            // Create the credentials.
            var credentialInitializer = new ServiceAccountCredential.Initializer(
                    credentialParameters.ClientEmail)
                {
                    Scopes = new[]
                    {
                        AuthorizedBuyersMarketplaceService.Scope.AuthorizedBuyersMarketplace
                    }
                }.FromPrivateKey(credentialParameters.PrivateKey);

            var oAuth2Credentials = new ServiceAccountCredential(credentialInitializer);

            // Use the credentials to create a client for the API service.
            var serviceInitializer = new BaseClientService.Initializer
                {
                    HttpClientInitializer = oAuth2Credentials,
                    ApplicationName = "FirstAPICall"
                };

            var mkService = new AuthorizedBuyersMarketplaceService(serviceInitializer);

            // Call the buyers.clients.list method to list clients for the given buyer.
            BuyersResource.ClientsResource.ListRequest request =
                mkService.Buyers.Clients.List(buyerName);

            IList<Client> clients = request.Execute().Clients;

            foreach (Client client in clients)
            {
                Console.WriteLine("* Client name: {0}", client.Name);
            }

            Console.ReadLine();
        }
    }
}

PHP

<?php

/**
 * Copyright 2022 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Sample application that authenticates and makes an API request.
 */

namespace Google\Ads\AuthorizedBuyers\Marketplace\Examples\V1;

/**
 * Provide path to client library. See README.md for details.
 */
require_once __DIR__ . '/../../vendor/autoload.php';

use Google_Client;
use Google_Service_AuthorizedBuyersMarketplace;


session_start();

/**
 * You can retrieve this file from the Google Developers Console.
 *
 * See README.md for details.
 */
$keyFileLocation = "INSERT_PATH_TO_JSON_KEYFILE";

/**
 * Name of the buyer resource for which the API call is being made.
 */
$buyerName = "INSERT_BUYER_RESOURCE_NAME";

if ($keyFileLocation === 'INSERT_PATH_TO_JSON_KEYFILE') {
    print "WARNING: Authorization details not provided!\n";
    exit(1);
}

$client = new Google_Client();
$client->setApplicationName('Authorized Buyers Marketplace API PHP Samples');

$service = new Google_Service_AuthorizedBuyersMarketplace($client);

$client->setAuthConfig($keyFileLocation);
$client->addScope('https://www.googleapis.com/auth/authorized-buyers-marketplace');

if ($client->isAccessTokenExpired()) {
    $client->refreshTokenWithAssertion();
}

if ($client->getAccessToken()) {
    // Call the buyers.clients.list method to get a list of clients for the given buyer.
    $result = $service->buyers_clients->listBuyersClients($buyerName);

    print "Clients associated with buyer account\n";
    if (empty($result['clients'])) {
        print "No clients found\n";
        return;
    } else {
        foreach ($result['clients'] as $client) {
            print_r($client);
        }
    }
}

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2022 Google LLC
#
# License:: Licensed under the Apache License, Version 2.0 (the "License");
#           you may not use this file except in compliance with the License.
#           You may obtain a copy of the License at
#
#           http://www.apache.org/licenses/LICENSE-2.0
#
#           Unless required by applicable law or agreed to in writing, software
#           distributed under the License is distributed on an "AS IS" BASIS,
#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
#           implied.
#           See the License for the specific language governing permissions and
#           limitations under the License.
#
# Sample application that authenticates and makes an API request.

require 'google/apis/authorizedbuyersmarketplace_v1'
require 'googleauth/service_account'

# You can download the JSON keyfile used for authentication from the Google
# Developers Console.
KEY_FILE = 'path_to_key'  # Path to JSON file containing your private key.

# Name of the buyer resource for which the API call is being made.
BUYER_NAME = 'insert_buyer_resource_name'


def first_api_request()
  # Create credentials using the JSON key file.
  auth_options = {
    :json_key_io => File.open(KEY_FILE, "r"),
    :scope => 'https://www.googleapis.com/auth/authorized-buyers-marketplace'
  }

  oauth_credentials = Google::Auth::ServiceAccountCredentials.make_creds(
    options=auth_options
  )

  # Create the service and set credentials
  marketplace = (
    Google::Apis::AuthorizedbuyersmarketplaceV1::AuthorizedBuyersMarketplaceService.new
  )
  marketplace.authorization = oauth_credentials
  marketplace.authorization.fetch_access_token!

  begin
    # Call the buyers.clients.list method to get list of clients for given buyer.
    clients_list = marketplace.list_buyer_clients(BUYER_NAME)

    if clients_list.clients.any?
      puts "Found the following clients for buyer '%s':" % BUYER_NAME
      clients_list.clients.each do |client|
        puts "* Client name: #{client.name}"
      end
    else
      puts "No clients were found that were associated with buyer '%s'" % BUYER_NAME
    end
  rescue Google::Apis::ServerError => e
    raise "The following server error occured:\n%s" % e.message
  rescue Google::Apis::ClientError => e
    raise "Invalid client request:\n%s" % e.message
  rescue Google::Apis::AuthorizationError => e
    raise "Authorization error occured:\n%s" % e.message
  end
end

if __FILE__ == $0
  begin
    first_api_request()
  end
end

Real-time Bidding API

Java

Oto podstawowy przykład, który pokazuje, jak używać interfejsu API określania stawek w czasie rzeczywistym w języku Java.

Tworzenie projektu Maven

Otwórz plik pom.xml i dodaj te zależności:

<dependencies>
  <dependency>
    <groupId>com.google.api-client</groupId>
    <artifactId>google-api-client</artifactId>
    <version>1.32.2</version>
  </dependency>
  <dependency>
    <groupId>com.google.apis</groupId>
    <artifactId>google-api-services-pubsub</artifactId>
    <version>v1-rev452-1.25.0</version>
  </dependency>
  <dependency>
    <groupId>com.google.apis</groupId>
    <artifactId>google-api-services-realtimebidding</artifactId>
    <version>v1-rev20220503-1.32.1</version>
  </dependency>
  <dependency>
    <groupId>com.google.auth</groupId>
    <artifactId>google-auth-library-oauth2-http</artifactId>
    <version>1.3.0</version>
  </dependency>
  <dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.9</version>
  </dependency>
  <dependency>
    <groupId>com.google.http-client</groupId>
    <artifactId>google-http-client-jackson2</artifactId>
    <version>1.40.1</version>
  </dependency>
  <dependency>
    <groupId>joda-time</groupId>
    <artifactId>joda-time</artifactId>
    <version>2.10.13</version>
  </dependency>
  <dependency>
    <groupId>net.sourceforge.argparse4j</groupId>
    <artifactId>argparse4j</artifactId>
    <version>0.9.0</version>
  </dependency>
</dependencies>

Konfigurowanie danych logowania

Wszystkie wywołania interfejsu API wymagają uwierzytelnienia. Utwórz plik klucza JSON konta usługi Credential, korzystając z omówionego powyżej pliku klucza JSON konta usługi.

GoogleCredentials credentials = null;

try (FileInputStream serviceAccountStream = new FileInputStream((JSON_FILE))) {
  Set<String> scopes = new HashSet<>(RealTimeBiddingScopes.all());
  credentials = ServiceAccountCredentials.fromStream(serviceAccountStream).createScoped(scopes);
} catch (IOException ex) {
  System.out.println("Can't complete authorization step. Did you specify a JSON key file?");
  System.out.println(ex);
  System.exit(1);
}

Tworzenie klienta interfejsu Real-time Bidding API

Następnie możesz utworzyć klienta interfejsu API określania stawek w czasie rzeczywistym za pomocą wzoru kreatora:


HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(credentials);
httpTransport = GoogleNetHttpTransport.newTrustedTransport();

// Use the credentials to create a client for the API service.
RealTimeBidding realtimeBidding =
    new RealTimeBidding.Builder(httpTransport, jsonFactory, requestInitializer)
        .setApplicationName(APPLICATION_NAME)
        .build();

Wykonywanie operacji

Po uruchomieniu klienta, który ma się połączyć z interfejsem API, możesz wykonać operację. Ten kod zwraca wszystkie kreacje danego kupującego.

    List<Creative> creatives =
        realtimeBidding
            .buyers()
            .creatives()
            .list(BUYER_NAME)
            .setView("FULL")
            .execute()
            .getCreatives();

    if (creatives != null && creatives.size() > 0) {
      System.out.printf("Listing of creatives associated with buyer '%s'%n", BUYER_NAME);
      for (Creative creative : creatives) {
        System.out.printf("* Creative name: %s\n", creative.getName());
      }
    } else {
      System.out.printf(
          "No creatives were found that were associated with buyer '%s'%n.", BUYER_NAME);
    }FirstApiRequest.java

Bardziej szczegółowe informacje o używaniu interfejsu Real-timeReporting API w Javie znajdziesz w pliku README w przykładach interfejsu Real-time Reporting API.

Python

Oto podstawowy przykład, który pokazuje, jak używać interfejsu API określania stawek w czasie rzeczywistym w Pythonie.

Pobieranie i instalowanie klienta interfejsu Google API w Pythonie
Przykład użycia pip:
```
$ pip install --upgrade google-api-python-client
```
Konfigurowanie danych logowania
Wszystkie wywołania interfejsu API wymagają uwierzytelnienia. Aby utworzyć instancję service_account.Credentials, użyj pliku klucza JSON konta usługi, o którym mowa powyżej.
```
  credentials = service_account.Credentials.from_service_account_file(
      KEY_FILE, scopes=[SCOPE])
```
Tworzenie klienta dla interfejsu Real-time Billing API
Następnie możesz utworzyć klienta interfejsu API określania stawek w czasie rzeczywistym, korzystając z autoryzowanej instancji:service_account.Credentials
```
realtimebidding = build('realtimebidding', VERSION, credentials=credentials)
```
Wykonywanie operacji
Po utworzeniu instancji klienta umożliwiającej połączenie z interfejsem API możesz wykonać operację. Ten kod zwraca wszystkie kreacje danego kupującego.
```
request = realtimebidding.buyers().creatives().list(parent=BUYER_NAME)

pprint.pprint(request.execute())first_api_request.py
```

Więcej informacji o korzystaniu z interfejsu Ad Exchange Buyer API w Pythonie znajdziesz w pliku README w przykładach interfejsu API określania stawek w czasie rzeczywistym.

PHP

Oto podstawowy przykład pokazujący, jak używać interfejsu API określania stawek w czasie rzeczywistym w PHP.

Konfigurowanie zależności

Jeśli nie masz jeszcze zainstalowanego Composera, pobierz go i zainstaluj, a następnie utwórz plik composer.json z treścią podobną do tej:

{
  "description": "Authorized Buyers Real-Time Bidding API PHP Samples",
  "require": {
    "php": ">=7.2",
    "google/apiclient": "^2.0"
  },
  "require-dev": {
    "squizlabs/php_codesniffer": "3.*"
  },
  "type": "project",
  "homepage": "https://github.com/googleads/authorized-buyers-rtb-api-samples/tree/master/php",
  "license": "Apache-2.0",
  "authors": [
    {
      "name": "Google",
      "homepage": "https://github.com/googleads/authorized-buyers-rtb-api-samples/graphs/contributors"
    }
  ]
}

Na koniec uruchom to polecenie, aby zainstalować biblioteki zależności:

composer install

Konfigurowanie klienta

Utwórz obiekt Google_Client i użyj go do utworzenia instancji obiektu Google_Service_RealTimeBidding.


$client = new Google_Client();
$client->setApplicationName('Authorized Buyers Real-time Bidding API PHP Samples');

$service = new Google_Service_RealTimeBidding($client);

Konfigurowanie danych logowania

Wszystkie wywołania interfejsu API wymagają prawidłowego tokena dostępu. Skonfiguruj klienta, aby przeszedł przez proces OAuth 2.0.


$client->setAuthConfig($keyFileLocation);
$client->addScope('https://www.googleapis.com/auth/realtime-bidding');

if ($client->isAccessTokenExpired()) {
    $client->refreshTokenWithAssertion();
}

Wykonywanie operacji

Po uruchomieniu klienta do nawiązywania połączenia z interfejsem API i skonfigurowaniu OAuth 2.0 możesz go użyć do wywołania interfejsu API. Poniższy kod zwraca wszystkie kreacje danego kupującego:

$result = $service->buyers_creatives->listBuyersCreatives($buyerName, $queryParams);

print "Creatives associated with buyer account\n";
if (empty($result['creatives'])) {
    print "No creatives found\n";
    return;
} else {
    foreach ($result['creatives'] as $creative) {
        print_r($creative);
    }
}FirstApiRequest.php

Więcej informacji o korzystaniu z interfejsu Ad Exchange Buyer API w PHP znajdziesz w pliku README w przykładach interfejsu API określania stawek w czasie rzeczywistym.

.NET

Oto podstawowy przykład, który pokazuje, jak używać interfejsu API określania stawek w czasie rzeczywistym w języku C#.

Tworzenie nowego projektu
Otwórz Visual Studio Code i utwórz nowy projekt.

Dodawanie do projektu odwołań do wymaganych bibliotek

W pliku *.csproj projektu dodaj wpis PackageReference dla Google.Apis, Google.Apis.Auth, Google.Apis.Core, Google.Apis.Oauth2.v2 i Google.Apis.RealTimeBidding.v1. Może to wyglądać na przykład tak:

<ItemGroup>
  <PackageReference Include="Google.Apis" Version="1.57.0" />
  <PackageReference Include="Google.Apis.Auth" Version="1.57.0" />
  <PackageReference Include="Google.Apis.Core" Version="1.57.0" />
  <PackageReference Include="Google.Apis.Oauth2.v2" Version="1.57.0.1869" />
  <PackageReference Include="Google.Apis.Pubsub.v1" Version="1.57.0.2667" />
  <PackageReference Condition="!Exists('./Google.Apis.RealTimeBidding.v1.csproj')" Include="Google.Apis.RealTimeBidding.v1" Version="1.57.0.2680" />
  <PackageReference Include="log4net" Version="2.0.13" />
  <PackageReference Include="Microsoft.Extensions.Configuration" Version="3.1.4" />
  <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0">
    <PrivateAssets>all</PrivateAssets>
    <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
  </PackageReference>
  <PackageReference Include="Mono.Options" Version="6.12.0.148" />
  <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
</ItemGroup>

Więcej informacji o tych zależnościach znajdziesz na stronie https://www.nuget.org/packages/.

Konfigurowanie danych logowania

Wszystkie wywołania interfejsu API wymagają uwierzytelnienia. Utwórz Credentialza pomocą adresu e-mail konta usługi i pliku JSON, o których mowa powyżej.

var credentialParameters = NewtonsoftJsonSerializer.Instance
    .Deserialize<JsonCredentialParameters>(
        System.IO.File.ReadAllText(ServiceKeyFilePath));

// Create the credentials.
var credentialInitializer = new ServiceAccountCredential.Initializer(
        credentialParameters.ClientEmail)
    {
        Scopes = new[] { RealTimeBiddingService.Scope.RealtimeBidding }
    }.FromPrivateKey(credentialParameters.PrivateKey);

var oAuth2Credentials = new ServiceAccountCredential(credentialInitializer);

Tworzenie klienta dla interfejsu Real-time Bidding API

Możesz utworzyć RealTimeBiddingService:

var serviceInitializer = new BaseClientService.Initializer
    {
        HttpClientInitializer = oAuth2Credentials,
        ApplicationName = "FirstAPICall"
    };

var realtimebidding = new RealTimeBiddingService(serviceInitializer);

Wykonywanie operacji

Po uruchomieniu klienta, który ma się połączyć z interfejsem API, możesz wykonać operację. Poniższy kod zawiera listę kreacji na określonym koncie kupującego Authorized Buyers powiązanym z Twoimi danymi logowania.

BuyersResource.CreativesResource.ListRequest request =
    realtimebidding.Buyers.Creatives.List(buyerName);
request.View = BuyersResource.CreativesResource.ListRequest.ViewEnum.FULL;

IList<Creative> creatives = request.Execute().Creatives;

foreach (Creative creative in creatives)
{
    Console.WriteLine("* Creative name: {0}", creative.Name);
}FirstApiRequest.cs

Więcej informacji o korzystaniu z interfejsu Real-time Bidding API w języku C# znajdziesz w pliku README w przykładach interfejsu Real-time Bidding API.

Ruby

Oto podstawowy przykład, który pokazuje, jak używać interfejsu Real-timeReporting API w języku Ruby.

Pobieranie i instalowanie klienta Ruby interfejsu API Google
Jeśli nie masz jeszcze zainstalowanego Bundler, pobierz go i zainstaluj, a potem utwórz plik Gemfile o takiej treści:
```
source "https://rubygems.org"

ruby "2.6.0"

gem 'google-apis-pubsub_v1', '0.10.0'
gem 'google-apis-realtimebidding_v1', '~> 0.14.0'
```
Na koniec uruchom te polecenia, aby zainstalować biblioteki zależności:
```
bundle
```

Konfigurowanie danych logowania

Wszystkie wywołania interfejsu API wymagają uwierzytelnienia. Utwórz dane logowania za pomocą adresu e-mail konta usługi i pliku JSON, o których mowa powyżej.

# Create credentials using the JSON key file.
  auth_options = {
    :json_key_io => File.open(KEY_FILE, "r"),
    :scope => 'https://www.googleapis.com/auth/realtime-bidding'
  }

  oauth_credentials = Google::Auth::ServiceAccountCredentials.make_creds(
    options=auth_options
  )

Tworzenie klienta dla AdExchangeBuyer

Następnie możesz utworzyć autoryzowanego klienta kupującego Ad Exchange, korzystając z tych danych uwierzytelniających:

# Create the service and set credentials
  realtimebidding = (
    Google::Apis::RealtimebiddingV1::RealtimeBiddingService.new
  )
  realtimebidding.authorization = oauth_credentials
  realtimebidding.authorization.fetch_access_token!

Wykonywanie operacji

Po uruchomieniu klienta, który ma się połączyć z interfejsem API, możesz wykonać operację. Poniższy kod zwraca wszystkie kreacje danego kupującego.

# Call the buyers.creatives.list method to get list of creatives for given buyer.
    creatives_list = realtimebidding.list_buyer_creatives(
        BUYER_NAME, view: 'FULL')

    if creatives_list.creatives.any?
      puts "Found the following creatives for buyer '%s':" % BUYER_NAME
      creatives_list.creatives.each do |creative|
        puts "* Creative name: #{creative.name}"
      end
    else
      puts "No creatives were found that were associated with buyer '%s'" % BUYER_NAME
    endfirst_api_request.rb

Bardziej szczegółowe informacje o korzystaniu z interfejsu Real-timeReporting API w Ruby znajdziesz w pliku README w przykładach interfejsu Real-time określania stawek interfejsu API.

Ad Exchange Buyer API II

Java

/*
 * Copyright (c) 2017 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.api.services.samples.adexchangebuyer.cmdline.v2_x;

import com.google.api.client.googleapis.services.json.AbstractGoogleJsonClient;
import com.google.api.services.adexchangebuyer2.v2beta1.AdExchangeBuyerII;
import com.google.api.services.adexchangebuyer2.v2beta1.model.AbsoluteDateRange;
import com.google.api.services.adexchangebuyer2.v2beta1.model.Client;
import com.google.api.services.adexchangebuyer2.v2beta1.model.Date;
import com.google.api.services.adexchangebuyer2.v2beta1.model.FilterSet;
import com.google.api.services.adexchangebuyer2.v2beta1.model.RealtimeTimeRange;
import com.google.api.services.adexchangebuyer2.v2beta1.model.RelativeDateRange;
import com.google.api.services.samples.adexchangebuyer.cmdline.BaseSample;
import java.io.IOException;
import java.util.List;

/**
 * This sample illustrates how to retrieve all Bidder-level Filter Sets.
 */
public class GetAllBidderLevelFilterSets extends BaseSample {
  @Override
  public ClientType getClientType() {
    return ClientType.ADEXCHANGEBUYERII;
  }

  @Override
  public String getName() {
    return "Get All Bidder-level Filter Sets.";
  }

  @Override
  public String getDescription() {
    return "Lists Filter Sets associated with the given Bidder.";
  }

  @Override
  public void execute(AbstractGoogleJsonClient client) throws IOException {
    AdExchangeBuyerII adXClient = (AdExchangeBuyerII) client;
    String bidderResourceId = getStringInput("bidderResourceId", "Enter the Bidder's resource ID");
    String ownerName = String.format("bidders/%s", bidderResourceId);
    List<FilterSet> allFilterSets = adXClient.bidders().filterSets().list(ownerName).execute()
        .getFilterSets();

    if (allFilterSets != null && allFilterSets.size() > 0) {
      System.out.println("========================================");
      System.out.printf("Listing of Filter Sets associated with Bidder \"%s\"%n", ownerName);
      System.out.println("========================================");
      for (FilterSet filterSet : allFilterSets) {
        System.out.printf("* Filter Set name: %s%n", filterSet.getName());
        AbsoluteDateRange absDateRange = filterSet.getAbsoluteDateRange();
        if(absDateRange != null) {
          System.out.println("AbsoluteDateRange");
          System.out.printf("\tStart date: %s%n",
              convertDateToString(absDateRange.getStartDate()));
          System.out.printf("\tEnd date: %s%n",
              convertDateToString(absDateRange.getEndDate()));
        }
        RelativeDateRange relDateRange = filterSet.getRelativeDateRange();
        if(relDateRange != null) {
          Integer offset = relDateRange.getOffsetDays();
          System.out.println("RelativeDateRange");
          System.out.printf("\tOffset days: %s%n", offset != null ? offset : 0);
          System.out.printf("\tDuration days: %s%n", relDateRange.getDurationDays());
        }
        RealtimeTimeRange rtTimeRange = filterSet.getRealtimeTimeRange();
        if(rtTimeRange != null) {
          System.out.println("RealtimeTimeRange");
          System.out.printf("\tStart timestamp: %s%n", rtTimeRange.getStartTimestamp());
        }
        String timeSeriesGranularity = filterSet.getTimeSeriesGranularity();
        if(timeSeriesGranularity != null) {
          System.out.printf("Time series granularity: %s%n", timeSeriesGranularity);
        }
        String format = filterSet.getFormat();
        if(format != null) {
          System.out.printf("\tFormat: %s%n", format);
        }
        String environment = filterSet.getEnvironment();
        if(environment != null) {
          System.out.printf("Environment: %s%n", environment);
        }
        List<String> platforms = filterSet.getPlatforms();
        if(platforms != null) {
          System.out.println("Platforms:");
          for(String platform : platforms) {
            System.out.printf("\t%s%n", platform);
          }
        }
        List<Integer> sellerNetworkIds = filterSet.getSellerNetworkIds();
        if(filterSet.getSellerNetworkIds() != null) {
          System.out.println("Seller network IDS:");
          for(Integer sellerNetworkId : sellerNetworkIds) {
            System.out.printf("\t%d%n", sellerNetworkId);
          }
        }
      }
    } else {
      System.out.printf("No Filter Sets were found associated with Bidder \"%s\"%n", ownerName);
    }
  }

  private String convertDateToString(Date date) {
    return String.format("%d%02d%02d", date.getYear(), date.getMonth(), date.getDay());
  }
}

Python

#!/usr/bin/python
#
# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""This example lists bidder-level filter sets."""


import argparse
import os
import pprint
import sys

sys.path.insert(0, os.path.abspath('..'))

from googleapiclient.errors import HttpError
import samples_util


_OWNER_NAME_TEMPLATE = 'bidders/{bidders_resource_id}'

DEFAULT_BIDDER_RESOURCE_ID = 'ENTER_BIDDER_RESOURCE_ID_HERE'


def main(ad_exchange_buyer, owner_name):
  try:
    # Construct and execute the request.
    filter_sets = ad_exchange_buyer.bidders().filterSets().list(
        ownerName=owner_name).execute()
    print(f'Listing FilterSets for bidder: "{owner_name}".')
    pprint.pprint(filter_sets)
  except HttpError as e:
    print(e)


if __name__ == '__main__':
  parser = argparse.ArgumentParser(
      description='Creates a bidder-level filter set with the specified options'
  )
  # Required fields.
  parser.add_argument(
      '-b', '--bidder_resource_id', default=DEFAULT_BIDDER_RESOURCE_ID,
      help=('The resource ID of the bidders resource for which the filter '
            'sets were created. This will be used to construct the ownerName '
            'used as a path parameter for filter set requests. For additional '
            'information on how to configure the ownerName path parameter, '
            'see: https://developers.google.com/authorized-buyers/apis/'
            'reference/rest/v2beta1/bidders.filterSets/list'
            '#body.PATH_PARAMETERS.owner_name'))

  args = parser.parse_args()

  try:
    service = samples_util.GetService('v2beta1')
  except IOError as ex:
    print(f'Unable to create adexchangebuyer service - {ex}')
    print('Did you specify the key file in samples_util.py?')
    sys.exit(1)

  main(service, _OWNER_NAME_TEMPLATE.format(
           bidders_resource_id=args.bidder_resource_id))

PHP

<?php
/**
 * Copyright 2017 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

require_once __DIR__ . '/../../BaseExample.php';

/**
 * This example illustrates how to retrieve all Bidder-level Filter Sets.
 */
class ListBidderLevelFilterSets extends BaseExample {

  /**
   * @see BaseExample::getInputParameters()
   */
  protected function getInputParameters() {
    return [
        [
            'name' => 'bidderResourceId',
            'display' => 'Bidder Resource ID',
            'required' => true
        ]
    ];
  }

  /**
   * @see BaseExample::run()
   */
  public function run() {
    $values = $this->formValues;
    $ownerName = sprintf(
        'bidders/%s',
        $values['bidderResourceId']
    );
    $result = $this->service->bidders_filterSets
        ->listBiddersFilterSets($ownerName);
    print sprintf(
        '<h2>Listing Bidder-level Filter Sets for ownerName "%s"</h2>',
         $ownerName
    );
    if (empty($result['filterSets'])) {
      print '<p>No Bidder-level Filter Sets found.</p>';
    } else {
      foreach ($result['filterSets'] as $filterSets) {
        $this->printResult($filterSets);
      }
    }
  }

  /**
   * @see BaseExample::getClientType()
   */
  public function getClientType() {
    return ClientType::AdExchangeBuyerII;
  }

  /**
   * @see BaseExample::getName()
   */
  public function getName() {
    return 'RTB Troubleshooting: List Bidder-level Filter Sets';
  }
}

.NET

/* Copyright 2017, Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using Google.Apis.AdExchangeBuyerII.v2beta1;
using Google.Apis.AdExchangeBuyerII.v2beta1.Data;
using Google.Apis.Services;

using System;
using System.Collections.Generic;

namespace Google.Apis.AdExchangeBuyer.Examples.v2_x
{
    /// <summary>
    /// Retrieves the bidder-level filter sets for the given bidder resource ID.
    /// </summary>
    public class ListBidderLevelFilterSets : ExampleBase
    {
        /// <summary>
        /// Main method, to run this code example as a standalone application.
        /// </summary>
        /// <param name="args">The command line arguments</param>
        public static void Main(string[] args)
        {
            AdExchangeBuyerIIService service = Utilities.GetV2Service();
            ExampleBase example = new ListBidderLevelFilterSets();
            Console.WriteLine(example.Description);

            example.Run(service);
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get { return "This code example lists all bidder-level filter sets for the given " +
                    "bidder resource ID."; }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="service">An authenticated AdExchangeBuyerIIService</param>
        public override void Run(BaseClientService service)
        {
            AdExchangeBuyerIIService adXService = (AdExchangeBuyerIIService)service;
            string bidderResourceId = "INSERT_BIDDER_RESOURCE_ID_HERE";
            string ownerName = String.Format("bidders/{0}", bidderResourceId);

            ListFilterSetsResponse response = adXService.Bidders.FilterSets.List(ownerName)
                .Execute();

            Console.WriteLine("========================================\n");
            Console.WriteLine("Listing of filter sets associated with owner name \"{0}\"",
                ownerName);
            Console.WriteLine("========================================\n");

            if (response.FilterSets.Count == 0)
            {
                Console.WriteLine("No filter sets found.");
            } else
            {
                foreach (FilterSet filterSet in response.FilterSets)
                {
                    Console.WriteLine("* Name: {0}", filterSet.Name);
                    AbsoluteDateRange absDateRange = filterSet.AbsoluteDateRange;
                    if (absDateRange != null)
                    {
                        Console.WriteLine("\tAbsoluteDateRange:");
                        Date startDate = absDateRange.StartDate;
                        Console.WriteLine("\t\tStartDate:");
                        Console.WriteLine("\t\t\tYear: {0}", startDate.Year);
                        Console.WriteLine("\t\t\tMonth: {0}", startDate.Month);
                        Console.WriteLine("\t\t\tDay: {0}", startDate.Day);
                        Date endDate = absDateRange.EndDate;
                        Console.WriteLine("\t\tEndDate:");
                        Console.WriteLine("\t\t\tYear: {0}", endDate.Year);
                        Console.WriteLine("\t\t\tMonth: {0}", endDate.Month);
                        Console.WriteLine("\t\t\tDay: {0}", endDate.Day);
                    }
                    RelativeDateRange relDateRange = filterSet.RelativeDateRange;
                    if (relDateRange != null)
                    {
                        Console.WriteLine("\tRelativeDateRange:");
                        Console.WriteLine("\t\tOffsetDays: {0}", relDateRange.OffsetDays);
                        Console.WriteLine("\t\tDurationDays: {0}", relDateRange.DurationDays);
                    }
                    RealtimeTimeRange rtTimeRange = filterSet.RealtimeTimeRange;
                    if (rtTimeRange != null)
                    {
                        Console.WriteLine("\tRealtimeTimeRange:");
                        Console.WriteLine("\t\tStartTimestamp: {0}", rtTimeRange.StartTimestamp);
                    }
                    String timeSeriesGranularity = filterSet.TimeSeriesGranularity;
                    if (timeSeriesGranularity != null)
                    {
                        Console.WriteLine("\tTimeSeriesGranularity: {0}", timeSeriesGranularity);
                    }
                    IList<String> formats = filterSet.Formats;
                    if (formats != null)
                    {
                        Console.WriteLine("\tFormats:");
                        foreach (string format in formats)
                        {
                            Console.WriteLine("\t\t{0}", format);
                        }
                    }
                    String environment = filterSet.Environment;
                    if (environment != null)
                    {
                        Console.WriteLine("\tEnvironment: {0}", environment);
                    }
                    IList<string> platforms = filterSet.Platforms;
                    if (platforms != null)
                    {
                        Console.WriteLine("\tPlatforms:");
                        foreach (string platform in platforms)
                        {
                            Console.WriteLine("\t\t{0}", platform);
                        }
                    }
                    IList<int?> sellerNetworkIds = filterSet.SellerNetworkIds;
                    if (sellerNetworkIds != null)
                    {
                        Console.WriteLine("\tSellerNetworkIds:");
                        foreach (int? sellerNetworkId in sellerNetworkIds)
                        {
                            Console.WriteLine("\t\t{0}", sellerNetworkId);
                        }
                    }
                }
            }
        }

        public override ClientType getClientType()
        {
            return ClientType.ADEXCHANGEBUYERII;
        }
    }
}

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright:: Copyright 2017, Google Inc. All Rights Reserved.
#
# License:: Licensed under the Apache License, Version 2.0 (the "License");
#           you may not use this file except in compliance with the License.
#           You may obtain a copy of the License at
#
#           http://www.apache.org/licenses/LICENSE-2.0
#
#           Unless required by applicable law or agreed to in writing, software
#           distributed under the License is distributed on an "AS IS" BASIS,
#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
#           implied.
#           See the License for the specific language governing permissions and
#           limitations under the License.
#
# Lists the filter sets for a given bidder.
#
# Tags: Bidders.FilterSets.list

require 'optparse'

require_relative '../samples_util'


def list_bidder_level_filter_sets(ad_exchange_buyer, owner_name, page_size)
  begin
    response = ad_exchange_buyer.list_bidder_filter_sets(
        owner_name, page_size: page_size
    )

    unless response.filter_sets.nil?
      puts 'Found the following filter sets for bidder %s:' % owner_name
      response.filter_sets.each do |filter_set|
        puts '* Filter set name: %s' % filter_set.name
        if !filter_set.absolute_date_range.nil?
          abs_date_range = filter_set.absolute_date_range
          start_date = abs_date_range.start_date
          end_date = abs_date_range.end_date
          puts "\tAbsolute date range:"
          puts "\t\tStart date: %s-%s-%s" % [start_date.year, start_date.month,
              start_date.day]
          puts "\t\tEnd date: %s-%s-%s" % [end_date.year, end_date.month,
              end_date.day]
        end
        unless filter_set.realtime_time_range.nil?
          realtime_time_range = filter_set.realtime_time_range
          puts "\tRealtime time range:"
          puts "\t\tStart timestamp: %s" % realtime_time_range.start_timestamp
        end
        unless filter_set.relative_date_range.nil?
          relative_date_range = filter_set.relative_date_range
          puts "\tRelative date range:"
          puts "\t\tOffset days: %s" % relative_date_range.offset_days
          puts "\t\tDuration days: %s" % relative_date_range.duration_days
        end
        unless filter_set.time_series_granularity.nil?
          puts "\tTime series granularity: %s" %
              filter_set.time_series_granularity
        end
        unless filter_set.format.nil?
          puts "\tFormat: %s" % filter_set.format
        end
        unless filter_set.environment.nil?
          puts "\tEnvironment: %s" % filter_set.environment
        end
        unless filter_set.platforms.nil?
          puts "\tPlatforms: %s" % filter_set.platforms.inspect
        end
        unless filter_set.seller_network_ids.nil?
          puts "\tSeller network IDs: %s" %
              filter_set.seller_network_ids.inspect
        end
      end
    else
      puts 'No filter sets found for bidder %s.' % owner_name
    end
  rescue Google::Apis::ServerError => e
    raise "The following server error occured:\n%s" % e.message
  rescue Google::Apis::ClientError => e
    raise "Invalid client request:\n%s" % e.message
  rescue Google::Apis::AuthorizationError => e
    raise "Authorization error occured:\n%s" % e.message
  end
end


if __FILE__ == $0
  begin
    # Retrieve the service used to make API requests.
    service = get_service(ADEXCHANGEBUYER_V2BETA1)
  rescue ArgumentError => e
    raise 'Unable to create service, with error message: %s' % e.message
  rescue Signet::AuthorizationError => e
    raise ('Unable to create service, was the KEY_FILE in samples_util.rb ' +
           'set? Error message: %s') % e.message
  end

  # Set options and default values for fields used in this example.
  options = [
    Option.new(
      'bidder_resource_id',
      ('The resource ID of the bidders resource for which the filter ' +
       'sets were created. This will be used to construct the ownerName ' +
       'used as a path parameter for filter set requests. For additional ' +
       'information on how to configure the ownerName path parameter, ' +
       'see: https://developers.google.com/authorized-buyers/apis/reference/' +
       'rest/v2beta1/bidders.filterSets/list#body.PATH_PARAMETERS.owner_name'),
      :short_alias => 'b', :required => true,
      :default_value => nil  # Insert default value here.
    ),
    Option.new(
      'max_page_size',
      'The maximum number of entries returned on one result page.',
      :type => Integer, :short_alias => 'm', :required => true,
      :default_value => MAX_PAGE_SIZE
    )
  ]

  # Parse options.
  parser = Parser.new(options)
  opts = parser.parse(ARGV)

  owner_name = 'bidders/%s' % opts['bidder_resource_id']

  list_bidder_level_filter_sets(service, owner_name, opts['max_page_size'])
end

Dalsze kroki

Przeczytaj przewodnik wprowadzający, aby dowiedzieć się więcej o przykładach i dostępnych opcjach tworzenia rozwiązania.
Po skonfigurowaniu biblioteki klienta spróbuj rozszerzyć przykłady kodu, aby dostosować je do swoich potrzeb.
Aby dowiedzieć się więcej o interfejsie API, zapoznaj się z dokumentacją referencyjną wersji, z której korzystasz.
Jeśli potrzebujesz pomocy, odwiedź forum.
Jeśli Twoja aplikacja ma określać stawki w czasie rzeczywistym, zapoznaj się z dokumentacją dotyczącą protokołu RTB.
Przejrzyj wskazówki dotyczące skuteczności.

Weź udział w ankiecie

Pomóż nam ulepszyć tę dokumentację: powiedz nam, co działało, a co nie, wypełniając krótką ankietę.