Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

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

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

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

Firebase SDK की मदद से, साइन-इन फ़्लो को मैनेज करना

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

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

Twitter सेवा देने वाली कंपनी के ऑब्जेक्ट का इंस्टेंस बनाएं:

Web

import { TwitterAuthProvider } from "firebase/auth";

const provider = new TwitterAuthProvider();auth_twitter_provider_create.js

Web

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

ज़रूरी नहीं: अगर आपको OAuth फ़्लो को उपयोगकर्ता की पसंदीदा भाषा में बदलना है, तो आपको OAuth के कस्टम पैरामीटर पास करने की ज़रूरत नहीं है. इसके लिए, OAuth फ़्लो शुरू करने से पहले, Auth इंस्टेंस पर भाषा का कोड अपडेट करें. उदाहरण के लिए:
Web
```
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
```
Web
```
firebase.auth().languageCode = 'it';
// To apply the default browser preference instead of explicitly setting it.
// firebase.auth().useDeviceLanguage();index.js
```
ज़रूरी नहीं: OAuth अनुरोध के साथ भेजने के लिए, OAuth सेवा देने वाली कंपनी के अतिरिक्त कस्टम पैरामीटर तय करें. कस्टम पैरामीटर जोड़ने के लिए, शुरू किए गए प्रोवाइडर पर setCustomParameters को कॉल करें. इसमें एक ऐसा ऑब्जेक्ट शामिल होता है जिसमें OAuth प्रोवाइडर के दस्तावेज़ में बताई गई कुंजी और उससे जुड़ी वैल्यू होती है. उदाहरण के लिए:
Web
```
provider.setCustomParameters({
  'lang': 'es'
});auth_twitter_provider_params.js
```
Web
```
provider.setCustomParameters({
  'lang': 'es'
});twitter.js
```
रिज़र्व किए गए ज़रूरी OAuth पैरामीटर का इस्तेमाल नहीं किया जा सकता. इन्हें अनदेखा कर दिया जाएगा. ज़्यादा जानकारी के लिए, Authentication Provider का रेफ़रंस देखें.

Twitter provider ऑब्जेक्ट का इस्तेमाल करके, Firebase से पुष्टि करें. अपने उपयोगकर्ताओं को Twitter खातों से साइन इन करने के लिए कहा जा सकता है. इसके लिए, पॉप-अप विंडो खोलें या उन्हें साइन-इन पेज पर रीडायरेक्ट करें. मोबाइल डिवाइसों पर रीडायरेक्ट करने का तरीका बेहतर होता है.

पॉप-अप विंडो की मदद से साइन इन करने के लिए, signInWithPopup को कॉल करें:

Web

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

Web

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 की मदद से, अतिरिक्त डेटा फ़ेच करने के लिए किया जा सकता है.

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

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

Web

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

const auth = getAuth();
signInWithRedirect(auth, provider);auth_signin_redirect.js

Web

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

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

Web

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

Web

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

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

account-exists-with-different-credential गड़बड़ियों को ठीक करना

अगर आपने Firebase कंसोल में, हर ईमेल पते के लिए एक खाता सेटिंग चालू की है, तो जब कोई उपयोगकर्ता किसी ऐसे ईमेल पते से Twitter जैसे किसी सेवा देने वाले प्लैटफ़ॉर्म में साइन इन करने की कोशिश करता है जो पहले से ही Firebase के किसी अन्य उपयोगकर्ता के लिए मौजूद है, तो उसे auth/account-exists-with-different-credential गड़बड़ी का मैसेज मिलता है. साथ ही, उसे AuthCredential ऑब्जेक्ट (Twitter का OAuth टोकन और सीक्रेट) मिलता है. सेवा देने वाले प्लैटफ़ॉर्म में साइन इन करने के लिए, उपयोगकर्ता को पहले Google में साइन इन करना होगा. इसके बाद, उसे AuthCredential (Twitter का OAuth टोकन और सीक्रेट) से लिंक करना होगा.

signInWithPopup का इस्तेमाल करने पर, auth/account-exists-with-different-credential से जुड़ी गड़बड़ियों को इस तरह के कोड से ठीक किया जा सकता है:

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 एंडपॉइंट को कॉल करके, साइन-इन फ़्लो को मैनेज करें:

डेवलपर के दस्तावेज़ में दिए गए निर्देशों का पालन करके, अपने ऐप्लिकेशन में Twitter की पुष्टि करने की सुविधा इंटिग्रेट करें. Twitter से साइन-इन करने की प्रोसेस पूरी होने के बाद, आपको OAuth ऐक्सेस टोकन और OAuth सीक्रेट मिलेगा.
अगर आपको Node.js ऐप्लिकेशन पर साइन इन करना है, तो Node.js ऐप्लिकेशन को OAuth ऐक्सेस टोकन और OAuth सीक्रेट भेजें.
जब कोई उपयोगकर्ता Twitter खाते से साइन इन कर लेता है, तो OAuth ऐक्सेस टोकन और OAuth सीक्रेट को Firebase क्रेडेंशियल के लिए एक्सचेंज करें:
```
var credential = firebase.auth.TwitterAuthProvider.credential(token, secret);
```

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

Web

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

Web

// 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 आपके प्रोजेक्ट के लिए एक यूनीक सबडोमेन उपलब्ध कराएगा: https://my-app-12345.firebaseapp.com.

इसका इस्तेमाल, OAuth से साइन इन करने के लिए रीडायरेक्ट करने के तरीके के तौर पर भी किया जाएगा. इस डोमेन को, OAuth की सुविधा देने वाली सभी कंपनियों के लिए अनुमति देनी होगी. हालांकि, इसका मतलब यह है कि Twitter में साइन इन करते समय, उपयोगकर्ताओं को यह डोमेन दिख सकता है. इसके बाद, उन्हें वापस ऐप्लिकेशन पर रीडायरेक्ट किया जाएगा: जारी रखें: https://my-app-12345.firebaseapp.com.

अपने सबडोमेन को दिखने से रोकने के लिए, Firebase Hosting के साथ कस्टम डोमेन सेट अप करें:

Hosting के लिए अपना डोमेन सेट अप करें में दिए गए पहले से तीसरे चरण तक की प्रोसेस पूरी करें. डोमेन के मालिकाना हक की पुष्टि करने पर, Hosting आपके कस्टम डोमेन के लिए एसएसएल सर्टिफ़िकेट उपलब्ध कराता है.
Firebase कंसोल में, अनुमति वाले डोमेन की सूची में अपना कस्टम डोमेन जोड़ें: auth.custom.domain.com.
Twitter डेवलपर कंसोल या OAuth सेटअप पेज में, रीडायरेक्ट पेज के यूआरएल को श्वेतसूची में शामिल करें. यह यूआरएल आपके कस्टम डोमेन पर ऐक्सेस किया जा सकेगा: https://auth.custom.domain.com/__/auth/handler.

JavaScript लाइब्रेरी शुरू करते समय, authDomain फ़ील्ड की मदद से अपने कस्टम डोमेन के बारे में बताएं:

var config = {
  apiKey: '...',
  // Changed from 'PROJECT_ID.firebaseapp.com'.
  authDomain: 'auth.custom.domain.com',
  databaseURL: 'https://PROJECT_ID.firebaseio.com',
  projectId: 'PROJECT_ID',
  storageBucket: 'PROJECT_ID.firebasestorage.app',
  messagingSenderId: 'SENDER_ID'
};
firebase.initializeApp(config);

अगले चरण

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

अपने ऐप्लिकेशन में, उपयोगकर्ता की पुष्टि की स्थिति जानने के लिए, हमारा सुझाव है कि आप Auth ऑब्जेक्ट पर एक ऑब्ज़र्वर सेट करें. इसके बाद, User ऑब्जेक्ट से उपयोगकर्ता की बुनियादी प्रोफ़ाइल की जानकारी पाई जा सकती है. उपयोगकर्ताओं को मैनेज करना लेख पढ़ें.
Firebase Realtime Database और Cloud Storage सुरक्षा के नियमों में, auth वैरिएबल से साइन इन किए हुए उपयोगकर्ता का यूनीक User-ID पाया जा सकता है. साथ ही, इसका इस्तेमाल यह कंट्रोल करने के लिए किया जा सकता है कि कोई उपयोगकर्ता किस डेटा को ऐक्सेस कर सकता है.

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

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

Web

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

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

Web

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