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

Zarządzaj aktywnością klientów

Aby zmienić state w Client Wartość state jest ustawiona na ACTIVE w przypadku nowych zasobów Client automatycznie po zaakceptowaniu przez klienta zaproszenie.

Możesz ustawić state na INACTIVE dla określonego Client, aby unieważnić dostęp do interfejsu Authorized Buyers Marketplace;

Dezaktywuj

Możesz dezaktywować aktywną usługę Client za pomocą buyers.clients.deactivate. .

Tej metody możesz użyć na przykład wtedy, gdy chcesz wyłączyć dostęp do interfejsu Authorized Buyers Marketplace;

Gdy dezaktywujesz usługę Client, traci ona dostęp do interfejsu użytkownika. Nadal możesz wyświetlać i negocjują oferty pakietowe w imieniu klientów, którzy zostali zdezaktywowani.

Z przykładu poniżej dowiesz się, jak dezaktywować Client za pomocą Metoda deactivate.

REST

Żądanie

POST https://authorizedbuyersmarketplace.googleapis.com/v1/buyers/12345678/clients/837492105:deactivate?alt=json
Authorization: Bearer ACCESS_TOKEN
Content-Type: application/json

Odpowiedź

{
 "name": "buyers/12345678/clients/837492105",
 "role": "CLIENT_DEAL_VIEWER",
 "state": "INACTIVE",
 "displayName": "Demo Viewer 1",
 "sellerVisible": true
}

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>
    /// Deactivates client for the given buyer account ID and client ID.
    /// </summary>
    public class DeactivateClients : ExampleBase
    {
        private AuthorizedBuyersMarketplaceService mkService;

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

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

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

            string accountId = null;
            string clientId = null;

            OptionSet options = new OptionSet {
                "Deactivate a client with the given buyer account ID and client 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 " +
                     "was created. This will be used to construct the name used as a path " +
                     "parameter for the clients.activate request."),
                    a => accountId = a
                },
                {
                    "c|client_id=",
                    ("[Required] The resource ID of the buyers.clients resource for which the " +
                     "client was created. This will be used to construct the name used as a " +
                     "path parameter for the clients.activate request."),
                    c => clientId = c
                },
            };

            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 optional arguments.
            parsedArgs["account_id"] = accountId;
            parsedArgs["client_id"] = clientId;
            // 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 clientId = (string) parsedArgs["client_id"];
            string name = $"buyers/{accountId}/clients/{clientId}";

            BuyersResource.ClientsResource.DeactivateRequest request =
                mkService.Buyers.Clients.Deactivate(new DeactivateClientRequest(), name);
            Client response = null;

            Console.WriteLine("Deactivating client with name: {0}", name);

            try
            {
                response = request.Execute();
            }
            catch (Exception exception)
            {
                throw new ApplicationException(
                    $"Marketplace 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.authorizedbuyersmarketplace.v1.model.DeactivateClientRequest;
import com.google.api.services.samples.authorizedbuyers.marketplace.Utils;
import java.io.IOException;
import java.security.GeneralSecurityException;
import net.sourceforge.argparse4j.ArgumentParsers;
import net.sourceforge.argparse4j.inf.ArgumentParser;
import net.sourceforge.argparse4j.inf.ArgumentParserException;
import net.sourceforge.argparse4j.inf.Namespace;

/**
 * This sample illustrates how to deactivate a client for the given buyer account ID and client ID.
 */
public class DeactivateClients {

  public static void execute(AuthorizedBuyersMarketplace marketplaceClient, Namespace parsedArgs) {
    Long accountId = parsedArgs.getLong("account_id");
    Long clientId = parsedArgs.getLong("client_id");
    String name = String.format("buyers/%d/clients/%d", accountId, clientId);

    Client client = null;

    try {
      client =
          marketplaceClient
              .buyers()
              .clients()
              .deactivate(name, new DeactivateClientRequest())
              .execute();
    } catch (IOException ex) {
      System.out.printf("Marketplace API returned error response:%n%s", ex);
      System.exit(1);
    }

    System.out.printf(
        "Deactivated Client with ID \"%s\" for buyer account ID '%d':%n", clientId, accountId);
    Utils.printClient(client);
  }

  public static void main(String[] args) {
    ArgumentParser parser =
        ArgumentParsers.newFor("DeactivateClients")
            .build()
            .defaultHelp(true)
            .description(("Deactivate a client for the given buyer account ID and client ID."));
    parser
        .addArgument("-a", "--account_id")
        .help(
            "The resource ID of the buyers resource under which the client was created. This "
                + "will be used to construct the parent used as a path parameter for the "
                + "clients.deactivate request.")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-c", "--client_id")
        .help(
            "The resource ID of the buyers.clients resource for which the client was created "
                + "This will be used to construct the name used as a path parameter for the "
                + "clients.deactivate request.")
        .required(true)
        .type(Long.class);

    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.

"""Deactivates client with the given with the given account ID and client ID."""


import argparse
import os
import pprint
import sys

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

from googleapiclient.errors import HttpError

import util


_CLIENTS_NAME_TEMPLATE = 'buyers/%s/clients/%s'

DEFAULT_BUYER_RESOURCE_ID = 'ENTER_BUYER_RESOURCE_ID_HERE'
DEFAULT_CLIENT_RESOURCE_ID = 'ENTER_CLIENT_RESOURCE_ID_HERE'


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

    print(f'Deactivate client "{client_id}" for account "{account_id}":')
    try:
        # Construct and execute the request.
        response = marketplace.buyers().clients().deactivate(
            name=_CLIENTS_NAME_TEMPLATE % (account_id, client_id)).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)

    parser = argparse.ArgumentParser(
        description=('Deactivate a client for the given buyer account ID and '
                     'client 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 was created. This will be used to construct the '
              'name used as a path parameter for the clients.deactivate '
              'request.'))
    parser.add_argument(
        '-c', '--client_id', default=DEFAULT_CLIENT_RESOURCE_ID,
        help=('The resource ID of the buyers.clients resource for which the '
              'client was created. This will be used to construct the '
              'name used as a path parameter for the clients.deactivate '
              'request.'))

    main(service, parser.parse_args())

Aktywuj ponownie

Możesz ponownie aktywować nieaktywne Client, używając: buyers.clients.activate. .

Za pomocą tej metody możesz na przykład przywrócić dostęp do interfejsu Authorized Buyers Marketplace po jego dezaktywacji.

Z przykładu poniżej dowiesz się, jak aktywować Client za pomocą Metoda activate.