Mulai

/*
 * 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());
  }
}

#!/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
/**
 * 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';
  }
}

/* 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;
        }
    }
}

#!/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