Integração do lado do servidor

Os editores usam a integração do lado do servidor principalmente para gerenciar leitores e os direitos deles. Os editores usam UpdateReaderEntitlements basicamente para atualizar o registro do Google quanto ao direito de acesso de um ID do produto para um PPID.

Observação: se quiser criar leitores, é preciso usar a integração js do lado do cliente para criar e gerenciar assinaturas vinculadas.

Configuração do Google Cloud

A configuração da vinculação de assinaturas no Google Cloud inclui dois componentes principais:

1. Ativação da API para um determinado projeto
2. Como criar uma conta de serviço para acessar a API

Ativar a API Subscription Linking

Para usar uma conta de serviço e gerenciar os direitos de um leitor, o projeto do Google Cloud precisa ter a API Subscription Linking ativada e uma conta de serviço OAuth configurada. Para ativar a API Subscription Linking em um projeto, acesse o menu -> APIs e serviços -> Biblioteca e procure por Subscription Linking ou acesse a página diretamente:

https://console.cloud.google.com/apis/library?project=gcp_project_id

Figura 1. Como navegar até a API Library e ativá-la para um projeto do Google Cloud.

Crie uma conta de serviço

As contas de serviço são usadas para permitir o acesso do seu app à API Subscription Linking.

1. Crie uma conta de serviço no console do seu projeto.
2. Crie credenciais para a conta de serviço e armazene o arquivo credentials.json em um local seguro que possa ser acessado pelo app.
3. Conceda o papel do IAM "Administrador de vinculação de assinatura" à conta de serviço que você criou. Para ter controle granular sobre os recursos da conta de serviço, atribua o papel apropriado na tabela a seguir.

Capacidade / função	Administrador de vinculação de assinaturas	Leitor de vinculação de assinatura	Leitor de direitos de vinculação de assinatura
Receber direitos do leitor
Conquiste leitores
Atualizar os direitos do leitor
Excluir leitores

Atenção: as chaves de conta de serviço podem causar problemas de segurança se não forem gerenciadas corretamente. Sempre que possível, escolha uma alternativa mais segura para as chaves de conta de serviço. Caso precise autenticar com uma chave de conta de serviço, você será responsável pela segurança da chave privada e por outras operações de gerenciamento, como a rotação de chaves. Para mais informações, consulte Práticas recomendadas para gerenciar chaves de conta de serviço.

Usar contas de serviço com a API Subscription Linking

Use contas de serviço para autenticar chamadas para a API Subscription Linking, com a biblioteca de cliente googleapis ou assinando solicitações com a API REST. As bibliotecas de cliente processam automaticamente a solicitação do access_token adequado, enquanto a API REST exige a recuperação de um id_token e a troca dele por um access_token.

Tanto esta biblioteca de cliente como os exemplos da API REST usam o endpoint getReader(). Para ver uma demonstração ao vivo de todos os métodos de API, consulte o código ou o site da demonstração da vinculação de assinaturas.

Observação :para exemplos de API do lado do servidor, mescle o projeto e adicione suas próprias credenciais da conta de serviço.

Exemplo de solicitação com a biblioteca de cliente googleapis do node.js

import {readerrevenuesubscriptionlinking_v1, Auth} from 'googleapis'
const subscriptionLinking = readerrevenuesubscriptionlinking_v1.Readerrevenuesubscriptionlinking

class SubscriptionLinking {
  constructor() {
    this.auth = new Auth.GoogleAuth({
      keyFile: process.env.KEY_FILE,
      scopes: [
        'https://www.googleapis.com/auth/readerrevenue.subscriptionlinking.manage'
      ],
    })
  }

  init() {
    return new subscriptionLinking(
        {version: 'v1', auth: this.auth})
  }
}

const api = new SubscriptionLinking()
const client = api.init()

async function getReader (ppid) {
  const publicationId = process.env.PUBLICATION_ID
  return await client.publications.readers.get({
    name: `publications/${publicationId}/readers/${ppid}`,
  })
}

Assinatura manual de solicitações da API REST

import fetch from 'node-fetch'
import jwt from 'jsonwebtoken'

function getSignedJwt() {
  /*
    Either store the credentials string in an environmental variable
    Or implement logic to fetch it.
  */
  const key_file = process.env.CREDENTIALS_STRING

  const issueDate = new Date()
  const expireMinutes = 60
  const offsetInSeconds = issueDate.getTimezoneOffset() * 60000
  const expireDate = new Date(issueDate.getTime() + (expireMinutes * 60000))
  const iat = Math.floor((issueDate.getTime() + offsetInSeconds) / 1000)
  const exp = Math.floor((expireDate.getTime() + offsetInSeconds) / 1000)

  const token = {
    iss: key_file.client_email,
    iat,
    exp,
    aud: 'https://oauth2.googleapis.com/token',
    scope:'https://www.googleapis.com/auth/readerrevenue.subscriptionlinking.manage',
  }
  return jwt.sign(token, key_file.private_key, {
    algorithm: 'RS256',
    keyid: key_file.private_key_id,
  })
}

async function getAccessToken(signedJwt) {
  let body = new URLSearchParams();
  body.set('grant_type', 'urn:ietf:params:oauth:grant-type:jwt-bearer')
  body.set('assertion', signedJwt)
  const request = await fetch('https://oauth2.googleapis.com/token', {
    method: 'POST',
    headers: {'Content-Type': 'application/x-www-form-urlencoded'},
    body
  })

  const accessResponse = await accessFetch.json()
  return accessResponse.access_token
}

async function getReader(ppid) {
  const publicationId = process.env.PUBLICATION_ID
  const base_url = 'https://readerrevenuesubscriptionlinking.googleapis.com/v1'
  const endpoint = `${base_url}/publications/${publicationId}/readers/${ppid}`
  const signedJwt = await getSignedJwt()
  const accessToken = await getAccessToken(signedJwt)

  const reader = await fetch(endpoint, {
     method: 'GET',
     headers: {
       Authorization: `Bearer ${accessToken}`,
     },
   }).then((response) => {
    return response.json()
  })

  return reader
}