Rozpocznij

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

Java

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

1. 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>
     

2. 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);
   }

3. 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();

4. 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.

1. Pobieranie i instalowanie klienta interfejsu Google API w Pythonie

   Przykład użycia pip:

   $ pip install --upgrade google-api-python-client

2. 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])

3. 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)

4. 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.

1. 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

2. 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);

3. 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();
   }

4. 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#.

1. Tworzenie nowego projektu

   Otwórz Visual Studio Code i utwórz nowy projekt.

2. 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/.

3. 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);

4. 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);

5. 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.

1. 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

2. 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
     )

3. 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!

4. 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
       end
   first_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.

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