Gestire l'inoltro email

Questo documento spiega come configurare l'inoltro email nell'API Gmail.

Puoi utilizzare la risorsa settings per configurare l'inoltro per un account. Per utilizzare un indirizzo email per l'inoltro, questo deve soddisfare uno dei seguenti criteri:

  • L'indirizzo email è verificato. Per saperne di più, consulta Creare e verificare gli indirizzi di inoltro.
  • L'indirizzo email appartiene allo stesso dominio del mittente.
  • L'indirizzo email appartiene a un sottodominio all'interno dello stesso dominio del mittente.
  • L'indirizzo email appartiene a un alias di dominio configurato come parte dello stesso account Google Workspace.

Se l'indirizzo email di inoltro non rispetta una di queste regole, la configurazione dell'inoltro tramite l'API non va a buon fine.

Per informazioni su come creare, elencare, ottenere>o eliminare gli indirizzi di inoltro, consulta i metodi nella risorsa settings.forwardingAddresses.

Per informazioni su come ottenere o aggiornare le impostazioni di inoltro automatico, consulta i metodi nella risorsa settings.

Creare e verificare gli indirizzi di inoltro

Devi creare gli indirizzi di inoltro prima di utilizzarli. In alcuni casi, gli utenti devono anche verificare la proprietà dell'indirizzo.

Se Gmail richiede la verifica dell'utente per un indirizzo di inoltro, l'API restituisce l'indirizzo con un VerificationStatus di pending. Gmail invia automaticamente un messaggio di verifica all'indirizzo email di destinazione. Il proprietario dell'indirizzo email deve completare la procedura di verifica prima che tu possa utilizzarlo.

Gli indirizzi di inoltro che non richiedono la verifica hanno uno stato di verifica accepted.

Attivare l'inoltro automatico

Puoi scegliere di inoltrare tutti i nuovi messaggi a un altro indirizzo email.

Per farlo, chiama il metodo updateAutoForwarding per attivare l'inoltro automatico per un account. La chiamata richiede un indirizzo di inoltro registrato e verificato e un'azione da intraprendere per i messaggi inoltrati. Imposta questi valori nell'oggetto AutoForwarding.

Utilizza il campo disposition per impostare lo stato del messaggio dopo l'inoltro. Sebbene il valore predefinito sia dispositionUnspecified, non puoi impostare questo campo su dispositionUnspecified.

I seguenti esempi di codice mostrano come attivare l'inoltro automatico e poi spostare i messaggi inoltrati nel cestino:

Java

gmail/snippets/src/main/java/EnableForwarding.java
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.gmail.Gmail;
import com.google.api.services.gmail.GmailScopes;
import com.google.api.services.gmail.model.AutoForwarding;
import com.google.api.services.gmail.model.ForwardingAddress;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;

/* Class to demonstrate the use of Gmail Enable Forwarding API */
public class EnableForwarding {
  /**
   * Enable the auto-forwarding for an account.
   *
   * @param forwardingEmail - Email address of the recipient whose email will be forwarded.
   * @return forwarding id and metadata, {@code null} otherwise.
   * @throws IOException - if service account credentials file not found.
   */
  public static AutoForwarding enableAutoForwarding(String forwardingEmail) throws IOException {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(GmailScopes.GMAIL_SETTINGS_SHARING);
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(credentials);

    // Create the gmail API client
    Gmail service = new Gmail.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Gmail samples")
        .build();

    try {
      // Enable auto-forwarding and move forwarded messages to the trash
      ForwardingAddress address = new ForwardingAddress()
          .setForwardingEmail(forwardingEmail);
      ForwardingAddress createAddressResult = service.users().settings().forwardingAddresses()
          .create("me", address).execute();
      if (createAddressResult.getVerificationStatus().equals("accepted")) {
        AutoForwarding autoForwarding = new AutoForwarding()
            .setEnabled(true)
            .setEmailAddress(address.getForwardingEmail())
            .setDisposition("trash");
        autoForwarding =
            service.users().settings().updateAutoForwarding("me", autoForwarding).execute();
        System.out.println(autoForwarding.toPrettyString());
        return autoForwarding;
      }
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      GoogleJsonError error = e.getDetails();
      if (error.getCode() == 403) {
        System.err.println("Unable to enable forwarding: " + e.getDetails());
      } else {
        throw e;
      }
    }
    return null;
  }
}

Python

gmail/snippet/settings snippets/enable_forwarding.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def enable_forwarding():
  """Enable email forwarding.
  Returns:Draft object, including forwarding id and result meta data.

  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()

  try:
    # create gmail api client
    service = build("gmail", "v1", credentials=creds)

    address = {"forwardingEmail": "gduser1@workspacesamples.dev"}

    # pylint: disable=E1101
    result = (
        service.users()
        .settings()
        .forwardingAddresses()
        .create(userId="me", body=address)
        .execute()
    )
    if result.get("verificationStatus") == "accepted":
      body = {
          "emailAddress": result.get("forwardingEmail"),
          "enabled": True,
          "disposition": "trash",
      }
      # pylint: disable=E1101
      result = (
          service.users()
          .settings()
          .updateAutoForwarding(userId="me", body=body)
          .execute()
      )
      print(f"Forwarding is enabled : {result}")

  except HttpError as error:
    print(f"An error occurred: {error}")
    result = None

  return result


if __name__ == "__main__":
  enable_forwarding()

Per disattivare l'inoltro automatico, chiama il metodo updateAutoForwarding e imposta il campo enabled dell'oggetto AutoForwarding su false.

Inoltrare messaggi specifici

L'inoltro automatico invia tutti i messaggi Gmail ricevuti all'account di destinazione. Per inoltrare messaggi specifici, configura un filtro per creare regole che inoltrino i messaggi in risposta agli attributi o ai contenuti dei messaggi.

Per inoltrare i messaggi a più account, crea un filtro per ogni indirizzo email di inoltro.