meteor
Daten veröffentlichen

Bemerkungen

Basis-Abonnement und Veröffentlichung

Entfernen Sie zunächst die autopublish . autopublish automatisch die gesamte Datenbank auf der Client-Seite, sodass die Auswirkungen von Publikationen und Abonnements nicht sichtbar sind.

So entfernen Sie die autopublish :

$ meteor remove autopublish

Dann können Sie Publikationen erstellen. Unten ist ein vollständiges Beispiel.

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');
  })
}

Globale Veröffentlichungen

Eine globale Publikation besitzt keinen Namen und erfordert kein Abonnement vom verbundenen Client. Daher steht sie dem verbundenen Client zur Verfügung, sobald der Client eine Verbindung zum Server herstellt.

Um dies zu erreichen, nennt man die Publikation einfach als null

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

Benannte Publikationen

Eine benannte Publikation besitzt einen Namen und muss explizit vom Client abonniert werden.

Betrachten Sie diesen serverseitigen Code:

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

Der Kunde muss es anfordern durch:

Meteor.subscribe('somePublication')

Abonnements mit Vorlagenbereich

Meteors Standard-Templatiersystem Leertasten und das zugrunde liegende Rendering-Subsystem Blaze integriert sich nahtlos in Publikationslebenszyklusmethoden, sodass ein einfacher Vorlagencode seine eigenen Daten abonnieren und seine eigenen Spuren während des Abreißvorgangs der Vorlage stoppen und bereinigen kann.

Um dies zu erschließen, muss man die Template-Instanz abonnieren und nicht das Meteor Symbol wie folgt:

Richten Sie zuerst die Vorlage ein

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

Tippen Sie dann auf den entsprechenden Lifecycle-Callback

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

Wenn diese Vorlage nun zerstört wird, wird auch die Veröffentlichung automatisch gestoppt.

Hinweis: Die abonnierten Daten stehen allen Vorlagen zur Verfügung.

In einer ephemeren clientseitigen Sammlung veröffentlichen.

Für, wenn Sie das, was veröffentlicht wird, verfeinern müssen.

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));
  });
}

Fehler in einer Publikation erstellen und darauf reagieren

Auf dem Server können Sie eine solche Veröffentlichung erstellen. this.userId ist die ID des aktuell angemeldeten Benutzers. Wenn kein Benutzer angemeldet ist, möchten Sie möglicherweise einen Fehler this.userId und darauf reagieren.

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();
  }
});

Auf dem Client können Sie mit den folgenden Antworten antworten.

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

Datei / Importe / Sammlungen / Geheimnisse erstellt einen Verweis auf die Geheimnisse-Sammlung wie folgt:

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

Erneutes Abonnieren einer Publikation

Ein Vorlagenautorun kann verwendet werden, um eine Publikation (erneut) zu abonnieren. Es wird ein reaktiver Kontext erstellt, der immer dann ausgeführt wird, wenn reaktive Daten von Änderungen abhängen . Außerdem wird ein Autorun immer einmal ausgeführt (beim ersten Ausführen).

Vorlagenautoruns werden normalerweise in eine onCreated Methode geschrieben.

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

Dies wird einmalig (das erste Mal) ausgeführt und ein Abonnement eingerichtet. Sie wird dann erneut ausgeführt, wenn sich die parameter Blindgröße ändert.

Warten Sie in der Blaze-Ansicht, während veröffentlichte Daten abgerufen werden

Template JS-Code

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

Vorlagen-HTML-Code

<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>

Überprüfen des Benutzerkontos beim Veröffentlichen

Manchmal ist es eine gute Idee, Ihre Veröffentlichungen weiter zu schützen, indem Sie ein Benutzer-Login erfordern. So erreichen Sie dies über Meteor.

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 [];
  }
});

Veröffentlichen Sie mehrere Cursor

Mehrere Datenbankcursor können aus derselben Publikationsmethode veröffentlicht werden, indem ein Array von Cursor zurückgegeben wird.

Die "Kinder" -Cursors werden als Joins behandelt und sind nicht reaktiv.

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];
});

Simulieren Sie die Verzögerung in Publikationen

In der Meteor._sleepForMs(ms); Verzögerungen in Verbindung und Server auftreten, um Verzögerungen in der Entwicklungsumgebung zu simulieren. Meteor._sleepForMs(ms); könnte verwendet werden

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

Publikationen zusammenführen

Publikationen können auf dem Client zusammengeführt werden, was zu unterschiedlich geformten Dokumenten innerhalb eines einzelnen Cursors führt. Das folgende Beispiel zeigt, wie ein Benutzerverzeichnis eine minimale Menge öffentlicher Daten für Benutzer einer App veröffentlicht und ein detaillierteres Profil für den angemeldeten Benutzer bereitstellt.

// 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
    }});
});