रीयलटाइम डेटाबेस ट्रिगर

Cloud Functions की मदद से, आप Firebase रीयल टाइम डेटाबेस के लिए, क्लाइंट कोड अपडेट करने की ज़रूरत नहीं होती. Cloud Functions की मदद से, पूरे एडमिन के साथ रीयल टाइम डेटाबेस ऑपरेशन चलाए जा सकते हैं और पक्का करता है कि रीयलटाइम डेटाबेस में किया गया हर बदलाव प्रोसेस हो जाए अलग-अलग करें. Firebase रीयल टाइम डेटाबेस में बदलाव किए जा सकते हैं. इसके लिए, DataSnapshot यह जानकारी, एडमिन SDK टूल की मदद से ली जा सकती है.

किसी सामान्य लाइफ़साइकल में, Firebase रीयल टाइम डेटाबेस फ़ंक्शन ये काम करता है:

1. किसी खास रीयल टाइम डेटाबेस की जगह में बदलाव का इंतज़ार करता है.
2. यह तब ट्रिगर होता है, जब कोई इवेंट होता है और अपने टास्क पूरे करते हैं (देखें कि मैं क्या करूं साथ ही, Cloud Functions वाला है? इस्तेमाल के उदाहरण).
3. ऐसा डेटा ऑब्जेक्ट मिलता है जिसमें सेव किए गए डेटा का स्नैपशॉट होता है दिए गए दस्तावेज़ में मौजूद है.

रीयलटाइम डेटाबेस फ़ंक्शन को ट्रिगर करना

रीयलटाइम डेटाबेस इवेंट के लिए नए फ़ंक्शन बनाना functions.database के साथ. यहां की यात्रा पर हूं फ़ंक्शन के ट्रिगर होने पर कंट्रोल करें, कोई एक इवेंट हैंडलर तय करें और रीयलटाइम डेटाबेस पाथ की जानकारी दें, जहां यह इवेंट सुनेगा.

इवेंट हैंडलर सेट करना

फ़ंक्शन की मदद से, रीयलटाइम डेटाबेस इवेंट को खासियत के दो लेवल पर मैनेज किया जा सकता है; हालाँकि, खास तौर पर सिर्फ़ कॉन्टेंट बनाने, उसे अपडेट करने, और या मिटाने की घटनाओं को सुन सकते हैं, या फिर पाथ में किसी भी तरह के बदलाव को सुन सकते हैं. Cloud Functions, रीयलटाइम डेटाबेस के लिए इन इवेंट हैंडलर के साथ काम करता है:

• onWrite(), यह तब ट्रिगर होता है, जब रीयलटाइम डेटाबेस में डेटा बनाया जाता है, अपडेट किया जाता है या मिटाया जाता है.
• onCreate(), जो रीयलटाइम डेटाबेस में नया डेटा बनाए जाने पर ट्रिगर होती है.
• onUpdate(), जो रीयलटाइम डेटाबेस में डेटा के अपडेट होने पर ट्रिगर होती है .
• onDelete(), यह तब ट्रिगर होता है, जब रीयलटाइम डेटाबेस से डेटा मिटाया जाता है .

इंस्टेंस और पाथ के बारे में बताएं

यह कंट्रोल करने के लिए कि आपका फ़ंक्शन कब और कहां ट्रिगर हो, ref(path) को कॉल करें और रीयलटाइम डेटाबेस इंस्टेंस के बारे में बताएं. instance('INSTANCE_NAME') के साथ. अगर आपको किसी इंस्टेंस के बारे में बताने पर फ़ंक्शन, Firebase प्रोजेक्ट. उदाहरण के लिए:

• डिफ़ॉल्ट रीयल टाइम डेटाबेस इंस्टेंस: functions.database.ref('/foo/bar')
• "my-app-db-2" नाम का इंस्टेंस: functions.database.instance('my-app-db-2').ref('/foo/bar')

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

 /foo/bar
 /foo/bar/baz/really/deep/path

दोनों ही मामलों में, Firebase यह समझता है कि इवेंट /foo/bar पर होगा, और इवेंट डेटा में /foo/bar पर पुराना और नया डेटा. अगर इवेंट डेटा बड़ा हो सकता है, एक के बजाय डीप पाथ पर कई फ़ंक्शन का इस्तेमाल करने के बारे में सोचें फ़ंक्शन को अपने डेटाबेस के रूट के पास रखें. सबसे अच्छी परफ़ॉर्मेंस के लिए, सिर्फ़ अनुरोध करें डेटा को ज़्यादा गहराई से इकट्ठा किया जा सकता है.

आपके पास पाथ कॉम्पोनेंट को कर्ली के साथ आस-पास रखकर, पाथ कॉम्पोनेंट को वाइल्डकार्ड के तौर पर तय करने का विकल्प है ब्रैकेट; ref('foo/{bar}'), /foo के किसी भी चाइल्ड से मेल खाता है. इन इवेंट की वैल्यू वाइल्डकार्ड पाथ घटक EventContext.params आपके फ़ंक्शन का ऑब्जेक्ट. इस उदाहरण में, वैल्यू इस तरह से उपलब्ध है context.params.bar.

वाइल्डकार्ड वाले पाथ, एक ही लिखने से कई इवेंट को मैच कर सकते हैं. इसका एक निवेश

{
  "foo": {
    "hello": "world",
    "firebase": "functions"
  }
}

पथ "/foo/{bar}" से दो बार मेल खाता है: एक बार "hello": "world" के साथ और फिर "firebase": "functions" के साथ.

इवेंट डेटा मैनेज करना

किसी रीयलटाइम डेटाबेस इवेंट को हैंडल करते समय, लौटाया गया डेटा ऑब्जेक्ट एक DataSnapshot. onWrite या onUpdate इवेंट के लिए, पहला पैरामीटर एक Change ऑब्जेक्ट है, जिसमें दो स्नैपशॉट हैं जो पहले डेटा की स्थिति को दिखाती हैं और ट्रिगर करने वाले इवेंट के बाद दिखेगा. onCreate और onDelete इवेंट के लिए, वापस किया गया डेटा ऑब्जेक्ट, बनाए या मिटाए गए डेटा का स्नैपशॉट होता है.

इस उदाहरण में, फ़ंक्शन बताया गया पाथ, उस जगह की स्ट्रिंग को अपरकेस में बदल देता है, और उस संशोधित स्ट्रिंग को डेटाबेस में लिखता है:

// Listens for new messages added to /messages/:pushId/original and creates an
// uppercase version of the message to /messages/:pushId/uppercase
exports.makeUppercase = functions.database.ref('/messages/{pushId}/original')
    .onCreate((snapshot, context) => {
      // Grab the current value of what was written to the Realtime Database.
      const original = snapshot.val();
      functions.logger.log('Uppercasing', context.params.pushId, original);
      const uppercase = original.toUpperCase();
      // You must return a Promise when performing asynchronous tasks inside a Functions such as
      // writing to the Firebase Realtime Database.
      // Setting an "uppercase" sibling in the Realtime Database returns a Promise.
      return snapshot.ref.parent.child('uppercase').set(uppercase);
    });
index.js

उपयोगकर्ता की पुष्टि करने की जानकारी को ऐक्सेस करना

EventContext.auth से और EventContext.authType, तो तुम ऐक्सेस कर सकती हो ट्रिगर किए गए उपयोगकर्ता की अनुमतियां सहित उपयोगकर्ता की जानकारी एक फ़ंक्शन का इस्तेमाल करें. यह सुरक्षा नियमों, इससे आपके फ़ंक्शन को उपयोगकर्ता की प्रॉपर्टी के आधार पर अलग-अलग कार्रवाइयां करने की अनुमति मिलती है अनुमतियों का लेवल:

const functions = require('firebase-functions');
const admin = require('firebase-admin');

exports.simpleDbFunction = functions.database.ref('/path')
    .onCreate((snap, context) => {
      if (context.authType === 'ADMIN') {
        // do something
      } else if (context.authType === 'USER') {
        console.log(snap.val(), 'written by', context.auth.uid);
      }
    });

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

exports.impersonateMakeUpperCase = functions.database.ref('/messages/{pushId}/original')
    .onCreate((snap, context) => {
      const appOptions = JSON.parse(process.env.FIREBASE_CONFIG);
      appOptions.databaseAuthVariableOverride = context.auth;
      const app = admin.initializeApp(appOptions, 'app');
      const uppercase = snap.val().toUpperCase();
      const ref = snap.ref.parent.child('uppercase');

      const deleteApp = () => app.delete().catch(() => null);

      return app.database().ref(ref).set(uppercase).then(res => {
        // Deleting the app is necessary for preventing concurrency leaks
        return deleteApp().then(() => res);
      }).catch(err => {
        return deleteApp().then(() => Promise.reject(err));
      });
    });

पिछली वैल्यू पढ़ना

Change ऑब्जेक्ट में before प्रॉपर्टी की मदद से, इस बात की जांच की जा सकती है कि रीयलटाइम डेटाबेस में सेव की गई जानकारी से पहले इवेंट. before प्रॉपर्टी एक DataSnapshot दिखाती है, जहां सभी तरीके (उदाहरण के लिए, val() और exists()) पिछली वैल्यू देखें. इनमें से किसी एक विकल्प का इस्तेमाल करके, नई वैल्यू को फिर से पढ़ा जा सकता है ओरिजनल DataSnapshot को पढ़ने के लिए after प्रॉपर्टी. किसी भी Change पर मौजूद यह प्रॉपर्टी, एक और DataSnapshot है जो इवेंट होने के बाद के डेटा की स्थिति.

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

exports.makeUppercase = functions.database.ref('/messages/{pushId}/original')
    .onWrite((change, context) => {
      // Only edit data when it is first created.
      if (change.before.exists()) {
        return null;
      }
      // Exit when the data is deleted.
      if (!change.after.exists()) {
        return null;
      }
      // Grab the current value of what was written to the Realtime Database.
      const original = change.after.val();
      console.log('Uppercasing', context.params.pushId, original);
      const uppercase = original.toUpperCase();
      // You must return a Promise when performing asynchronous tasks inside a Functions such as
      // writing to the Firebase Realtime Database.
      // Setting an "uppercase" sibling in the Realtime Database returns a Promise.
      return change.after.ref.parent.child('uppercase').set(uppercase);
    });