Generuję linki do czynności związanych z e-mailami

Aplikacje mobilne muszą czasami wchodzić w interakcje z użytkownikami i zachęcać ich do określonych działań przez wysyłanie e-maili.

Pakiety SDK klienta Firebase umożliwiają wysyłanie do użytkowników e-maili zawierających których może użyć do resetowania hasła, weryfikacji adresu e-mail oraz logowanie się za pomocą adresu e-mail. Te oparte na szablonach e-maile są wysyłane przez Google i zawierają ograniczone możliwości dostosowywania.

Jeśli wolisz zamiast tego użyć własnych szablonów e-maili i własnego sposobu dostarczania poczty e-mail Google, ta strona zawiera informacje o korzystaniu z pakietu SDK Firebase Admin. aby automatycznie generować linki do działań dla powyższych przepływów, które można umieścić w e-mailach wysyłanych do użytkowników.

Dzięki temu:

• Dostosowywanie szablonów e-maili. Obejmuje to możliwość dodawania nowych stylów tworzenie niestandardowych elementów marki, zmianę tekstu i logo, zwracanie się do użytkowników po imieniu imienia i nazwiska itd.
• Stosuj różne szablony w zależności od kontekstu. Jeśli na przykład użytkownik jest weryfikacji adresu e-mail w celu subskrypcji newslettera, kontekst może być podane w treści e-maila. Inny przykład to logowanie za pomocą linku w e-mailu: scenariusz może zostać wywołany przez tego samego użytkownika lub przez zaproszenie od innego użytkownika. E-mail musi zawierać kontekst.
• Lokalizowanie niestandardowych szablonów e-maili.
• Możliwość wygenerowania linku z bezpiecznego środowiska serwera.
• Możliwość dostosowania sposobu otwierania linku w aplikacji mobilnej lub oraz jak przekazywać dodatkowe informacje o stanie itp.
• Możliwość dostosowania domeny linku dynamicznego używanej w przepływach aplikacji mobilnych, gdy tworząc link do działania e-maila, a nawet określając inny link dynamiczny, w zależności od kontekstu lub aplikacji mobilnej.

Inicjowanie ustawień kodu akcji

Zanim będzie można wygenerować link do działania w e-mailu, może być konieczne zainicjowanie ActionCodeSettings instancja.

ActionCodeSettings umożliwiają przekazywanie dodatkowego stanu za pomocą adresu URL typu „Dalej”, jest dostępny, gdy użytkownik kliknie link w e-mailu. Dzięki temu użytkownik może też możliwość powrotu do aplikacji po zakończeniu działania. Ponadto możesz określić, czy link do działania e-maila ma być obsługiwany bezpośrednio z telefonu podczas instalacji lub z przeglądarki.

W przypadku linków, które mają być otwierane w aplikacji mobilnej, musisz włączyć Linków dynamicznych Firebase i wykonując pewne zadania, aby wykryć te linki w aplikacji mobilnej. Zapoznaj się z instrukcjami Skonfiguruj Linki dynamiczne Firebase pod kątem działań związanych z e-mailami.

Aby zainicjować instancję ActionCodeSettings, podaj te dane:

Poniższy przykład pokazuje, jak wysłać e-mail weryfikacyjny link, który najpierw otworzy się w aplikacji mobilnej jako link dynamiczny Firebase (Apple com.example.ios lub com.example.android na Androida, w których aplikacja jeśli nie jest jeszcze zainstalowany, a minimalna wersja to 12). Precyzyjny link będzie zawierać ładunek adresu URL https://www.example.com/checkout?cartId=1234 Użyta domena linku dynamicznego to coolapp.page.link, który należy skonfigurować na potrzeby kreacji dynamicznych Firebase Linki.

const actionCodeSettings = {
  // URL you want to redirect back to. The domain (www.example.com) for
  // this URL must be whitelisted in the Firebase Console.
  url: 'https://www.example.com/checkout?cartId=1234',
  // This must be true for email link sign-in.
  handleCodeInApp: true,
  iOS: {
    bundleId: 'com.example.ios',
  },
  android: {
    packageName: 'com.example.android',
    installApp: true,
    minimumVersion: '12',
  },
  // FDL custom domain.
  dynamicLinkDomain: 'coolapp.page.link',
};

ActionCodeSettings actionCodeSettings = ActionCodeSettings.builder()
    .setUrl("https://www.example.com/checkout?cartId=1234")
    .setHandleCodeInApp(true)
    .setIosBundleId("com.example.ios")
    .setAndroidPackageName("com.example.android")
    .setAndroidInstallApp(true)
    .setAndroidMinimumVersion("12")
    .setDynamicLinkDomain("coolapp.page.link")
    .build();

action_code_settings = auth.ActionCodeSettings(
    url='https://www.example.com/checkout?cartId=1234',
    handle_code_in_app=True,
    ios_bundle_id='com.example.ios',
    android_package_name='com.example.android',
    android_install_app=True,
    android_minimum_version='12',
    dynamic_link_domain='coolapp.page.link',
)

actionCodeSettings := &auth.ActionCodeSettings{
	URL:                   "https://www.example.com/checkout?cartId=1234",
	HandleCodeInApp:       true,
	IOSBundleID:           "com.example.ios",
	AndroidPackageName:    "com.example.android",
	AndroidInstallApp:     true,
	AndroidMinimumVersion: "12",
	DynamicLinkDomain:     "coolapp.page.link",
}

var actionCodeSettings = new ActionCodeSettings()
{
    Url = "https://www.example.com/checkout?cartId=1234",
    HandleCodeInApp = true,
    IosBundleId = "com.example.ios",
    AndroidPackageName = "com.example.android",
    AndroidInstallApp = true,
    AndroidMinimumVersion = "12",
    DynamicLinkDomain = "coolapp.page.link",
};

Więcej informacji: Stan przekazywania w działaniach e-maili.

Wygeneruj link do zresetowania hasła

Aby wygenerować link do zresetowania hasła, podaj adres e-mail istniejącego użytkownika oraz opcjonalny obiekt ActionCodeSettings. Operacja zostanie zakończona przy użyciu e-maila działania. Użyty adres e-mail musi należeć do istniejącego użytkownika.

// Admin SDK API to generate the password reset link.
const userEmail = 'user@example.com';
getAuth()
  .generatePasswordResetLink(userEmail, actionCodeSettings)
  .then((link) => {
    // Construct password reset email template, embed the link and send
    // using custom SMTP server.
    return sendCustomPasswordResetEmail(userEmail, displayName, link);
  })
  .catch((error) => {
    // Some error occurred.
  });

String email = "user@example.com";
try {
  String link = FirebaseAuth.getInstance().generatePasswordResetLink(
      email, actionCodeSettings);
  // Construct email verification template, embed the link and send
  // using custom SMTP server.
  sendCustomEmail(email, displayName, link);
} catch (FirebaseAuthException e) {
  System.out.println("Error generating email link: " + e.getMessage());
}

email = 'user@example.com'
link = auth.generate_password_reset_link(email, action_code_settings)
# Construct password reset email from a template embedding the link, and send
# using a custom SMTP server.
send_custom_email(email, link)

email := "user@example.com"
link, err := client.PasswordResetLinkWithSettings(ctx, email, actionCodeSettings)
if err != nil {
	log.Fatalf("error generating email link: %v\n", err)
}

// Construct password reset template, embed the link and send
// using custom SMTP server.
sendCustomEmail(email, displayName, link)

var email = "user@example.com";
var link = await FirebaseAuth.DefaultInstance.GeneratePasswordResetLinkAsync(
    email, actionCodeSettings);
// Construct email verification template, embed the link and send
// using custom SMTP server.
SendCustomEmail(email, displayName, link);

Po wygenerowaniu linku można go wstawić do niestandardowego hasła do resetowania a następnie wysłać e-maila do odpowiedniego użytkownika, korzystając z niestandardowego serwera SMTP.

Jeśli nie korzystasz z domyślnej strony docelowej resetowania hasła ani nie tworzysz Niestandardowy moduł obsługi, patrz tworząc niestandardowe moduły obsługi działań e-mail.

Wygeneruj link weryfikacyjny adresu e-mail

Aby wygenerować link weryfikacyjny e-maila, podaj obecnemu użytkownikowi niezweryfikowane adres e-mail i opcjonalny obiekt ActionCodeSettings. Operacja zostanie zakończona z linkiem do działania w e-mailu. Użyty adres e-mail musi należeć do istniejącego użytkownika.

// Admin SDK API to generate the email verification link.
const useremail = 'user@example.com';
getAuth()
  .generateEmailVerificationLink(useremail, actionCodeSettings)
  .then((link) => {
    // Construct email verification template, embed the link and send
    // using custom SMTP server.
    return sendCustomVerificationEmail(useremail, displayName, link);
  })
  .catch((error) => {
    // Some error occurred.
  });

String email = "user@example.com";
try {
  String link = FirebaseAuth.getInstance().generateEmailVerificationLink(
      email, actionCodeSettings);
  // Construct email verification template, embed the link and send
  // using custom SMTP server.
  sendCustomEmail(email, displayName, link);
} catch (FirebaseAuthException e) {
  System.out.println("Error generating email link: " + e.getMessage());
}

email = 'user@example.com'
link = auth.generate_email_verification_link(email, action_code_settings)
# Construct email from a template embedding the link, and send
# using a custom SMTP server.
send_custom_email(email, link)

email := "user@example.com"
link, err := client.EmailVerificationLinkWithSettings(ctx, email, actionCodeSettings)
if err != nil {
	log.Fatalf("error generating email link: %v\n", err)
}

// Construct email verification template, embed the link and send
// using custom SMTP server.
sendCustomEmail(email, displayName, link)

var email = "user@example.com";
var link = await FirebaseAuth.DefaultInstance.GenerateEmailVerificationLinkAsync(
    email, actionCodeSettings);
// Construct email verification template, embed the link and send
// using custom SMTP server.
SendCustomEmail(email, displayName, link);

Po wygenerowaniu linku można go wstawić do weryfikacji niestandardowej a następnie wysłać e-maila do odpowiedniego użytkownika, korzystając z niestandardowego serwera SMTP.

Jeśli nie używasz domyślnej strony docelowej weryfikacji adresu e-mail ani budynku własnego modułu obsługi, patrz tworząc niestandardowe moduły obsługi działań e-mail.

Wygeneruj link e-mail do logowania

Zanim będzie można uwierzytelnić użytkowników za pomocą logowania za pomocą linku e-mail, musisz wykonać włącz logowanie za pomocą linku w e-mailu do swojego projektu Firebase.

Aby wygenerować link logowania, podaj adres e-mail użytkownika i ActionCodeSettings obiektu. W tym przypadku wymagany jest obiekt ActionCodeSettings, aby podać informacje o tym, dokąd ma wrócić użytkownik po kliknięciu linku w celu zalogowania się. do końca. Operacja zostanie zakończona wraz z linkiem do działania e-maila.

W przeciwieństwie do resetowania hasła i weryfikacji adresu e-mail użyty adres e-mail nie musi należeć do istniejącego użytkownika, ponieważ ta operacja może być używana do zarejestruj nowych użytkowników w swojej aplikacji za pomocą linku w e-mailu.

// Admin SDK API to generate the sign in with email link.
const useremail = 'user@example.com';
getAuth()
  .generateSignInWithEmailLink(useremail, actionCodeSettings)
  .then((link) => {
    // Construct sign-in with email link template, embed the link and
    // send using custom SMTP server.
    return sendSignInEmail(useremail, displayName, link);
  })
  .catch((error) => {
    // Some error occurred.
  });

String email = "user@example.com";
try {
  String link = FirebaseAuth.getInstance().generateSignInWithEmailLink(
      email, actionCodeSettings);
  // Construct email verification template, embed the link and send
  // using custom SMTP server.
  sendCustomEmail(email, displayName, link);
} catch (FirebaseAuthException e) {
  System.out.println("Error generating email link: " + e.getMessage());
}

email = 'user@example.com'
link = auth.generate_sign_in_with_email_link(email, action_code_settings)
# Construct email from a template embedding the link, and send
# using a custom SMTP server.
send_custom_email(email, link)

email := "user@example.com"
link, err := client.EmailSignInLink(ctx, email, actionCodeSettings)
if err != nil {
	log.Fatalf("error generating email link: %v\n", err)
}

// Construct sign-in with email link template, embed the link and send
// using custom SMTP server.
sendCustomEmail(email, displayName, link)

var email = "user@example.com";
var link = await FirebaseAuth.DefaultInstance.GenerateSignInWithEmailLinkAsync(
    email, actionCodeSettings);
// Construct email verification template, embed the link and send
// using custom SMTP server.
SendCustomEmail(email, displayName, link);

Po wygenerowaniu linku możesz go wstawić do niestandardowego e-maila logowania a następnie wyślij e-maila do odpowiedniego użytkownika za pomocą niestandardowego serwera SMTP.

Więcej informacji o uwierzytelniania użytkowników za pomocą Firebase za pomocą linków e-mail. Pomoże to uzyskać informacje o tym, jak dokończyć logowanie po tym, jak użytkownik kliknie link i zostanie przekierowany z powrotem do aplikacji.