Servizio TagManager

Dati dell'API Manager, inclusi account, container e autorizzazioni utente.

Il servizio Google Tag Manager fornisce l'accesso ai dati dell'API Tag Manager per un utente autorizzato. Questo servizio consente agli utenti di Tag Manager di gestire account, contenitori, ambienti, versioni, spazi di lavoro, cartelle, variabili, attivatori, tag e autorizzazioni utente.

Si tratta di un servizio avanzato che deve essere attivato prima dell'uso.

Riferimento

Per informazioni dettagliate su questo servizio, consulta la documentazione di riferimento dell'API Tag Manager V2.

Come tutti i servizi avanzati in Google Apps Script, il servizio Tag Manager utilizza gli stessi oggetti, metodi e parametri dell'API pubblica. Per maggiori informazioni, consulta Come vengono determinate le firme dei metodi.

Per segnalare problemi e trovare altro supporto, consulta il Centro assistenza Google Tag Manager.

Codice di esempio

Il seguente codice campione mostra come utilizzare alcune funzionalità del servizio Tag Manager.

Crea una versione del contenitore con una variabile, un attivatore e un tag.

Il seguente codice campione utilizza l'API Tag Manager V2 per creare prima un contenitore con un nome con timestamp della data corrente per aumentare le probabilità che sia univoco. L'esempio crea quindi uno spazio di lavoro con una variabile di valore casuale e un attivatore che si attiva per qualsiasi visualizzazione di pagina. Successivamente, l'esempio utilizza l'attivatore per creare un tag di pixel arbitrario che si attiva un pixel su //example.com con un busting della cache aggiunto alla fine dell'URL. Infine, l'esempio crea una versione del contenitore con queste entità, registra la versione e la restituisce per un uso successivo.

advanced/tagManager.gs
/**
 * Creates a container version for a particular account
 * with the input accountPath.
 * @param {string} accountPath The account path.
 * @return {string} The tag manager container version.
 */
function createContainerVersion(accountPath) {
  const date = new Date();
  // Creates a container in the account, using the current timestamp to make
  // sure the container is unique.
  try {
    const container = TagManager.Accounts.Containers.create(
      {
        name: `appscript tagmanager container ${date.getTime()}`,
        usageContext: ["WEB"],
      },
      accountPath,
    );
    const containerPath = container.path;
    // Creates a workspace in the container to track entity changes.
    const workspace = TagManager.Accounts.Containers.Workspaces.create(
      { name: "appscript workspace", description: "appscript workspace" },
      containerPath,
    );
    const workspacePath = workspace.path;
    // Creates a random value variable.
    const variable = TagManager.Accounts.Containers.Workspaces.Variables.create(
      { name: "apps script variable", type: "r" },
      workspacePath,
    );
    // Creates a trigger that fires on any page view.
    const trigger = TagManager.Accounts.Containers.Workspaces.Triggers.create(
      { name: "apps script trigger", type: "PAGEVIEW" },
      workspacePath,
    );
    // Creates a arbitary pixel that fires the tag on all page views.
    const tag = TagManager.Accounts.Containers.Workspaces.Tags.create(
      {
        name: "apps script tag",
        type: "img",
        liveOnly: false,
        parameter: [
          { type: "boolean", key: "useCacheBuster", value: "true" },
          {
            type: "template",
            key: "cacheBusterQueryParam",
            value: "gtmcb",
          },
          { type: "template", key: "url", value: "//example.com" },
        ],
        firingTriggerId: [trigger.triggerId],
      },
      workspacePath,
    );
    // Creates a container version with the variabe, trigger, and tag.
    const version = TagManager.Accounts.Containers.Workspaces.create_version(
      { name: "apps script version" },
      workspacePath,
    ).containerVersion;
    console.log(version);
    return version;
  } catch (e) {
    // TODO (Developer) - Handle exception
    console.log("Failed with error: %s", e.error);
  }
}

Pubblica una versione del contenitore e visualizza rapidamente l'anteprima della bozza corrente.

Il seguente codice campione utilizza l'API Tag Manager V2 per accettare una versione del contenitore che potrebbe essere stata creata nell'esempio precedente e recuperare gli ID account, contenitore e versione dalla versione. L'esempio utilizza questi ID per pubblicare una versione del contenitore live in tutto il mondo. Infine, l'esempio crea un'anteprima rapida di un nuovo workspace e registra l'anteprima rapida.

advanced/tagManager.gs
/**
 * Publishes a container version publically to the world and creates a quick
 * preview of the current container draft.
 * @param {object} version The container version.
 */
function publishVersionAndQuickPreviewDraft(version) {
  try {
    const pathParts = version.path.split("/");
    const containerPath = pathParts.slice(0, 4).join("/");
    // Publish the input container version.
    TagManager.Accounts.Containers.Versions.publish(version.path);
    const workspace = TagManager.Accounts.Containers.Workspaces.create(
      { name: "appscript workspace", description: "appscript workspace" },
      containerPath,
    );
    const workspaceId = workspace.path;
    // Quick previews the current container draft.
    const quickPreview =
      TagManager.Accounts.Containers.Workspaces.quick_preview(workspace.path);
    console.log(quickPreview);
  } catch (e) {
    // TODO (Developer) - Handle exceptions
    console.log("Failed with error: $s", e.error);
  }
}

Crea e riautorizza un ambiente utente.

Il seguente codice campione utilizza l'API Tag Manager V2 per accettare una versione del contenitore ed estrarre gli ID account, contenitore e versione. L'esempio utilizza questi ID per creare un ambiente utente che punta alla versione del container di input e registra l'ambiente utente. L'esempio si conclude registrando un ambiente utente riautorizzato.

advanced/tagManager.gs
/**
 * Creates and reauthorizes a user environment in a container that points
 * to a container version passed in as an argument.
 * @param {object} version The container version object.
 */
function createAndReauthorizeUserEnvironment(version) {
  try {
    // Creates a container version.
    const pathParts = version.path.split("/");
    const containerPath = pathParts.slice(0, 4).join("/");
    // Creates a user environment that points to a container version.
    const environment = TagManager.Accounts.Containers.Environments.create(
      {
        name: "test_environment",
        type: "user",
        containerVersionId: version.containerVersionId,
      },
      containerPath,
    );
    console.log(`Original user environment: ${environment}`);
    // Reauthorizes the user environment that points to a container version.
    TagManager.Accounts.Containers.Environments.reauthorize(
      {},
      environment.path,
    );
    console.log(`Reauthorized user environment: ${environment}`);
  } catch (e) {
    // TODO (Developer) - Handle exceptions
    console.log("Failed with error: $s", e.error);
  }
}

Registra tutte le email e le autorizzazioni di accesso ai contenitori all'interno di un account.

Il seguente codice campione utilizza l'API Tag Manager V2 per trovare un elenco di tutte le autorizzazioni all'interno di un account Tag Manager. L'esempio registra l'indirizzo email dell'utente, l'ID contenitore e i tipi di autorizzazioni di accesso al contenitore per ogni voce.

advanced/tagManager.gs
/**
 * Logs all emails and container access permission within an account.
 * @param {string} accountPath The account path.
 */
function logAllAccountUserPermissionsWithContainerAccess(accountPath) {
  try {
    const userPermissions =
      TagManager.Accounts.User_permissions.list(accountPath).userPermission;
    for (let i = 0; i < userPermissions.length; i++) {
      const userPermission = userPermissions[i];
      if ("emailAddress" in userPermission) {
        const containerAccesses = userPermission.containerAccess;
        for (let j = 0; j < containerAccesses.length; j++) {
          const containerAccess = containerAccesses[j];
          console.log(
            `emailAddress:${userPermission.emailAddress} containerId:${containerAccess.containerId} containerAccess:${containerAccess.permission}`,
          );
        }
      }
    }
  } catch (e) {
    // TODO (Developer) - Handle exceptions
    console.log("Failed with error: $s", e.error);
  }
}