Integração do lado do servidor

Os editores usam a integração do lado do servidor principalmente para gerenciar leitores e os do Google Cloud. Os editores usam UpdateReaderEntitlements principalmente para atualizar Registro do Google sobre um direito de ID do produto para um PPID.

Configuração do Google Cloud

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

  1. Ativar a API para um determinado projeto
  2. 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, uma conta de serviço projeto precisa ter a API Subscription Linking ativada e uma e configurou a conta de serviço OAuth. Para ativar a API Subscription Linking para uma projeto, navegue no menu -> APIs e Serviços -> Biblioteca e pesquisa Subscription Linking ou acesse a página diretamente:


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

api

Figura 1. Como navegar até a Biblioteca de APIs e ativá-la para um bucket do Google Cloud.

Crie uma conta de serviço

As contas de serviço são usadas para permitir o acesso do aplicativo ao API Subscription Linking.

  1. Crie uma conta de serviço no arquivo no console do Google Cloud.
  2. Criar credenciais para a conta de serviço e armazenar o arquivo credentials.json em um local seguro que possa ser acessado pelo aplicativo.
  3. Conceda o papel do IAM "Administrador de vinculação de assinaturas" ao conta de serviço que você criou. Para um controle granular sobre os recursos da você pode atribuir o papel apropriado da 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 de leitor
Conseguir leitores
Atualizar direitos do leitor
Excluir leitores

Usar contas de serviço com a API Subscription Linking

Usar 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 lidam automaticamente com a solicitação access_token apropriado, enquanto a API REST exige a recuperação de um id_token e, em seguida, troque-o por um access_token.

Os clientes a seguir biblioteca e exemplos da API REST usam o endpoint getReader(). Para uma transmissão ao vivo, demonstração de todos os métodos da API, consulte Demonstração da vinculação de assinaturas ou o código dela.

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}`,
  });
};

async function updateEntitlements(ppid) {
  const publicationId = process.env.PUBLICATION_ID;
  const requestBody = {
    /*
    Refer to
    https://developers.google.com/news/subscribe/subscription-linking/appendix/glossary#entitlements_object
    */
    entitlements : [{
      product_id: `${publicationId}:basic`,
      subscription_token: 'abc1234',
      detail: 'This is our basic plan',
      expire_time: '2025-10-21T03:05:08.200564Z'
    }]
  };
  return await client.publications.readers.updateEntitlements({
    name: `publications/${publicationId}/readers/${ppid}`,
    requestBody
  });
};

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
}