meteor
प्रकाशन डेटा

टिप्पणियों

मूल सदस्यता और प्रकाशन

सबसे पहले, autopublish हटा autopublish । autopublish पूरे डेटाबेस को क्लाइंट-साइड में स्वचालित रूप से प्रकाशित करता है, और इसलिए प्रकाशनों और सदस्यता के प्रभावों को नहीं देखा जा सकता है।

autopublish : autopublish हटाने के लिए:

$ meteor remove autopublish

फिर आप प्रकाशन बना सकते हैं। नीचे एक पूर्ण उदाहरण है।

import { Mongo } from 'meteor/mongo';
import { Meteor } from 'meteor/meteor';

const Todos = new Mongo.Collection('todos');

const TODOS = [
  { title: 'Create documentation' },
  { title: 'Submit to Stack Overflow' }
];

if (Meteor.isServer) {
  Meteor.startup(function () {
    TODOS.forEach(todo => {
      Todos.upsert(
        { title: todo.title },
        { $setOnInsert: todo }
      );
    });
  });

  // first parameter is a name.
  Meteor.publish('todos', function () {
    return Todos.find();
  });
}

if (Meteor.isClient) {
  // subscribe by name to the publication.
  Meteor.startup(function () {
    Meteor.subscribe('todos');
  })
}

वैश्विक प्रकाशन

एक वैश्विक प्रकाशन के पास नाम नहीं होता है और उसे कनेक्टेड क्लाइंट से सदस्यता की आवश्यकता नहीं होती है और इसलिए जैसे ही क्लाइंट सर्वर से जुड़ता है, यह कनेक्टेड क्लाइंट के लिए उपलब्ध होता है।

इस लक्ष्य को हासिल करने के लिए, एक बस नाम के रूप में प्रकाशन null इसलिए की तरह

Meteor.publish(null, function() {
  return SomeCollection.find();
})

नामांकित प्रकाशन

एक नामांकित प्रकाशन वह है जिसमें एक नाम होता है और क्लाइंट से स्पष्ट रूप से सदस्यता लेने की आवश्यकता होती है।

इस सर्वर साइड कोड पर विचार करें:

Meteor.publish('somePublication', function() {
  return SomeCollection.find()
})

ग्राहक को इसके लिए अनुरोध करना होगा:

Meteor.subscribe('somePublication')

टेम्पलेट ने सदस्यता रद्द कर दी

उल्का के डिफॉल्ट टेम्प्लेटिंग सिस्टम स्पेसबार और इसके अंतर्निहित रेंडरिंग सबसिस्टम ब्लेज़ को प्रकाशन जीवनचक्र विधियों के साथ एकीकृत रूप से एकीकृत करते हैं, ताकि टेम्प्लेट कोड का एक साधारण टुकड़ा अपने स्वयं के डेटा की सदस्यता ले सके, टेम्प्लेट आंसू के दौरान अपने स्वयं के निशान को रोक और साफ कर सके।

इस तरह से टैप करने के लिए, किसी को टेम्पलेट उदाहरण पर सब्सक्राइब करने की ज़रूरत होती है, न कि Meteor प्रतीक की तरह।

पहले टेम्पलेट सेट करें

<template name="myTemplate">
  We will use some data from a publication here
</template>

फिर संबंधित जीवनचक्र कॉलबैक में टैप करें

Template.myTemplate.onCreated(function() {
  const templateInstance = this;
  templateInstance.subscribe('somePublication')
})

अब जब यह खाका नष्ट हो जाएगा, तो प्रकाशन भी अपने आप बंद हो जाएगा।

नोट: जिस डेटा को सब्सक्राइब किया गया है, वह सभी टेम्प्लेट में उपलब्ध होगा।

संग्रह नाम के एक अल्पकालिक ग्राहक पक्ष में प्रकाशित करें।

के लिए यदि आपको ठीक-ठीक लिखना है जो प्रकाशित है।

import { Mongo } from 'meteor/mongo';
import { Meteor } from 'meteor/meteor';
import { Random } from 'meteor/random';

if (Meteor.isClient) {
  // established this collection on the client only.
  // a name is required (first parameter) and this is not persisted on the server.
  const Messages = new Mongo.Collection('messages');
  Meteor.startup(function () {
    Meteor.subscribe('messages');
    Messages.find().observe({
      added: function (message) {
        console.log('Received a new message at ' + message.timestamp);
      }
    });
  })
}

if (Meteor.isServer) {
  // this will add a new message every 5 seconds.
  Meteor.publish('messages', function () {
    const interval = Meteor.setInterval(() => {
      this.added('messages', Random.id(), {
        message: '5 seconds have passed',
        timestamp: new Date()
      })
    }, 5000);
    this.added('messages', Random.id(), {
      message: 'First message',
      timestamp: new Date()
    });
    this.onStop(() => Meteor.clearInterval(interval));
  });
}

किसी प्रकाशन पर एक त्रुटि बनाने और प्रतिक्रिया देने के लिए।

सर्वर पर, आप इस तरह से एक प्रकाशन बना सकते हैं। this.userId उस उपयोगकर्ता की आईडी है जो वर्तमान में लॉग इन है। यदि कोई उपयोगकर्ता लॉग इन नहीं है, तो आप एक त्रुटि फेंक सकते हैं और उस पर प्रतिक्रिया दे सकते हैं।

import Secrets from '/imports/collections/Secrets';

Meteor.publish('protected_data', function () {
  if (!this.userId) {
    this.error(new Meteor.Error(403, "Not Logged In."));
    this.ready();
  } else {
    return Secrets.find();
  }
});

क्लाइंट पर, आप निम्न के साथ प्रतिक्रिया कर सकते हैं।

Meteor.subscribe('protected_data', {
  onError(err) {
    if (err.error === 403) {
      alert("Looks like you're not logged in");
    }
  },
});

फ़ाइल / आयात / संग्रह / रहस्य नीचे के रूप में रहस्य संग्रह के संदर्भ बनाता है:

const Secrets = new Mongo.Collection('secrets');

किसी प्रकाशन के लिए पुन: सदस्यता लेना

एक टेम्प्लेट ऑटोरन का उपयोग प्रकाशन के लिए (पुनः) सदस्यता के लिए किया जा सकता है। यह एक प्रतिक्रियाशील संदर्भ स्थापित करता है जिसे किसी भी प्रतिक्रियाशील डेटा को जब भी परिवर्तनों पर निर्भर किया जाता है, उसे फिर से निष्पादित किया जाता है । इसके अलावा, एक ऑटोरन हमेशा एक बार चलता है (पहली बार इसे निष्पादित किया जाता है)।

टेम्प्लेट ऑटोरन को आम तौर पर onCreated विधि से डाला जाता है।

Template.myTemplate.onCreated(function() {
  this.parameter = new ReactiveVar();
  this.autorun(() => {
    this.subscribe('myPublication', this.parameter.get());
  });
});

यह एक बार (पहली बार) चलेगा और एक सदस्यता स्थापित करेगा। जब भी parameter प्रतिक्रियाशील चर बदलता है, तब इसे फिर से चलाया जाएगा।

ब्लेज़ दृश्य में प्रतीक्षा करें जब प्रकाशित डेटा लाया जा रहा हो

टेम्पलेट जेएस कोड

Template.templateName.onCreated(function(){
    this.subscribe('subsription1');
    this.subscribe('subscription2');
});

टेम्पलेट HTML कोड

<template name="templateName">
    {{#if Template.subscriptionsReady }}
        //your actual view with data. it can be plain HTML or another template
    {{else}}
        //you can use any loader or a simple header
        <h2> Please wait ... </h2>
    {{/if}}
</template>

प्रकाशन पर उपयोगकर्ता खाता मान्य करना

कभी-कभी उपयोगकर्ता लॉगिन की आवश्यकता के द्वारा अपने प्रकाशनों को और सुरक्षित करना एक अच्छा विचार है। यहाँ आप उल्का के माध्यम से इसे कैसे प्राप्त करते हैं।

import { Recipes } from '../imports/api/recipes.js';
import { Meteor } from 'meteor/meteor';

Meteor.publish('recipes', function() {
  if(this.userId) {
    return Recipe.find({});
  } else {
    this.ready();  // or: return [];
  }
});

कई कर्सर प्रकाशित करें

कई डेटाबेस कर्सर को एक ही प्रकाशन विधि से प्रकाशित किया जा सकता है, जो कि कर्सर की एक सरणी लौटाते हैं।

"बच्चों" के शाप देने वालों को जोड़ के रूप में माना जाएगा और प्रतिक्रियाशील नहीं होगा।

Meteor.publish('USER_THREAD', function(postId) {
  let userId   = this.userId;

  let comments = Comments.find({ userId, postId });
  let replies  = Replies.find({ userId, postId });

  return [comments, replies];
});

प्रकाशनों में देरी का अनुकरण करें

वास्तविक दुनिया में, कनेक्शन और सर्वर देरी विकास पर्यावरण में देरी का अनुकरण करने के लिए हो सकता है Meteor._sleepForMs(ms); इस्तेमाल किया जा सकता है

Meteor.publish('USER_DATA', function() {
    Meteor._sleepForMs(3000); // Simulate 3 seconds delay
    return Meteor.users.find({});
});

प्रकाशनों को विलय करना

प्रकाशनों को क्लाइंट पर मर्ज किया जा सकता है, जिसके परिणामस्वरूप एकल कर्सर के भीतर अलग-अलग आकार के दस्तावेज़ होते हैं। निम्न उदाहरण बताता है कि उपयोगकर्ता निर्देशिका किसी ऐप के उपयोगकर्ताओं के लिए न्यूनतम डेटा कैसे प्रकाशित कर सकती है, और उपयोगकर्ता में लॉग इन के लिए अधिक विस्तृत प्रोफ़ाइल प्रदान करती है।

// client/subscriptions.js  
Meteor.subscribe('usersDirectory');
Meteor.subscribe('userProfile', Meteor.userId());

// server/publications.js  
// Publish users directory and user profile

Meteor.publish("usersDirectory", function (userId) {
    return Meteor.users.find({}, {fields: {
        '_id': true,
        'username': true,
        'emails': true,
        'emails[0].address': true,

        // available to everybody
        'profile': true,
        'profile.name': true,
        'profile.avatar': true,
        'profile.role': true
    }});
});
Meteor.publish('userProfile', function (userId) {
    return Meteor.users.find({_id: this.userId}, {fields: {
        '_id': true,
        'username': true,
        'emails': true,
        'emails[0].address': true,
    
        'profile': true,
        'profile.name': true,
        'profile.avatar': true,
        'profile.role': true,
    
        // privately accessible items, only availble to the user logged in
        'profile.visibility': true,
        'profile.socialsecurity': true,
        'profile.age': true,
        'profile.dateofbirth': true,
        'profile.zip': true,
        'profile.workphone': true,
        'profile.homephone': true,
        'profile.mobilephone': true,
        'profile.applicantType': true
    }});
});