JavaScript में Twitter का इस्तेमाल करके पुष्टि करें

अपने ऐप्लिकेशन में Twitter से पुष्टि करने की सुविधा को जोड़कर, उपयोगकर्ताओं को उनके Twitter खातों का इस्तेमाल करके, Firebase की पुष्टि करने की अनुमति दी जा सकती है. साइन-इन फ़्लो को पूरा करने के लिए Firebase SDK टूल का इस्तेमाल करके, Twitter से पुष्टि करने की सुविधा इंटिग्रेट की जा सकती है. इसके अलावा, Twitter OAuth फ़्लो को मैन्युअल तरीके से चलाकर, Firebase को ऐक्सेस टोकन और सीक्रेट भी पास किया जा सकता है.

वेब कंटेनर इंस्टॉल करने से पहले

1. Firebase को अपने JavaScript प्रोजेक्ट में जोड़ें.
2. Firebase कंसोल में, पुष्टि करें सेक्शन खोलें.
3. साइन इन करने का तरीका टैब पर, Twitter की सेवा देने वाली कंपनी को चालू करें.
4. सेवा देने वाली कंपनी के डेवलपर कंसोल से, एपीआई पासकोड और एपीआई सीक्रेट को कंपनी के कॉन्फ़िगरेशन में जोड़ें:
   1. Twitter पर डेवलपर ऐप्लिकेशन के तौर पर अपने ऐप्लिकेशन को रजिस्टर करें. साथ ही, अपने ऐप्लिकेशन की OAuth एपीआई पासकोड और एपीआई सीक्रेट पाएं.
   2. पक्का करें कि आपका Firebase OAuth रीडायरेक्ट यूआरआई (उदाहरण के लिए, my-app-12345.firebaseapp.com/__/auth/handler) आपके Twitter ऐप्लिकेशन के कॉन्फ़िगरेशन पर आपके ऐप्लिकेशन के सेटिंग पेज में, ऑथराइज़ेशन कॉलबैक यूआरएल के तौर पर सेट हो.
5. सेव करें पर क्लिक करें.

Firebase SDK टूल की मदद से साइन-इन की प्रोसेस को मैनेज करना

अगर आप कोई वेब ऐप्लिकेशन बना रहे हैं, तो Firebase JavaScript SDK टूल की मदद से साइन-इन फ़्लो को मैनेज करना, अपने उपयोगकर्ताओं के Twitter खातों का इस्तेमाल करके Firebase से पुष्टि करने का सबसे आसान तरीका है. (अगर आपको Node.js या बिना ब्राउज़र वाले एनवायरमेंट में किसी उपयोगकर्ता की पुष्टि करनी है, तो आपको मैन्युअल तरीके से साइन-इन फ़्लो मैनेज करना होगा.)

Firebase JavaScript SDK टूल से साइन इन फ़्लो को मैनेज करने के लिए, यह तरीका अपनाएं:

1. Twitter कंपनी के ऑब्जेक्ट का इंस्टेंस बनाएं:

   वेब मॉड्यूलर एपीआई

   import { TwitterAuthProvider } from "firebase/auth";
   
   const provider = new TwitterAuthProvider();
   auth_twitter_provider_create.js

   वेब नेमस्पेसेड एपीआई

   var provider = new firebase.auth.TwitterAuthProvider();
   twitter.js

2. ज़रूरी नहीं: काम के कस्टम OAuth पैरामीटर साफ़ तौर पर पास किए बिना, सेवा देने वाले के OAuth फ़्लो को उपयोगकर्ता की पसंदीदा भाषा में लोकलाइज़ करने के लिए, OAuth फ़्लो शुरू करने से पहले, ऑथराइज़ेशन इंस्टेंस पर भाषा कोड को अपडेट करें. उदाहरण के लिए:

   वेब मॉड्यूलर एपीआई

   import { getAuth } from "firebase/auth";
   
   const auth = getAuth();
   auth.languageCode = 'it';
   // To apply the default browser preference instead of explicitly setting it.
   // auth.useDeviceLanguage();
   auth_set_language_code.js

   वेब नेमस्पेसेड एपीआई

   firebase.auth().languageCode = 'it';
   // To apply the default browser preference instead of explicitly setting it.
   // firebase.auth().useDeviceLanguage();
   index.js

3. ज़रूरी नहीं: कस्टम OAuth प्रोवाइडर के ऐसे अतिरिक्त पैरामीटर तय करें जिन्हें आपको OAuth अनुरोध के साथ भेजना है. कोई कस्टम पैरामीटर जोड़ने के लिए, शुरू की गई सेवा देने वाली कंपनी के उस ऑब्जेक्ट के साथ setCustomParameters को कॉल करें जिसमें वह कुंजी मौजूद हो जो OAuth की सेवा देने वाली कंपनी के दस्तावेज़ और उससे जुड़ी वैल्यू में बताया गया हो. उदाहरण के लिए:

   वेब मॉड्यूलर एपीआई

   provider.setCustomParameters({
     'lang': 'es'
   });
   auth_twitter_provider_params.js

   वेब नेमस्पेसेड एपीआई

   provider.setCustomParameters({
     'lang': 'es'
   });
   twitter.js

   रिज़र्व किए गए ज़रूरी OAuth पैरामीटर की अनुमति नहीं है. इन्हें अनदेखा कर दिया जाएगा. ज़्यादा जानकारी के लिए, पुष्टि करने वाली कंपनी का रेफ़रंस देखें.
4. Twitter प्रोवाइडर ऑब्जेक्ट का इस्तेमाल करके, Firebase से पुष्टि करें. उपयोगकर्ताओं को पॉप-अप विंडो खोलकर या साइन-इन पेज पर रीडायरेक्ट करके, उनके Twitter खातों से साइन इन करने के लिए कहा जा सकता है. मोबाइल डिवाइस पर रीडायरेक्ट करने के तरीके को प्राथमिकता दी जाती है.
   • पॉप-अप विंडो की मदद से साइन इन करने के लिए, signInWithPopup पर कॉल करें:

     वेब मॉड्यूलर एपीआई

     import { getAuth, signInWithPopup, TwitterAuthProvider } from "firebase/auth";
     
     const auth = getAuth();
     signInWithPopup(auth, provider)
       .then((result) => {
         // This gives you a the Twitter OAuth 1.0 Access Token and Secret.
         // You can use these server side with your app's credentials to access the Twitter API.
         const credential = TwitterAuthProvider.credentialFromResult(result);
         const token = credential.accessToken;
         const secret = credential.secret;
     
         // The signed-in user info.
         const user = result.user;
         // IdP data available using getAdditionalUserInfo(result)
         // ...
       }).catch((error) => {
         // Handle Errors here.
         const errorCode = error.code;
         const errorMessage = error.message;
         // The email of the user's account used.
         const email = error.customData.email;
         // The AuthCredential type that was used.
         const credential = TwitterAuthProvider.credentialFromError(error);
         // ...
       });
     auth_twitter_signin_popup.js

     वेब नेमस्पेसेड एपीआई

     firebase
       .auth()
       .signInWithPopup(provider)
       .then((result) => {
         /** @type {firebase.auth.OAuthCredential} */
         var credential = result.credential;
     
         // This gives you a the Twitter OAuth 1.0 Access Token and Secret.
         // You can use these server side with your app's credentials to access the Twitter API.
         var token = credential.accessToken;
         var secret = credential.secret;
     
         // The signed-in user info.
         var user = result.user;
         // IdP data available in result.additionalUserInfo.profile.
           // ...
       }).catch((error) => {
         // Handle Errors here.
         var errorCode = error.code;
         var errorMessage = error.message;
         // The email of the user's account used.
         var email = error.email;
         // The firebase.auth.AuthCredential type that was used.
         var credential = error.credential;
         // ...
       });
     twitter.js

     यह भी ध्यान रखें कि आपके पास Twitter की सेवा देने वाली कंपनी का OAuth टोकन वापस पाने का विकल्प है. इसका इस्तेमाल, Twitter API का इस्तेमाल करके ज़्यादा डेटा फ़ेच करने के लिए किया जा सकता है.

     यहां पर गड़बड़ियों का पता लगाकर उन्हें ठीक भी किया जा सकता है. गड़बड़ी कोड की सूची के लिए, आधिकारिक रेफ़रंस दस्तावेज़ पर एक नज़र डालें.

   • साइन-इन पेज पर रीडायरेक्ट करके साइन इन करने के लिए, signInWithRedirect को कॉल करें: `signInWithredirect` का इस्तेमाल करते समय सबसे सही तरीके अपनाएं.

     वेब मॉड्यूलर एपीआई

     import { getAuth, signInWithRedirect } from "firebase/auth";
     
     const auth = getAuth();
     signInWithRedirect(auth, provider);
     auth_signin_redirect.js

     वेब नेमस्पेसेड एपीआई

     firebase.auth().signInWithRedirect(provider);
     index.js

     इसके बाद, पेज लोड होने पर getRedirectResult पर कॉल करके, Twitter सेवा देने वाली कंपनी का OAuth टोकन भी वापस पाया जा सकता है:

     वेब मॉड्यूलर एपीआई

     import { getAuth, getRedirectResult, TwitterAuthProvider } from "firebase/auth";
     
     const auth = getAuth();
     getRedirectResult(auth)
       .then((result) => {
         // This gives you a the Twitter OAuth 1.0 Access Token and Secret.
         // You can use these server side with your app's credentials to access the Twitter API.
         const credential = TwitterAuthProvider.credentialFromResult(result);
         const token = credential.accessToken;
         const secret = credential.secret;
         // ...
     
         // The signed-in user info.
         const user = result.user;
         // IdP data available using getAdditionalUserInfo(result)
         // ...
       }).catch((error) => {
         // Handle Errors here.
         const errorCode = error.code;
         const errorMessage = error.message;
         // The email of the user's account used.
         const email = error.customData.email;
         // The AuthCredential type that was used.
         const credential = TwitterAuthProvider.credentialFromError(error);
         // ...
       });
     auth_twitter_signin_redirect_result.js

     वेब नेमस्पेसेड एपीआई

     firebase.auth()
       .getRedirectResult()
       .then((result) => {
         if (result.credential) {
           /** @type {firebase.auth.OAuthCredential} */
           var credential = result.credential;
     
           // This gives you a the Twitter OAuth 1.0 Access Token and Secret.
           // You can use these server side with your app's credentials to access the Twitter API.
           var token = credential.accessToken;
           var secret = credential.secret;
           // ...
         }
     
         // The signed-in user info.
         var user = result.user;
         // IdP data available in result.additionalUserInfo.profile.
           // ...
       }).catch((error) => {
         // Handle Errors here.
         var errorCode = error.code;
         var errorMessage = error.message;
         // The email of the user's account used.
         var email = error.email;
         // The firebase.auth.AuthCredential type that was used.
         var credential = error.credential;
         // ...
       });
     twitter.js

     यहां पर गड़बड़ियों का पता लगाकर उन्हें ठीक भी किया जा सकता है. गड़बड़ी कोड की सूची के लिए, आधिकारिक रेफ़रंस दस्तावेज़ पर एक नज़र डालें.

import {
  getAuth,
  linkWithCredential,
  signInWithPopup,
  TwitterAuthProvider,
} from "firebase/auth";

try {
  // Step 1: User tries to sign in using Twitter.
  let result = await signInWithPopup(getAuth(), new TwitterAuthProvider());
} catch (error) {
  // Step 2: User's email already exists.
  if (error.code === "auth/account-exists-with-different-credential") {
    // The pending Twitter credential.
    let pendingCred = error.credential;

    // Step 3: Save the pending credential in temporary storage,

    // Step 4: Let the user know that they already have an account
    // but with a different provider, and let them choose another
    // sign-in method.
  }
}

// ...

try {
  // Step 5: Sign the user in using their chosen method.
  let result = await signInWithPopup(getAuth(), userSelectedProvider);

  // Step 6: Link to the Twitter credential.
  // TODO: implement `retrievePendingCred` for your app.
  let pendingCred = retrievePendingCred();

  if (pendingCred !== null) {
    // As you have access to the pending credential, you can directly call the
    // link method.
    let user = await linkWithCredential(result.user, pendingCred);
  }

  // Step 7: Continue to app.
} catch (error) {
  // ...
}

साइन-इन की प्रोसेस को मैन्युअल तरीके से मैनेज करना

Twitter खाते का इस्तेमाल करके भी Firebase की पुष्टि की जा सकती है. ऐसा करने के लिए, Twitter OAuth एंडपॉइंट को कॉल करके साइन-इन फ़्लो को मैनेज करें:

1. डेवलपर के दस्तावेज़ में दिए गए निर्देशों का पालन करके, अपने ऐप्लिकेशन में Twitter की पुष्टि करने की सुविधा इंटिग्रेट करें. Twitter पर साइन इन फ़्लो के खत्म होने पर, आपको एक OAuth ऐक्सेस टोकन और एक OAuth सीक्रेट मिलेगा.
2. अगर आपको Node.js ऐप्लिकेशन पर साइन इन करना है, तो Node.js ऐप्लिकेशन पर OAuth ऐक्सेस टोकन और OAuth सीक्रेट भेजें.
3. जब कोई उपयोगकर्ता Twitter पर साइन इन कर लेता है, तब OAuth ऐक्सेस टोकन और OAuth सीक्रेट को Firebase क्रेडेंशियल से एक्सचेंज करें:

   var credential = firebase.auth.TwitterAuthProvider.credential(token, secret);
   

4. Firebase क्रेडेंशियल का इस्तेमाल करके, Firebase से पुष्टि करें:

   वेब मॉड्यूलर एपीआई

   import { getAuth, signInWithCredential, FacebookAuthProvider } from "firebase/auth";
   
   // Sign in with the credential from the Facebook user.
   const auth = getAuth();
   signInWithCredential(auth, credential)
     .then((result) => {
       // Signed in 
       const credential = FacebookAuthProvider.credentialFromResult(result);
     })
     .catch((error) => {
       // Handle Errors here.
       const errorCode = error.code;
       const errorMessage = error.message;
       // The email of the user's account used.
       const email = error.customData.email;
       // The AuthCredential type that was used.
       const credential = FacebookAuthProvider.credentialFromError(error);
       // ...
     });
   auth_facebook_signin_credential.js

   वेब नेमस्पेसेड एपीआई

   // Sign in with the credential from the Facebook user.
   firebase.auth().signInWithCredential(credential)
     .then((result) => {
       // Signed in       
       var credential = result.credential;
       // ...
     })
     .catch((error) => {
       // Handle Errors here.
       var errorCode = error.code;
       var errorMessage = error.message;
       // The email of the user's account used.
       var email = error.email;
       // The firebase.auth.AuthCredential type that was used.
       var credential = error.credential;
       // ...
     });
   facebook.js

Chrome एक्सटेंशन में Firebase की मदद से पुष्टि करें

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

अगले चरण

जब कोई उपयोगकर्ता पहली बार साइन इन करता है, तो एक नया उपयोगकर्ता खाता बनाया जाता है और उपयोगकर्ता के क्रेडेंशियल से लिंक किया जाता है. इन क्रेडेंशियल में उपयोगकर्ता नाम और पासवर्ड, फ़ोन नंबर या पुष्टि करने वाली सेवा की जानकारी शामिल है. यह नया खाता आपके Firebase प्रोजेक्ट के हिस्से के तौर पर सेव किया जाता है. साथ ही, इसका इस्तेमाल आपके प्रोजेक्ट के हर ऐप्लिकेशन में किसी उपयोगकर्ता की पहचान करने के लिए किया जा सकता है. भले ही, उपयोगकर्ता ने किसी भी तरह से साइन इन किया हो.

• हमारा सुझाव है कि आप अपने ऐप्लिकेशन में, उपयोगकर्ता की पुष्टि की स्थिति जानने के लिए Auth ऑब्जेक्ट पर एक ऑब्ज़र्वर सेट करें. इसके बाद, User ऑब्जेक्ट से उपयोगकर्ता की प्रोफ़ाइल की बुनियादी जानकारी पाई जा सकती है. उपयोगकर्ताओं को मैनेज करें देखें.

• अपने Firebase रीयल टाइम डेटाबेस और Cloud Storage के सुरक्षा नियमों में, auth वैरिएबल से साइन-इन किए हुए उपयोगकर्ता का यूनीक यूज़र आईडी पाया जा सकता है और उसका इस्तेमाल करके यह कंट्रोल किया जा सकता है कि उपयोगकर्ता कौनसा डेटा ऐक्सेस कर सकता है.

आप पुष्टि करने वाली सेवा देने वाली कंपनियों के क्रेडेंशियल को किसी मौजूदा उपयोगकर्ता खाते से लिंक करके, उपयोगकर्ताओं को अपने ऐप्लिकेशन में साइन इन करने की अनुमति दे सकते हैं.

किसी उपयोगकर्ता को साइन आउट करने के लिए, signOut पर कॉल करें:

import { getAuth, signOut } from "firebase/auth";

const auth = getAuth();
signOut(auth).then(() => {
  // Sign-out successful.
}).catch((error) => {
  // An error happened.
});
auth_sign_out.js

firebase.auth().signOut().then(() => {
  // Sign-out successful.
}).catch((error) => {
  // An error happened.
});
index.js