Tato stránka byla přeložena překladačem Cloud Translation API.

Synchronizace nároků uživatelů (integrace na straně serveru)

Vydavatelé primárně využívají integraci na straně serveru pro správu čtenářů a jejich oprávnění. Vydavatelé primárně používají UpdateReaderEntitlements k aktualizaci záznamu společnosti Google o nároku na ID produktu pro PPID.

Nastavení Google Cloud

Konfigurace propojení předplatného ve službě Google Cloud zahrnuje dvě hlavní součásti:

Povolení API pro daný projekt
Vytvoření účtu služby pro přístup k rozhraní API

Povolte rozhraní API pro propojení předplatného

Chcete-li používat účet služby a spravovat oprávnění čtenáře, musí mít projekt Google Cloud povoleno rozhraní API pro propojení předplatného a správně nakonfigurovaný účet služby OAuth. Chcete-li pro projekt aktivovat rozhraní Subscription Linking API, přejděte z nabídky -> APIs & Services -> Library a vyhledejte položku Subscription Linking , nebo navštivte stránku přímo:


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

api

Obrázek 1. Přechod do knihovny API a povolení rozhraní API pro projekt Google Cloud.

Vytvořte servisní účet

Servisní účty se používají k povolení přístupu z vaší aplikace k rozhraní API pro propojení předplatného.

Vytvořte servisní účet v konzole vašeho projektu.
Vytvořte přihlašovací údaje pro účet služby a uložte soubor credentials.json na bezpečném místě přístupném pro vaši aplikaci.
Přidělte roli IAM „Správce propojení předplatného“ účtu služby, který jste vytvořili. Pro podrobnou kontrolu nad možnostmi účtu služby můžete přiřadit příslušnou roli z následující tabulky.

Schopnost / Role	Správce propojení předplatného	Prohlížeč propojení předplatného	Prohlížeč nároků na propojení předplatného
Získejte čtenářská oprávnění
Získejte čtenáře
Aktualizujte oprávnění čtenářů
Smazat čtenáře

Používejte servisní účty s rozhraním Subscription Linking API

Chcete-li ověřit volání rozhraní Subscription Linking API pomocí servisních účtů, použijte buď klientskou knihovnu knihovny googleapis (která automaticky zpracovává požadavky access_token ), nebo podepisujte požadavky přímo pomocí REST API. Pokud používáte REST API, musíte nejprve získat access_token (prostřednictvím knihovny Google Auth nebo pomocí servisního účtu JWT ) a poté jej zahrnout do záhlaví Authorization

Následující klientská knihovna i příklady REST API obsahují ukázkový kód pro volání getReader() , getReaderEntitlements() , updateReaderEntitlements() a deleteReader() .

Klientská knihovna

Tato část vysvětluje, jak používat klientskou knihovnu googleapis v Node.js.

Vzorová žádost

Pro pole keyFile v konstruktoru Auth.GoogleAuth nastavte cestu ke klíči účtu služby . Pokud nemůžete exportovat klíč servisního účtu kvůli zásadám vaší organizace, můžete použít metodu výchozích přihlašovacích údajů účtu (ADC) . Pokud použijete metodu ADC, nemusíte zadávat pole keyFile , protože ADC bude vyhledávat přihlašovací údaje sám.

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 subscriptionLinkingApi = new SubscriptionLinking();
const client = subscriptionLinkingApi.init();

/**
 * Retrieves details for a specific reader associated with the publication.
 * @async
 * @param {string} ppid - The Publisher Provided ID (ppid) for the reader.
 * @return {Promise<object>} A promise that resolves with the reader's details
 *  from the API.
 */
async function getReader(ppid) {
  const publicationId = process.env.PUBLICATION_ID;
  return await client.publications.readers.get({
    name: `publications/${publicationId}/readers/${ppid}`,
  });
};

/**
 * Updates the entitlements for a specific reader.
 * @async
 * @param {string} ppid - The Publisher Provided ID (ppid) for the reader whose
 *  entitlements are being updated.
 * @return {Promise<object>} A promise that resolves with the result of the
 *  updated entitlements object.
 */
async function updateReaderEntitlements(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}/entitlements`,
    requestBody
  });
};

/**
 * Retrieves the current entitlements for a specific reader.
 * @async
 * @param {string} ppid - The Publisher Provided ID (ppid) for the reader.
 * @return {Promise<object>} A promise that resolves with the reader's entitlements object.
 */
async function getReaderEntitlements(ppid) {
  const publicationId = process.env.PUBLICATION_ID;
  return await client.publications.readers.getEntitlements({
    name: `publications/${publicationId}/readers/${ppid}/entitlements`
  });
};

/**
 * Deletes a specific Subscription Linkikng reader record associated with the publication.
 * @async
 * @param {string} ppid - The Publisher Provided ID (ppid) for the reader to be deleted.
 * @param {boolean=} forceDelete - If true, delete the user even if their
 *  entitelements are not empty
 * @return {Promise<object>} A promise that resolves upon successful deletion
 *  with an empty object ({})
 */
async function deleteReader(ppid, forceDelete = false) {
  const publicationId = process.env.PUBLICATION_ID;
  return await client.publications.readers.delete({
    name: `publications/${publicationId}/readers/${ppid}`
    force: forceDelete
  });
};

REST API

Pokud chcete volat koncové body REST API, můžete použít kteroukoli z metod k získání accessToken , který nastavíte na hlavičku Authorization .

1. Použijte knihovnu `GoogleAuth`

Pro klíč credentials můžete použít klíč účtu služby nebo výchozí pověření účtu (ADC) . Pokud použijete metodu ADC, nemusíte zadávat pole credentials , protože ADC vyhledá pověření sám.

import { GoogleAuth } from 'google-auth-library';
import credentialJson from 'path_to_your_json_file' with { type: 'json' };

const auth = new GoogleAuth({
    credentials: credential_json,
    scopes: [
      'https://www.googleapis.com/auth/readerrevenue.subscriptionlinking.manage'
    ]
});

async function getAccessToken() {
    const accessToken = await auth.getAccessToken();
    return accessToken;
}

2. Vygenerujte `access_token` pomocí servisního účtu JWT

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

function getSignedJwt() {
  /*
    Either store the service account 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 response = await fetch('https://oauth2.googleapis.com/token', {
    method: 'POST',
    headers: {'Content-Type': 'application/x-www-form-urlencoded'},
    body
  })
  const accessResponse = await response.json();
  return accessResponse.access_token;
}

Ukázkový kód pro volání REST API s knihovnou Google Auth

import { GoogleAuth } from 'google-auth-library';
import fetch from 'node-fetch'
import credentialJson from 'path_to_your_json_file' with { type: 'json' };

const BASE_SUBSCRIPTION_LINIING_API_URL='https://readerrevenuesubscriptionlinking.googleapis.com/v1';
const publicationId = process.env.PUBLICATION_ID

const auth = new GoogleAuth({
    credentials: credentialJson,
    scopes: [
      'https://www.googleapis.com/auth/readerrevenue.subscriptionlinking.manage'
    ]
});

async function getAccessToken() {
    const accessToken = await auth.getAccessToken();
    return accessToken;
}

/**
 * Retrieves details for a specific reader associated with the publication.
 * @async
 * @param {string} ppid - The Publisher Provided ID (ppid) for the reader.
 * @return {object} reader json for the given ppid
 */
async function getReader(ppid) {
  const endpoint = `${BASE_SUBSCRIPTION_LINIING_API_URL}/publications/${publicationId}/readers/${ppid}`;
  const accessToken = await getAccessToken();
  const response = await fetch(endpoint, {
     method: 'GET',
     headers: {
       Authorization: `Bearer ${accessToken}`,
     },
   });
  const reader = await response.json();
  return reader;
}

/**
 * Updates the entitlements for a specific reader.
 * @async
 * @param {string} ppid - The Publisher Provided ID (ppid) for the reader.
 * @return {object} the updated entitlements object in json.
 */
async function updateReaderEntitlements(ppid) {
  const endpoint = `${BASE_SUBSCRIPTION_LINIING_API_URL}/publications/${publicationId}/readers/${ppid}/entitlements`;
  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'
    }]
  };
  const response = await fetch(endpoint, {
     method: 'PATCH',
     headers: {
       Authorization: `Bearer ${accessToken}`,
       'Content-Type': 'application/json',
     },
     body: JSON.stringify(requestBody)
   })
  const updatedEntitlements = await response.json();
  return updatedEntitlements;
}

/**
 * Retrieves the current entitlements for a specific reader.
 * @async
 * @param {string} ppid - The Publisher Provided ID (ppid) for the reader.
 * @return {object} the reader's entitlements object in json.
 */
async function getReaderEntitlements(ppid) {
  const endpoint = `${BASE_SUBSCRIPTION_LINIING_API_URL}/publications/${publicationId}/readers/${ppid}/entitlements`;
  const accessToken = await getAccessToken();
  const response = await fetch(endpoint, {
     method: 'GET',
     headers: {
       Authorization: `Bearer ${accessToken}`,
     },
   });
  const entitlements = await response.json();
  return entitlements;
}

/**
 * Deletes a specific Subscription Linkikng reader record associated with the publication.
 * @async
 * @param {string} ppid - The Publisher Provided ID (ppid) for the reader.
 * @param {boolean=} forceDelete - If true, delete the user even if their
 *  entitelements are not empty
 * @return {object} returns an empty object ({}) if the delete operation is successful
 */
async function deleteReader(ppid, forceDelete = false) {
  const endpoint = `${BASE_SUBSCRIPTION_LINIING_API_URL}/publications/${publicationId}/readers/${ppid}?force=${forceDelete}`;
  const response = await fetch(endpoint, {
     method: 'DELETE',
     headers: {
       Authorization: `Bearer ${accessToken}`,
     }
   });
  const result = await response.json();
  return result;
}