Se usó la API de Cloud Translation para traducir esta página.

Crea y actualiza clientes

Cree un cliente

Puedes usar el método buyers.clients.create para crear un Client que represente a uno de tus clientes.

Estas son algunas de las acciones que puedes realizar con un recurso Client:

Haz referencia al cliente en las negociaciones con los publicadores.
Suscribir al cliente a paquetes de subasta
Administra el acceso del cliente a la IU de Marketplace de Authorized Buyers.

En el siguiente ejemplo, se muestra cómo puedes crear una Client nueva con el método create.

REST

Solicitud

POST https://authorizedbuyersmarketplace.googleapis.com/v1/buyers/12345678/clients?alt=json
Authorization: Bearer ACCESS_TOKEN
Content-Type: application/json
{
 "displayName": "Demo Approver 2",
 "role": "CLIENT_DEAL_APPROVER",
 "sellerVisible": false
}

Respuesta

{
 "name": "buyers/12345678/clients/873721984",
 "role": "CLIENT_DEAL_APPROVER",
 "state": "ACTIVE",
 "displayName": "Demo Approver 2"
}

C#

/* 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 Mono.Options;

using System;
using System.Collections.Generic;

namespace Google.Apis.AuthorizedBuyersMarketplace.Examples.v1.Buyers.Clients
{
    /// <summary>
    /// Creates a client for the given buyer account ID.
    /// </summary>
    public class CreateClients : ExampleBase
    {
        private AuthorizedBuyersMarketplaceService mkService;

        /// <summary>
        /// Constructor.
        /// </summary>
        public CreateClients()
        {
            mkService = Utilities.GetAuthorizedBuyersMarketplaceService();
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get => "This code example creates a client for the given buyer account ID.";
        }

        /// <summary>
        /// Parse specified arguments.
        /// </summary>
        protected override Dictionary<string, object> ParseArguments(List<string> exampleArgs) {
            string[] requiredOptions = new string[] {"account_id"};
            bool showHelp = false;

            string accountId = null;
            string displayName = null;
            string partnerClientId = null;
            string role = null;
            string sellerVisible = null;

            OptionSet options = new OptionSet {
                "Creates a client for the given buyer account ID.",
                {
                    "h|help",
                    "Show help message and exit.",
                    h => showHelp = h != null
                },
                {
                    "a|account_id=",
                    ("[Required] The resource ID of the buyers resource under which the " +
                     "client is to be created. This will be used to construct the name used as " +
                     "a path parameter for the clients.create request."),
                    a => accountId = a
                },
                {
                    "d|display_name=",
                    ("The display name shown to publishers. Must be unique for clients without " +
                     "partnerClientId specified. The maximum length allowed is 255 characters. " +
                     "By default, this sample will specify a generated name."),
                    d => displayName = d
                },
                {
                    "p|partner_client_id=",
                    ("Arbitrary unique identifier provided by the buyer. This field can be used " +
                     "to associate a client with an identifier in the namespace of the buyer. If " +
                     "present, it must be unique across all the clients. By default, this sample " +
                     "will not specify a partnerClientId."),
                    p => partnerClientId = p
                },
                {
                    "r|role=",
                    ("The role assigned to the client, which determines its permissions. By " +
                     "default, this will be set to CLIENT_DEAL_VIEWER. For more details on how " +
                     "to interpret the different roles, see:" +
                     "https://developers.google.com/authorized-buyers/apis/marketplace/" +
                     "reference/rest/v1/buyers.clients#ClientRole"),
                    r => role = r
                },
                {
                    "s|seller_visible=",
                    ("A boolean value indicating whether the client will be visible to " +
                     "publishers. By default, this will be set to false."),
                    s => sellerVisible = s
                },
            };

            List<string> extras = options.Parse(exampleArgs);
            var parsedArgs = new Dictionary<string, object>();

            // Show help message.
            if (showHelp == true)
            {
                options.WriteOptionDescriptions(Console.Out);
                Environment.Exit(0);
            }
            // Set arguments.
            parsedArgs["account_id"] = accountId;
            parsedArgs["display_name"] = displayName ?? String.Format(
                "Test_Client_{0}",
                System.Guid.NewGuid());
            parsedArgs["partner_client_id"] = partnerClientId;
            parsedArgs["role"] = role ?? "CLIENT_DEAL_VIEWER";

            if (sellerVisible != null)
            {
                parsedArgs["seller_visible"] = Boolean.Parse(sellerVisible);
            } else
            {
                parsedArgs["seller_visible"] = false;
            }

            // Validate that options were set correctly.
            Utilities.ValidateOptions(options, parsedArgs, requiredOptions, extras);

            return parsedArgs;
        }

        /// <summary>
        /// Run the example.
        /// </summary>
        /// <param name="parsedArgs">Parsed arguments for the example.</param>
        protected override void Run(Dictionary<string, object> parsedArgs)
        {
            string accountId = (string) parsedArgs["account_id"];
            string parent = $"buyers/{accountId}";

            Client newClient = new Client()
            {
                DisplayName = (string) parsedArgs["display_name"],
                Role = (string) parsedArgs["role"],
                SellerVisible = (Boolean) parsedArgs["seller_visible"]
            };

            string partnerClientId = (string) parsedArgs["partner_client_id"];
            if (partnerClientId != null)
            {
                newClient.PartnerClientId = partnerClientId;
            }

            BuyersResource.ClientsResource.CreateRequest request =
                mkService.Buyers.Clients.Create(newClient, parent);
            Client response = null;

            Console.WriteLine("Creating client for buyer: {0}", parent);

            try
            {
                response = request.Execute();
            }
            catch (Exception exception)
            {
                throw new ApplicationException(
                    $"Real-time Bidding API returned error response:\n{exception.Message}");
            }

            Utilities.PrintClient(response);
        }
    }
}

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.buyers.clients;

import com.google.api.services.authorizedbuyersmarketplace.v1.AuthorizedBuyersMarketplace;
import com.google.api.services.authorizedbuyersmarketplace.v1.model.Client;
import com.google.api.services.samples.authorizedbuyers.marketplace.Utils;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.UUID;
import net.sourceforge.argparse4j.ArgumentParsers;
import net.sourceforge.argparse4j.inf.ArgumentParser;
import net.sourceforge.argparse4j.inf.ArgumentParserException;
import net.sourceforge.argparse4j.inf.Namespace;

/** Creates a client for the given buyer account ID. */
public class CreateClients {

  public static void execute(AuthorizedBuyersMarketplace marketplaceClient, Namespace parsedArgs) {
    Long accountId = parsedArgs.getLong("account_id");

    String parentBuyerName = String.format("buyers/%d", accountId);

    Client newClient = new Client();
    newClient.setDisplayName(parsedArgs.getString("display_name"));
    newClient.setRole(parsedArgs.getString("role"));
    newClient.setSellerVisible(parsedArgs.getBoolean("seller_visible"));

    String partnerClientId = parsedArgs.getString("partner_client_id");
    if (partnerClientId != null) {
      newClient.setPartnerClientId(partnerClientId);
    }

    Client client = null;
    try {
      client = marketplaceClient.buyers().clients().create(parentBuyerName, newClient).execute();
    } catch (IOException ex) {
      System.out.printf("Marketplace API returned error response:%n%s", ex);
      System.exit(1);
    }

    System.out.printf("Created client for buyer Account ID '%d':%n", accountId);
    Utils.printClient(client);
  }

  public static void main(String[] args) {
    ArgumentParser parser =
        ArgumentParsers.newFor("CreateClients")
            .build()
            .defaultHelp(true)
            .description(("Creates a client for the given buyer account ID."));
    parser
        .addArgument("-a", "--account_id")
        .help("The resource ID of the buyers resource under which the client is to be created. ")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-d", "--display_name")
        .help(
            "Display name shown to publishers. Must be unique for clients without "
                + "partnerClientId specified. Maximum length of 255 characters is allowed. By "
                + "default, this sample will specify a generated name.")
        .type(String.class)
        .setDefault(String.format("TEST_CLIENT_%s", UUID.randomUUID()));
    parser
        .addArgument("-p", "--partner_client_id")
        .help(
            "Arbitrary unique identifier provided by the buyer. This field can be used to associate"
                + " a client with an identifier in the namespace of the buyer. If present, it must"
                + " be unique across all the clients. By default, this sample will not specify a"
                + "partnerClientId.")
        .type(String.class);
    parser
        .addArgument("-r", "--role")
        .help(
            "The role assigned to the client, which determines its permissions. By default, this"
                + " will be set to CLIENT_DEAL_VIEWER. For more details on how to interpret the"
                + " different roles, see: "
                + "https://developers.google.com/authorized-buyers/apis/marketplace/reference/rest/v1/buyers.clients#ClientRole")
        .type(String.class)
        .setDefault("CLIENT_DEAL_VIEWER");
    parser
        .addArgument("-s", "--seller_visible")
        .help(
            "Whether the client will be visible to publishers. By default, this sample will "
                + "set this to false.")
        .type(Boolean.class)
        .setDefault(false);

    Namespace parsedArgs = null;
    try {
      parsedArgs = parser.parseArgs(args);
    } catch (ArgumentParserException ex) {
      parser.handleError(ex);
      System.exit(1);
    }

    AuthorizedBuyersMarketplace client = null;
    try {
      client = Utils.getMarketplaceClient();
    } catch (IOException ex) {
      System.out.printf("Unable to create Marketplace API service:%n%s", ex);
      System.out.println("Did you specify a valid path to a service account key file?");
      System.exit(1);
    } catch (GeneralSecurityException ex) {
      System.out.printf("Unable to establish secure HttpTransport:%n%s", ex);
      System.exit(1);
    }

    execute(client, parsedArgs);
  }
}

Python

#!/usr/bin/python
#
# Copyright 2021 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.

"""Creates a client for the given buyer account ID."""


import argparse
import os
import pprint
import sys
import uuid

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

from googleapiclient.errors import HttpError
import util


_BUYER_NAME_TEMPLATE = 'buyers/%s'

DEFAULT_BUYER_RESOURCE_ID = 'ENTER_BUYER_RESOURCE_ID_HERE'


def main(marketplace, args):
    account_id = args.account_id

    client = {
        'displayName': args.display_name,
        'role': args.role,
        'sellerVisible': args.seller_visible
    }

    partner_client_id = args.partner_client_id
    if partner_client_id:
        client['partnerClientId'] = partner_client_id

    print(f'Creating client for buyer account ID "{account_id}":')
    try:
        # Construct and execute the request.
        response = (marketplace.buyers().clients().create(
            parent=_BUYER_NAME_TEMPLATE % account_id, body=client).execute())
    except HttpError as e:
        print(e)
        sys.exit(1)

    pprint.pprint(response)


if __name__ == '__main__':
    try:
        service = util.get_service(version='v1')
    except IOError as ex:
        print(f'Unable to create marketplace service - {ex}')
        print('Did you specify the key file in util.py?')
        sys.exit(1)

    def valid_role(value):
        valid_roles = (
            'CLIENT_DEAL_VIEWER', 'CLIENT_DEAL_VIEWER',
            'CLIENT_DEAL_NEGOTIATOR', 'CLIENT_DEAL_APPROVER')

        upper_input = value.upper()

        if upper_input in valid_roles:
            return upper_input
        else:
            raise ValueError(
                f'Invalid role specified. Must be one of: {valid_roles}')

    def valid_bool(value):
        upper_input = value.upper()

        if upper_input == 'TRUE':
            return True
        elif upper_input == 'FALSE':
            return False
        else:
            raise ValueError(
                'Invalid value specified. Must be a boolean input.')

    parser = argparse.ArgumentParser(
        description='Creates a client for the given buyer account ID.')

    # Required fields.
    parser.add_argument(
        '-a', '--account_id', default=DEFAULT_BUYER_RESOURCE_ID,
        help=('The resource ID of the buyers resource under which the '
              'client is to be created.'))
    # Optional fields.
    parser.add_argument(
        '-n', '--display_name', default='Test Client #%s' % uuid.uuid4(),
        help=('The display name shown to publishers. Must be unique for '
              'clients without partnerClientId specified. The maximum length '
              'allowed is 255 characters. By default, this sample will '
              'specify a generated name.'))
    parser.add_argument(
        '-p', '--partner_client_id', default=None,
        help=('Arbitrary unique identifier provided by the buyer. This field '
              'can be used to associate a client with an identifier in the '
              'namespace of the buyer. If present, it must be unique across '
              'all the clients. Be default, this sample will not specify a '
              'partnerClientId.'))
    parser.add_argument(
        '-r', '--role', default='CLIENT_DEAL_VIEWER', type=valid_role,
        help=('The role assigned to the client, which determines its '
              'permissions. By default, this will be set to '
              'CLIENT_DEAL_VIEWER. For more details on how to interpret the '
              'different roles, see: https://developers.google.com/'
              'authorized-buyers/apis/marketplace/reference/rest/v1/'
              'buyers.clients#ClientRole'))
    parser.add_argument(
        '-s', '--seller_visible', default=False, type=valid_bool,
        help=('Whether the client will be visible to publishers. By default, '
              'this sample will set this to False.'))

    main(service, parser.parse_args())

Aplicar un parche a un cliente

Puedes usar el método buyers.clients.patch para actualizar un Client existente. Por ejemplo, puedes usar patch para actualizar displayName. En el siguiente ejemplo, se muestra cómo actualizar un Client con el método patch.