पुष्टि करने की सुविधा को ब्लॉक करने वाले ट्रिगर (1st जनरेशन)

ब्लॉक करने वाले फ़ंक्शन की मदद से, कस्टम कोड को लागू किया जा सकता है. इससे, आपके ऐप्लिकेशन में रजिस्टर करने या साइन इन करने वाले उपयोगकर्ता के नतीजे में बदलाव होता है. उदाहरण के लिए, अगर कोई उपयोगकर्ता कुछ ज़रूरी शर्तें पूरी नहीं करता है, तो उसे पुष्टि करने से रोका जा सकता है. इसके अलावा, उपयोगकर्ता की जानकारी को क्लाइंट ऐप्लिकेशन में वापस भेजने से पहले, उसे अपडेट किया जा सकता है.

शुरू करने से पहले

ब्लॉक करने वाले फ़ंक्शन इस्तेमाल करने के लिए, आपको अपने Firebase प्रोजेक्ट को Firebase Authentication with Identity Platform पर अपग्रेड करना होगा. अगर आपने अब तक अपग्रेड नहीं किया है, तो पहले अपग्रेड करें.

ब्लॉक करने वाले फ़ंक्शन के बारे में जानकारी

इन इवेंट के लिए, ब्लॉक करने वाले फ़ंक्शन रजिस्टर किए जा सकते हैं:

• beforeCreate: यह ट्रिगर, नए उपयोगकर्ता को Firebase Authentication डेटाबेस में सेव करने और आपके क्लाइंट ऐप्लिकेशन को टोकन वापस करने से पहले ट्रिगर होता है.

• beforeSignIn: यह उपयोगकर्ता के क्रेडेंशियल की पुष्टि होने के बाद ट्रिगर होता है. हालांकि, यह Firebase Authentication के आपके क्लाइंट ऐप्लिकेशन को आईडी टोकन देने से पहले ट्रिगर होता है. अगर आपका ऐप्लिकेशन कई चरणों में पुष्टि करने की सुविधा का इस्तेमाल करता है, तो उपयोगकर्ता की ओर से पुष्टि करने के दूसरे चरण को पूरा करने के बाद, फ़ंक्शन ट्रिगर होता है. ध्यान दें कि नया उपयोगकर्ता बनाने पर, beforeCreate के साथ-साथ beforeSignIn भी ट्रिगर होता है.

• beforeEmail (सिर्फ़ Node.js के लिए): यह किसी उपयोगकर्ता को ईमेल (उदाहरण के लिए,
  साइन-इन या पासवर्ड रीसेट करने का ईमेल) भेजे जाने से पहले ट्रिगर होता है.

• beforeSms (सिर्फ़ Node.js के लिए): यह इवेंट, उपयोगकर्ता को एसएमएस भेजने से पहले ट्रिगर होता है. जैसे, मल्टीफ़ैक्टर ऑथेंटिकेशन के मामलों में.

ब्लॉक करने वाले फ़ंक्शन का इस्तेमाल करते समय, इन बातों का ध्यान रखें:

• आपके फ़ंक्शन को सात सेकंड के अंदर जवाब देना होगा. सात सेकंड के बाद, Firebase Authentication गड़बड़ी का मैसेज दिखाता है और क्लाइंट का ऑपरेशन पूरा नहीं हो पाता.

• 200 के अलावा, अन्य एचटीटीपी रिस्पॉन्स कोड आपके क्लाइंट ऐप्लिकेशन को पास किए जाते हैं. पक्का करें कि आपका क्लाइंट कोड, आपके फ़ंक्शन से मिलने वाली किसी भी गड़बड़ी को हैंडल करता हो.

• फ़ंक्शन, आपके प्रोजेक्ट के सभी उपयोगकर्ताओं पर लागू होते हैं. इनमें टेनेंट में मौजूद उपयोगकर्ता भी शामिल हैं. Firebase Authentication आपके फ़ंक्शन को उपयोगकर्ताओं के बारे में जानकारी देता है. इसमें यह भी शामिल है कि वे किस टेनेंट से जुड़े हैं, ताकि आप उसके हिसाब से जवाब दे सकें.

• किसी खाते से पहचान की पुष्टि करने वाली सेवा देने वाली दूसरी कंपनी को लिंक करने पर, रजिस्टर किए गए सभी beforeSignIn फ़ंक्शन फिर से ट्रिगर हो जाते हैं.

• पहचान छिपाकर और कस्टम तरीके से पुष्टि करने पर, ब्लॉक करने वाले फ़ंक्शन ट्रिगर नहीं होते.

ब्लॉकिंग फ़ंक्शन को डिप्लॉय करना

उपयोगकर्ता की पुष्टि करने के फ़्लो में अपना कस्टम कोड डालने के लिए, ब्लॉक करने वाले फ़ंक्शन डिप्लॉय करें. ब्लॉक करने वाले फ़ंक्शन डिप्लॉय होने के बाद, पुष्टि करने और उपयोगकर्ता बनाने की प्रोसेस को पूरा करने के लिए, आपके कस्टम कोड को सही तरीके से पूरा होना चाहिए.

ब्लॉक करने वाले फ़ंक्शन को उसी तरह डिप्लॉय किया जाता है जिस तरह किसी अन्य फ़ंक्शन को डिप्लॉय किया जाता है. ज़्यादा जानकारी के लिए, Cloud Functions शुरू करें पेज देखें. सारांश में:

1. टारगेट किए गए इवेंट को मैनेज करने वाला फ़ंक्शन लिखें.

   उदाहरण के लिए, शुरू करने के लिए index.js में, इस तरह का कोई नो-ऑप फ़ंक्शन जोड़ा जा सकता है:

   const functions = require('firebase-functions/v1');
   
   exports.beforeCreate = functions.auth.user().beforeCreate((user, context) => {
     // TODO
   });
   
   The above example has omitted the implementation of custom auth logic. See
   the following sections to learn how to implement your blocking functions and
   [Common scenarios](#common-scenarios) for specific examples.
   

1. Firebase सीएलआई का इस्तेमाल करके, अपने फ़ंक्शन डिप्लॉय करें:

   firebase deploy --only functions
   

   हर बार फ़ंक्शन अपडेट करने पर, आपको उन्हें फिर से डिप्लॉय करना होगा.

उपयोगकर्ता और कॉन्टेक्स्ट की जानकारी पाना

beforeSignIn और beforeCreate इवेंट, User और EventContext ऑब्जेक्ट उपलब्ध कराते हैं. इनमें साइन इन करने वाले उपयोगकर्ता की जानकारी होती है. अपने कोड में इन वैल्यू का इस्तेमाल करके तय करें कि किसी कार्रवाई को आगे बढ़ने की अनुमति देनी है या नहीं.

User ऑब्जेक्ट पर उपलब्ध प्रॉपर्टी की सूची देखने के लिए, UserRecord एपीआई का संदर्भ देखें.

EventContext ऑब्जेक्ट में ये प्रॉपर्टी शामिल होती हैं:

रजिस्ट्रेशन या साइन-इन को ब्लॉक करना

रजिस्ट्रेशन या साइन-इन की कोशिश को ब्लॉक करने के लिए, अपने फ़ंक्शन में HttpsError का इस्तेमाल करें. उदाहरण के लिए:

throw new functions.auth.HttpsError('permission-denied');

इस टेबल में, उन गड़बड़ियों की सूची दी गई है जिन्हें ट्रिगर किया जा सकता है. साथ ही, गड़बड़ी का डिफ़ॉल्ट मैसेज भी दिया गया है:

आपके पास गड़बड़ी का कस्टम मैसेज तय करने का विकल्प भी है:

throw new functions.auth.HttpsError('permission-denied', 'Unauthorized request origin!');

यहां दिए गए उदाहरण में, किसी खास डोमेन से बाहर के उपयोगकर्ताओं को आपके ऐप्लिकेशन के लिए रजिस्टर करने से रोकने का तरीका बताया गया है:

exports.beforeCreate = functions.auth.user().beforeCreate((user, context) => {
  // (If the user is authenticating within a tenant context, the tenant ID can be determined from
  // user.tenantId or from context.resource, e.g. 'projects/project-id/tenant/tenant-id-1')

  // Only users of a specific domain can sign up.
  if (user.email.indexOf('@acme.com') === -1) {
    throw new functions.auth.HttpsError('invalid-argument', `Unauthorized email "${user.email}"`);
  }
});

चाहे डिफ़ॉल्ट मैसेज का इस्तेमाल किया जाए या कस्टम मैसेज का, Cloud Functions गड़बड़ी को रैप करता है और उसे क्लाइंट को इंटरनल गड़बड़ी के तौर पर दिखाता है. उदाहरण के लिए:

throw new functions.auth.HttpsError('invalid-argument', `Unauthorized email user@evil.com}`);

आपके ऐप्लिकेशन को गड़बड़ी का पता लगाना चाहिए और उसके हिसाब से उसे ठीक करना चाहिए. उदाहरण के लिए:

// Blocking functions can also be triggered in a multi-tenant context before user creation.
// firebase.auth().tenantId = 'tenant-id-1';
firebase.auth().createUserWithEmailAndPassword('johndoe@example.com', 'password')
  .then((result) => {
    result.user.getIdTokenResult()
  })
  .then((idTokenResult) => {
    console.log(idTokenResult.claim.admin);
  })
  .catch((error) => {
    if (error.code !== 'auth/internal-error' && error.message.indexOf('Cloud Function') !== -1) {
      // Display error.
    } else {
      // Registration succeeds.
    }
  });

उपयोगकर्ता की जानकारी में बदलाव करना

रजिस्ट्रेशन या साइन-इन की कोशिश को ब्लॉक करने के बजाय, कार्रवाई को जारी रखने की अनुमति दी जा सकती है. हालांकि, Firebase Authentication के डेटाबेस में सेव किए गए और क्लाइंट को दिखाए गए User ऑब्जेक्ट में बदलाव करें.

किसी उपयोगकर्ता की जानकारी में बदलाव करने के लिए, अपने इवेंट हैंडलर से एक ऑब्जेक्ट दिखाएं. इसमें वे फ़ील्ड शामिल होने चाहिए जिनमें बदलाव करना है. इन फ़ील्ड में बदलाव किया जा सकता है:

• displayName
• disabled
• emailVerified
• photoUrl
• customClaims
• sessionClaims (सिर्फ़ beforeSignIn)

sessionClaims को छोड़कर, बदले गए सभी फ़ील्ड Firebase Authentication के डेटाबेस में सेव किए जाते हैं. इसका मतलब है कि वे रिस्पॉन्स टोकन में शामिल होते हैं और उपयोगकर्ता सेशन के बीच बने रहते हैं.

यहां दिए गए उदाहरण में, डिफ़ॉल्ट डिसप्ले नेम सेट करने का तरीका बताया गया है:

exports.beforeCreate = functions.auth.user().beforeCreate((user, context) => {
  return {
    // If no display name is provided, set it to "Guest".
    displayName: user.displayName || 'Guest';
  };
});

अगर आपने beforeCreate और beforeSignIn, दोनों के लिए इवेंट हैंडलर रजिस्टर किया है, तो ध्यान दें कि beforeSignIn, beforeCreate के बाद लागू होता है. beforeCreate में अपडेट किए गए उपयोगकर्ता फ़ील्ड, beforeSignIn में दिखते हैं. अगर दोनों इवेंट हैंडलर में sessionClaims के अलावा कोई अन्य फ़ील्ड सेट किया जाता है, तो beforeSignIn में सेट की गई वैल्यू, beforeCreate में सेट की गई वैल्यू को ओवरराइट कर देती है. सिर्फ़ sessionClaims के लिए, उन्हें मौजूदा सेशन के टोकन दावों में भेजा जाता है. हालांकि, उन्हें डेटाबेस में सेव नहीं किया जाता.

उदाहरण के लिए, अगर कोई sessionClaims सेट किया गया है, तो beforeSignIn उसे किसी भी beforeCreate दावे के साथ दिखाएगा और उन्हें मर्ज कर दिया जाएगा. मर्ज होने पर, अगर sessionClaims की कोई कुंजी customClaims की किसी कुंजी से मैच होती है, तो टोकन के दावों में मैच होने वाली customClaims कुंजी को sessionClaims कुंजी से ओवरराइट कर दिया जाएगा. हालांकि, ओवरराइट की गई customClaims कुंजी, आने वाले समय में किए जाने वाले अनुरोधों के लिए डेटाबेस में बनी रहेगी.

इस्तेमाल किए जा सकने वाले OAuth क्रेडेंशियल और डेटा

पहचान की पुष्टि करने वाली सेवा देने वाली अलग-अलग कंपनियों के ब्लॉक करने वाले फ़ंक्शन में, OAuth क्रेडेंशियल और डेटा पास किया जा सकता है. यहां दी गई टेबल में बताया गया है कि पहचान की पुष्टि करने वाली सेवा देने वाली हर कंपनी के लिए, कौनसे क्रेडेंशियल और डेटा का इस्तेमाल किया जा सकता है:

रीफ़्रेश टोकन

ब्लॉकिंग फ़ंक्शन में रीफ़्रेश टोकन का इस्तेमाल करने के लिए, आपको सबसे पहले Firebase कंसोल के ब्लॉकिंग फ़ंक्शन पेज पर मौजूद चेकबॉक्स को चुनना होगा. इसके लिए, सुरक्षा > पुष्टि > सेटिंग टैब पर जाएं.

आईडी टोकन या ऐक्सेस टोकन जैसे OAuth क्रेडेंशियल से सीधे साइन इन करने पर, कोई भी आइडेंटिटी प्रोवाइडर रीफ़्रेश टोकन नहीं दिखाएगा. इस स्थिति में, क्लाइंट-साइड का वही OAuth क्रेडेंशियल, ब्लॉक करने वाले फ़ंक्शन को पास किया जाएगा.

यहां दिए गए सेक्शन में, आइडेंटिटी प्रोवाइडर के हर टाइप के बारे में बताया गया है. साथ ही, यह भी बताया गया है कि वे किस तरह के क्रेडेंशियल और डेटा के साथ काम करते हैं.

सामान्य ओआईडीसी प्रोवाइडर

जब कोई उपयोगकर्ता सामान्य OIDC सेवा देने वाली कंपनी के क्रेडेंशियल से साइन इन करता है, तो ये क्रेडेंशियल पास किए जाएंगे:

• आईडी टोकन: यह तब दिया जाता है, जब id_token फ़्लो चुना जाता है.
• ऐक्सेस टोकन: कोड फ़्लो चुनने पर दिया जाता है. ध्यान दें कि कोड फ़्लो की सुविधा, फ़िलहाल सिर्फ़ REST API के ज़रिए काम करती है.
• रीफ़्रेश टोकन: यह तब दिया जाता है, जब offline_access स्कोप चुना गया हो.

उदाहरण:

const provider = new firebase.auth.OAuthProvider('oidc.my-provider');
provider.addScope('offline_access');
firebase.auth().signInWithPopup(provider);

Google

जब कोई उपयोगकर्ता Google से साइन इन करता है, तो ये क्रेडेंशियल पास किए जाएंगे:

• आईडी टोकन
• ऐक्सेस टोकन
• रीफ़्रेश टोकन: यह सिर्फ़ तब उपलब्ध कराया जाता है, जब इन कस्टम पैरामीटर का अनुरोध किया जाता है:
  • access_type=offline
  • prompt=consent, अगर उपयोगकर्ता ने पहले सहमति दी थी और नए स्कोप का अनुरोध नहीं किया गया था

उदाहरण:

const provider = new firebase.auth.GoogleAuthProvider();
provider.setCustomParameters({
  'access_type': 'offline',
  'prompt': 'consent'
});
firebase.auth().signInWithPopup(provider);

Google के रीफ़्रेश टोकन के बारे में ज़्यादा जानें.

Facebook

जब कोई उपयोगकर्ता Facebook से साइन इन करता है, तो यह क्रेडेंशियल पास किया जाएगा:

• ऐक्सेस टोकन: एक ऐक्सेस टोकन मिलता है, जिसे किसी दूसरे ऐक्सेस टोकन से बदला जा सकता है. Facebook पर इस्तेमाल किए जा सकने वाले अलग-अलग तरह के ऐक्सेस टोकन के बारे में ज़्यादा जानें. साथ ही, उन्हें लंबे समय तक इस्तेमाल किए जा सकने वाले टोकन में बदलने का तरीका जानें.

GitHub

जब कोई उपयोगकर्ता GitHub से साइन इन करता है, तो यह क्रेडेंशियल पास किया जाएगा:

• ऐक्सेस टोकन: यह तब तक खत्म नहीं होता, जब तक इसे रद्द न किया जाए.

Microsoft

जब कोई उपयोगकर्ता Microsoft खाते से साइन इन करता है, तो ये क्रेडेंशियल पास किए जाएंगे:

• आईडी टोकन
• ऐक्सेस टोकन
• रीफ़्रेश टोकन: अगर offline_access स्कोप चुना गया है, तो इसे ब्लॉक करने वाले फ़ंक्शन को पास किया जाता है.

उदाहरण:

const provider = new firebase.auth.OAuthProvider('microsoft.com');
provider.addScope('offline_access');
firebase.auth().signInWithPopup(provider);

Yahoo

जब कोई उपयोगकर्ता Yahoo से साइन इन करता है, तो बिना किसी कस्टम पैरामीटर या स्कोप के ये क्रेडेंशियल पास किए जाएंगे:

• आईडी टोकन
• ऐक्सेस टोकन
• रीफ़्रेश टोकन

LinkedIn

जब कोई उपयोगकर्ता LinkedIn से साइन इन करता है, तो यह क्रेडेंशियल पास किया जाएगा:

• ऐक्सेस टोकन

Apple

जब कोई उपयोगकर्ता Apple खाते से साइन इन करता है, तो बिना किसी कस्टम पैरामीटर या स्कोप के ये क्रेडेंशियल पास किए जाएंगे:

• आईडी टोकन
• ऐक्सेस टोकन
• रीफ़्रेश टोकन

आम तौर पर सामने आने वाली स्थितियां

यहां दिए गए उदाहरणों में, ब्लॉकिंग फ़ंक्शन के इस्तेमाल के कुछ सामान्य उदाहरण दिखाए गए हैं:

सिर्फ़ किसी खास डोमेन से रजिस्ट्रेशन की अनुमति देना

इस उदाहरण में बताया गया है कि example.com डोमेन से बाहर के उपयोगकर्ताओं को आपके ऐप्लिकेशन पर रजिस्टर करने से कैसे रोका जा सकता है:

exports.beforeCreate = functions.auth.user().beforeCreate((user, context) => {
  if (!user.email || user.email.indexOf('@example.com') === -1) {
    throw new functions.auth.HttpsError(
      'invalid-argument', `Unauthorized email "${user.email}"`);
  }
});

बिना पुष्टि वाले ईमेल पतों से रजिस्टर करने वाले उपयोगकर्ताओं को ब्लॉक करना

यहां दिए गए उदाहरण में, उन उपयोगकर्ताओं को आपके ऐप्लिकेशन पर रजिस्टर करने से रोकने का तरीका बताया गया है जिनके ईमेल पतों की पुष्टि नहीं हुई है:

exports.beforeCreate = functions.auth.user().beforeCreate((user, context) => {
  if (user.email && !user.emailVerified) {
    throw new functions.auth.HttpsError(
      'invalid-argument', `Unverified email "${user.email}"`);
  }
});

रजिस्ट्रेशन के दौरान ईमेल पते की पुष्टि करना ज़रूरी है

यहां दिए गए उदाहरण में, रजिस्टर करने के बाद उपयोगकर्ता को अपने ईमेल पते की पुष्टि करने के लिए कहने का तरीका बताया गया है:

exports.beforeCreate = functions.auth.user().beforeCreate((user, context) => {
  const locale = context.locale;
  if (user.email && !user.emailVerified) {
    // Send custom email verification on sign-up.
    return admin.auth().generateEmailVerificationLink(user.email).then((link) => {
      return sendCustomVerificationEmail(user.email, link, locale);
    });
  }
});

exports.beforeSignIn = functions.auth.user().beforeSignIn((user, context) => {
 if (user.email && !user.emailVerified) {
   throw new functions.auth.HttpsError(
     'invalid-argument', `"${user.email}" needs to be verified before access is granted.`);
  }
});

आइडेंटिटी प्रोवाइडर के कुछ ईमेल पतों को पुष्टि किए गए ईमेल पतों के तौर पर मानना

यहां दिए गए उदाहरण में, पहचान की पुष्टि करने वाली कुछ कंपनियों से मिले उपयोगकर्ता के ईमेल पतों को 'पुष्टि की गई' के तौर पर मार्क करने का तरीका बताया गया है:

exports.beforeCreate = functions.auth.user().beforeCreate((user, context) => {
  if (user.email && !user.emailVerified && context.eventType.indexOf(':facebook.com') !== -1) {
    return {
      emailVerified: true,
    };
  }
});

कुछ आईपी पतों से साइन इन करने की सुविधा को ब्लॉक करना

यहां दिए गए उदाहरण में, कुछ आईपी पतों की रेंज से साइन-इन करने की सुविधा को ब्लॉक करने का तरीका बताया गया है:

exports.beforeSignIn = functions.auth.user().beforeSignIn((user, context) => {
  if (isSuspiciousIpAddress(context.ipAddress)) {
    throw new functions.auth.HttpsError(
      'permission-denied', 'Unauthorized access!');
  }
});

कस्टम और सेशन क्लेम सेट करना

यहां दिए गए उदाहरण में, कस्टम और सेशन क्लेम सेट करने का तरीका बताया गया है:

exports.beforeCreate = functions.auth.user().beforeCreate((user, context) => {
  if (context.credential &&
      context.credential.providerId === 'saml.my-provider-id') {
    return {
      // Employee ID does not change so save in persistent claims (stored in
      // Auth DB).
      customClaims: {
        eid: context.credential.claims.employeeid,
      },
      // Copy role and groups to token claims. These will not be persisted.
      sessionClaims: {
        role: context.credential.claims.role,
        groups: context.credential.claims.groups,
      }
    }
  }
});

संदिग्ध गतिविधि पर नज़र रखने के लिए, आईपी पतों को ट्रैक करना

टोकन की चोरी को रोकने के लिए, उस आईपी पते को ट्रैक किया जा सकता है जिससे उपयोगकर्ता ने साइन इन किया है. इसके बाद, आने वाले अनुरोधों के आईपी पते से उसकी तुलना की जा सकती है. अगर अनुरोध संदिग्ध लगता है, तो उपयोगकर्ता से फिर से साइन इन करने के लिए कहा जा सकता है. उदाहरण के लिए, अगर आईपी अलग-अलग भौगोलिक इलाकों से हैं.

1. उपयोगकर्ता जिस आईपी पते से साइन इन करता है उसे ट्रैक करने के लिए, सेशन क्लेम का इस्तेमाल करें:

   Node.js

   exports.beforeSignIn = functions.auth.user().beforeSignIn((user, context) => {
     return {
       sessionClaims: {
         signInIpAddress: context.ipAddress,
       },
     };
   });
   

2. जब कोई उपयोगकर्ता ऐसे संसाधनों को ऐक्सेस करने की कोशिश करता है जिनके लिए Firebase Authentication से पुष्टि करना ज़रूरी है, तो अनुरोध में मौजूद आईपी पते की तुलना, साइन इन करने के लिए इस्तेमाल किए गए आईपी पते से करें:

   Node.js

   app.post('/getRestrictedData', (req, res) => {
     // Get the ID token passed.
     const idToken = req.body.idToken;
     // Verify the ID token, check if revoked and decode its payload.
     admin.auth().verifyIdToken(idToken, true).then((claims) => {
       // Get request IP address
       const requestIpAddress = req.connection.remoteAddress;
       // Get sign-in IP address.
       const signInIpAddress = claims.signInIpAddress;
       // Check if the request IP address origin is suspicious relative to
       // the session IP addresses. The current request timestamp and the
       // auth_time of the ID token can provide additional signals of abuse,
       // especially if the IP address suddenly changed. If there was a sudden
       // geographical change in a short period of time, then it will give
       // stronger signals of possible abuse.
       if (!isSuspiciousIpAddressChange(signInIpAddress, requestIpAddress)) {
         // Suspicious IP address change. Require re-authentication.
         // You can also revoke all user sessions by calling:
         // admin.auth().revokeRefreshTokens(claims.sub).
         res.status(401).send({error: 'Unauthorized access. Please login again!'});
       } else {
         // Access is valid. Try to return data.
         getData(claims).then(data => {
           res.end(JSON.stringify(data);
         }, error => {
           res.status(500).send({ error: 'Server error!' })
         });
       }
     });
   });
   

उपयोगकर्ता की फ़ोटो की जांच करना

यहां दिए गए उदाहरण में, उपयोगकर्ताओं की प्रोफ़ाइल फ़ोटो को सैनिटाइज़ करने का तरीका बताया गया है:

exports.beforeCreate = functions.auth.user().beforeCreate((user, context) => {
  if (user.photoURL) {
    return isPhotoAppropriate(user.photoURL)
      .then((status) => {
        if (!status) {
          // Sanitize inappropriate photos by replacing them with guest photos.
          // Users could also be blocked from sign-up, disabled, etc.
          return {
            photoUrl: PLACEHOLDER_GUEST_PHOTO_URL,
          };
        }
      });
});

इमेज का पता लगाने और उन्हें सैनिटाइज़ करने के तरीके के बारे में ज़्यादा जानने के लिए, Cloud Vision दस्तावेज़ देखें.

उपयोगकर्ता के आइडेंटिटी प्रोवाइडर के OAuth क्रेडेंशियल ऐक्सेस करना

यहां दिए गए उदाहरण में, Google से साइन इन करने वाले उपयोगकर्ता के लिए रीफ़्रेश टोकन पाने और Google Calendar API को कॉल करने के लिए इसका इस्तेमाल करने का तरीका बताया गया है. ऑफ़लाइन ऐक्सेस के लिए, रीफ़्रेश टोकन सेव किया जाता है.

const {OAuth2Client} = require('google-auth-library');
const {google} = require('googleapis');
// ...
// Initialize Google OAuth client.
const keys = require('./oauth2.keys.json');
const oAuth2Client = new OAuth2Client(
  keys.web.client_id,
  keys.web.client_secret
);

exports.beforeCreate = functions.auth.user().beforeCreate((user, context) => {
  if (context.credential &&
      context.credential.providerId === 'google.com') {
    // Store the refresh token for later offline use.
    // These will only be returned if refresh tokens credentials are included
    // (enabled by Cloud console).
    return saveUserRefreshToken(
        user.uid,
        context.credential.refreshToken,
        'google.com'
      )
      .then(() => {
        // Blocking the function is not required. The function can resolve while
        // this operation continues to run in the background.
        return new Promise((resolve, reject) => {
          // For this operation to succeed, the appropriate OAuth scope should be requested
          // on sign in with Google, client-side. In this case:
          // https://www.googleapis.com/auth/calendar
          // You can check granted_scopes from within:
          // context.additionalUserInfo.profile.granted_scopes (space joined list of scopes).

          // Set access token/refresh token.
          oAuth2Client.setCredentials({
            access_token: context.credential.accessToken,
            refresh_token: context.credential.refreshToken,
          });
          const calendar = google.calendar('v3');
          // Setup Onboarding event on user's calendar.
          const event = {/** ... */};
          calendar.events.insert({
            auth: oauth2client,
            calendarId: 'primary',
            resource: event,
          }, (err, event) => {
            // Do not fail. This is a best effort approach.
            resolve();
          });
      });
    })
  }
});

उपयोगकर्ता की कार्रवाई के लिए, reCAPTCHA Enterprise के फ़ैसले को बदलना

यहां दिए गए उदाहरण में, काम करने वाले यूज़र फ़्लो के लिए, reCAPTCHA Enterprise के फ़ैसले को बदलने का तरीका बताया गया है.

reCAPTCHA Enterprise को Firebase Authentication के साथ इंटिग्रेट करने के बारे में ज़्यादा जानने के लिए, reCAPTCHA Enterprise को चालू करें लेख पढ़ें.

ब्लॉकिंग फ़ंक्शन का इस्तेमाल, कस्टम फ़ैक्टर के आधार पर फ़्लो को अनुमति देने या ब्लॉक करने के लिए किया जा सकता है. इससे reCAPTCHA Enterprise से मिले नतीजे को बदला जा सकता है.

const functions = require("firebase-functions/v1");
exports.beforesmsv1 = functions.auth.user().beforeSms((context) => {
 if (
   context.smsType === "SIGN_IN_OR_SIGN_UP" &&
   context.additionalUserInfo.phoneNumber.includes('+91')
 ) {
   return {
     recaptchaActionOverride: "ALLOW",
   };
 }

 // Allow users to sign in with recaptcha score greater than 0.5
 if (event.additionalUserInfo.recaptchaScore > 0.5) {
   return {
     recaptchaActionOverride: 'ALLOW',
   };
 }

 // Block all others.
 return  {
   recaptchaActionOverride: 'BLOCK',
 }
});