Autorização da API

Use o OAuth 2.0 para autorizar seu aplicativo ao acessar as APIs de hotéis.

Configuração do OAuth 2.0

O OAuth 2.0 exige que você se identifique ao usar uma conta de serviço associados à sua Conta do Google. A conta de serviço envia seus dados em troca de um token de acesso do OAuth 2.0. Você pode então usar esse token chamadas para as APIs de hotéis para dados somente leitura, como preços, hotéis e dados do relatório de diagnóstico sobre seu feed de preços para hotéis.

Os tokens de acesso são válidos por uma hora (3.600 segundos).

Se você já implementou o Systrace, a abordagem do OAuth 2.0 será semelhante, com as seguintes diferenças:

• Seu aplicativo usa uma conta de serviço do Google para acessar a API.
• Você transmite um token de acesso do OAuth 2.0 no cabeçalho HTTP Authorization quando chamadas para APIs.

Para configurar sua conta para usar o OAuth 2.0 com o Travel Partner API, siga estas etapas:

1. Criar um novo projeto no Google Developers Console (DevConsole)

2. Ativar o acesso a Travel Partner API para o novo projeto

3. Criar uma conta de serviço e as credenciais dela

4. Permitir que sua conta de serviço acesse os dados do hotel

Cada uma dessas etapas é descrita nas seções a seguir.

Etapa 1: criar um novo projeto no DevConsole

O Google Developers Console ("DevConsole") é a experiência do desenvolvedor do Google para gerenciar e visualizar dados de tráfego, autenticação e informações de faturamento para as APIs do Google que seus projetos usam.

No DevConsole, um projeto é um conjunto de configurações, credenciais e metadados sobre os aplicativos em que você está trabalhando que usa as APIs Google Developer e os recursos do Google Cloud.

O DevConsole é onde você gerencia esses aspectos do seu projeto, como gerar credenciais de API, ativar APIs e gerenciar a equipe e o faturamento informações associadas ao seu projeto.

Para criar um novo projeto no DevConsole:

1. Faça login na sua Conta do Google/Gmail.

2. Abra o Google Developer Console. Se este for seu primeiro projeto, a visualização principal exibirá uma botão CREATE PROJECT simples:

   

3. Clique no botão CRIAR PROJETO. O DevConsole exibe a Caixa de diálogo New Project:

   

   Digite um nome amigável para seu novo projeto em Nome do projeto. campo de entrada. Abaixo do campo, o DevConsole gera um ID de projeto para você, garantindo que o ID seja único em todos os projetos. Por exemplo, se você digite "My New Project", o DevConsole atribuirá um ID como my-new-project-266022:

4. Clique no botão Criar para criar seu novo projeto.

5. Use o menu de navegação para selecionar APIs e Serviços > Painel de controle.

   

   A imagem abaixo mostra o menu de navegação no canto superior esquerdo o DevConsole. O Painel do projeto vai aparecer:

   

Para mais informações, consulte Gerenciar projetos na página do App Engine.

Quando você cria um novo projeto, ele ainda não tem APIs associadas a ele. Na na próxima etapa, você vai ativar o Travel Partner API para o novo projeto.

Etapa 2: ativar o Travel Partner API para o novo projeto

Para usar as APIs de hotel, ative Travel Partner API no seu novo projeto no DevConsole.

Para ativar as APIs de hotel no novo projeto:

1. Vá para a visualização Painel do seu projeto, conforme descrito acima.

2. Clique em Ativar APIs e serviços. Isso mostra a mensagem de boas-vindas da biblioteca de APIs página.

3. No campo de pesquisa, comece a digitar Travel Partner API. O Console de APIs do Google exibe uma lista de APIs que correspondem ao que você digitou.

4. Clique em Travel Partner API na tabela de APIs correspondentes. DevConsole exibe uma descrição sobre a API.

5. Clique no botão Ativar API para ativar esta API no projeto.

Para mais informações, consulte Ativar e desativar APIs do Google.

As APIs Hotel agora estão ativadas para o novo projeto da sua Conta do Google.

A próxima etapa é criar uma conta de serviço e gerar chaves para ela.

Etapa 3: criar uma conta de serviço e gerar as credenciais

As contas de serviço são usadas por interações de servidor para servidor, como as entre um aplicativo da Web e os dados do hotel.

Para criar e configurar uma conta de serviço, faça o seguinte:

1. Na visualização principal do Console de APIs do Google, clique em Credenciais no no menu de navegação à esquerda. O DevConsole mostra a visualização Credenciais.

   A visualização Credenciais mostra os IDs do cliente e as credenciais das suas projeto. Seu aplicativo usará o ID do cliente ao solicitar uma Token de acesso do OAuth 2.0. Novos projetos não terão clientes ou credenciais ainda.

2. Clique no link Credenciais em APIs e serviços.

3. Clique no botão Criar credenciais e selecione Chave da conta de serviço no menu suspenso. A visualização Criar chave da conta de serviço é exibida.

4. No menu suspenso Conta de serviço, selecione Nova conta de serviço.

5. Insira o nome e o ID da conta de serviço.

   O nome pode ser o que você quiser, mas o ID da conta precisa ser exclusivo em todos os projetos. O DevConsole gerará um ID de conta exclusivo para você, com base no nome inserido.

6. Selecione P12 para o tipo de chave, conforme mostrado abaixo. O P12 é obrigatório.

   

7. Clique no botão Criar. O DevConsole gera um par de chaves privada/pública para seu projeto. A chave privada é salva no local padrão seu navegador armazena os downloads. É necessário fazer o download .p12 (binário), e não .json.

   Você usa a chave privada nos seus scripts ou em outros aplicativos que acessam o Travel Partner API.

   O DevConsole exibe o aviso a seguir quando termina de gerar a chaves:

   

8. Clique no botão OK, entendi. O DevConsole retorna você ao Credenciais. Para confirmar os detalhes da sua conta de serviço e ver as contas de serviço associadas ao seu projeto, clique em Gerenciar contas de serviço nessa visualização.

   A conta de serviço agora tem as seguintes credenciais associadas a ela:

   • ID do cliente:um identificador exclusivo usado pelo seu aplicativo ao solicitando um token de acesso do OAuth 2.0.
   • Endereço de e-mail: um endereço de e-mail gerado para a conta de serviço, em o formulário "account_name@account_name.google.com.iam.gserviceaccount.com".
   • Impressões digitais de certificado:o ID da chave privada que você baixado.

Para obter mais informações, consulte Usar o OAuth 2.0 para servidor para Aplicativos de servidor.

Etapa 4: conceder à conta de serviço acesso aos seus dados da Central para Hotéis

A etapa final é conceder à nova conta de serviço acesso aos seus Central para Hotéis. A conta de serviço é identificada pelo endereço de e-mail gerado que que você criou na etapa anterior. Você concede acesso a essa conta usando as configurações de compartilhamento da Central para Hotéis.

Para conceder a uma conta de serviço acesso aos seus dados da Central para Hotéis, faça o seguinte:

Se você não tiver o acesso adequado para adicionar usuários à conta, entre em contato com o da equipe de Hotéis do Google usando o formulário de contato e solicite a configuração da propriedade para sua conta. Você pode solicitar que um ou mais e-mails sejam enviados a um proprietário. Para mais informações sobre o acesso à Central para Hotéis, consulte Vincular a Central para Hotéis e Google Ads.

1. Em uma nova janela do navegador, abra a Central para Hotéis.

2. No banner da Central para Hotéis do Google, clique no ícone "Adicionar usuário" para abrir. a caixa de diálogo de compartilhamento.

   

3. No campo Adicionar mais pessoas, digite o endereço de e-mail do serviço. que você quer adicionar à Central para Hotéis.

4. Mantenha a opção Notificar pessoas selecionada.

5. No menu suspenso, selecione Gerenciar.

6. Clique no botão Convidar.

7. Depois de adicionar usuários à Central para Hotéis, sua conta de serviço vai ser o acesso à API será ativado em cerca de 24 horas.

Depois que o Google notificar você de que o acesso à API está ativado para seu serviço você poderá acessar a API com OAuth.

Como usar o OAuth 2.0

Para acessar a API, seu aplicativo deve se identificar para o Google com o o endereço de e-mail gerado e a chave privada da conta de serviço. do Google o mecanismo de autenticação troca essa chave por um token de acesso do OAuth 2.0 que você transmite o cabeçalho Authorization nas chamadas de API do seu app.

Os tokens de acesso, também conhecidos como tokens do portador, fazem parte do OAuth 2.0 padrão. A sintaxe para especificar um token de acesso em um cabeçalho HTTP é:

Authorization: Bearer *oauth2_access_token*

O exemplo a seguir mostra uma amostra de cabeçalhos HTTP de uma solicitação que acessa o API Reports:

GET /travelpartner/v2.0/42000042/reports/top_opportunity_7_day HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer nd42.fdLSKkljD98344444444444lSDF42fdLSKkljD98344444444444lSDF42
Cache-Control: no-cache

Para gerar um token de acesso, crie um aplicativo em qualquer linguagem que você escolher. O exemplo a seguir gera o token no Python. Você pode usar isso token nas solicitações cabeçalhos Authorization ao acessar o Travel Partner API.

#!/usr/bin/python2.7
#
""" Sample code to get an auth header that you can use in your HTTP requests
    1. Please see https://developers.google.com/api-client-library/python/start/installation
       to download and install the google-api-python-client package.
    2. Edit lines below marked _SERVICE_ACCOUNT, _KEY_FILE,  _PARTNER_NAME,
       and _API_VERSION.
    3. Run the program using: "python sample.py". The app returns the value that
       you use for the Authorization header's Bearer token in your request.
    4. Copy the token and use it in requests to the Travel Partner API.
       For example (2.0):
       https://www.googleapis.com/travelpartner/2.0/42000042/reports/budget
       For example (1.x):
       https://www.googleapis.com/travelpartner/1.2/reports?report_type=BUDGET
"""
import httplib2
import json
import os
import sys
import urllib

HAS_CRYPTO = False

from apiclient import discovery
from oauth2client.client import flow_from_clientsecrets
try:
  # Some systems may not have OpenSSL installed so can't use SignedJwtAssertionCredentials.
  from oauth2client.client import SignedJwtAssertionCredentials
  HAS_CRYPTO = True
except ImportError:
  print "Unable to import SignedJwtAssertionCredentials"

from oauth2client import tools
from oauth2client.file import Storage

# Authorization scope for our requests (do not change)
_DEFAULT_APISCOPE = 'https://www.googleapis.com/auth/travelpartner'

# Use the service account you set up in the Google Developers Platform.
# It will be of the form "gsaccount_name@project_name.google.com.iam.gserviceaccount.com".
_SERVICE_ACCOUNT = ('myserviceaccount@my-hotel-project.google.com.iam.gserviceaccount.com')

# Set this to the full path to your service account's private binary .p12 key file
# that you downloaded from the Google Developer's Console and stored in a secure place.
# DO NOT use the json version of the certificate.
_KEY_FILE = '../mylocaldir/api-keys/8482bb2bdb08.p12'

# Set this to the case-sensitive "Partner Key", NOT the account
# name in the Hotel Ads Center or the numeric partner ID.
# Check with your TAM if you do not know your "Partner Key" name.
_PARTNER_NAME = 'testpartner2'

class HotelAdsAPIConnection(object):
  def __init__(self, service_account=_SERVICE_ACCOUNT, key=_KEY_FILE, partner=_PARTNER_NAME):
    self.key_file = key
    self.account = service_account
    self.partner = partner

  def InitializeCredentials(self, scope):
    '''Get credentials for use in API requests.
    Generates service account credentials if the key file is present,
    and regular user credentials if the file is not found.
    '''
    if os.path.exists(self.key_file):
      if not HAS_CRYPTO:
        raise Exception("Unable to use cryptographic functions "
                        + "Try installing OpenSSL")
      with open (self.key_file, 'rb') as file:
        key = file.read();
      creds = SignedJwtAssertionCredentials(self.account, key, scope)
      self.credentials = creds

  def authorize(self):
    '''Construct a HTTP client that uses the supplied credentials.'''
    return credentials.authorize(httplib2.Http())

  def print_creds(self):
    '''Prints the Authorization header to use in HTTP requests.'''
    cred_dict = json.loads(self.credentials.to_json())

    if 'access_token' in cred_dict:
      print 'Authorization: Bearer %s' % (cred_dict['access_token'],)
    else:
      print 'creds: %s' % (cred_dict,)

  def GetConnection(self):
    http = httplib2.Http()
    self.credentials.refresh(http)
    http = self.credentials.authorize(http)
    self.print_creds()
    return http

def main(args):
  # Create an instance of the HotelAdsAPIConnection inner class
  api = HotelAdsAPIConnection()

  # Generate credentials
  api.InitializeCredentials(_DEFAULT_APISCOPE)

  # Output the Authorization header to use in HTTP requests
  api.GetConnection()

if __name__ == "__main__":
    main(sys.argv)</pre>

Ao desenvolver seu aplicativo, siga as práticas recomendadas para usar chaves de API com segurança.

O script Python de amostra gera um portador do cabeçalho Authorization token, como mostra o exemplo a seguir:

$ python sample.py
Authorization: Bearer ya29.42424242sample_420icu8122KSvoh4T42cRoG3rW1lc0Q
$

Use o valor do token em suas solicitações. Ele é bom por uma hora depois de gerá-la.

Solução de problemas

Está com problemas? Uma verificação rápida dos itens a seguir pode resolver o problema.

1. Você criou um projeto no Google Developer Console?
2. Você encontrou e ativou o Travel Partner API?
3. Você fez o download de um arquivo .p12 (uma chave privada após clicar em um) Crie um ID do cliente e selecione Conta de serviço?
4. Você recebeu o endereço de e-mail do ID do cliente de uma conta de serviço de um formulário: nnnnnnn@app_name.google.com.iam.gserviceaccount.com?
5. Você compartilhou sua conta da Central de anúncios de hotéis com a conta de serviço clicando o botão Compartilhar esta conta?
6. Você enviou o endereço de e-mail da conta de serviço e seu ID de parceiro para ao Gerente técnico de contas (TAM)?
7. Suas chamadas Travel Partner API estão passando um token recebido recentemente no Authorization?
8. O token do portador do seu cabeçalho Authorization tem mais de uma hora?

A tabela a seguir lista alguns erros comuns e possíveis soluções: