anchor.diff:  http://sensit.meteor.com/sensit-callback/button?device_serial_number=ABCDE&notification_type=generic_punctual&data=%7B%22first_name%22%3A%22Anthonny%22%2C%22sensit_name%22%3A%22%22%2C%22last_name%22%3A%22Querouil%22%2C%22device_id%22%3A%22ABCDE%22%7D&device_id=1234&sensor_id=5678&date=2015-09-01T17%3A37Z&mode=6
   ----
   
  -Et vérifier que la notification est bien présente en base :
  +Enfin, on vérifie que la `notification` est bien présente en base :
   
   image::https://cloud.githubusercontent.com/assets/2006548/9630272/66e493a6-5179-11e5-9230-36ecf85d83e1.png[]
   
  -== Le client : sensit-meteor-rs
  -
  -Nous avons désormais un "backend" qui prend en compte les différentes notifications, il nous faut maintenant une application tournant *localement* et qui réagira aux changements qui surviennent dans le "backend".
  +== La local-app : sensit-meteor-rs
  +
  +Nous avons désormais un *backend* qui prend en compte les différentes notifications, il nous faut maintenant une application qui tournera *localement* et qui réagira aux changements qui surviennent dans le backend.
   
   
   === L'application
   
   [source,shell]
   ----
  -meteor create sensit-meteor-rs
  -cd sensit-meteor-rs
  +meteor create local-app
  +cd local-app
   meteor remove autopublish insecure
  -rm sensit-meteor-rs.*
  -mkdir server client shared
  -touch server/main.js client/main.js client/index.html
  -----
  -
  -Nous allons initier une connexion DDP avec notre backend et écouter les changements qui sont faits sur la collection `notification`.
  -
  -[source, javascript]
  -----
  +rm local-app.*
  +mkdir server
  +touch server/main.js
  +----
  +
  +Nous allons initier une connexion https://www.meteor.com/ddp[DDP] avec notre *backend* et écouter les changements qui sont faits sur la collection `notification`. 
  +Pour chaque notification ajoutée dans cette collection que nous appellerons `RemoteNotification`, nous ajouterons une copie dans notre collection *locale* `Notification` :
  +
  +[source, javascript]
  +----
  +// Déclaration de la connexion
   var remote = DDP.connect('http://sensit.meteor.com/');
  -var RButton = new Meteor.Collection('button', { connection: remote });
  -----
  +var RemoteNotification = new Meteor.Collection('notification', { connection: remote });
  +remote.subscribe('remote-button');
  +
  +// On écoute les changements effectués sur la collection en Remote
  +RemoteNotification.find().observe({
  +  added: function(notification) {
  +    console.log('-- remote item added --');
  +    // On upsert dans la collection de Notification locale
  +    Notification.upsert({notification._id}, {$set: notification});
  +  }
  +});
  +----
  +
  +
  +Il ne nous reste plus qu'à faire décoller le spider lorsqu'une `notification` est ajoutée en local :
  +
  +[source, javascript]
  +----
  +var rollingSpider = new RollingSpider();
  +
  +rollingSpider.connect(Meteor.bindEnvironment(function () {
  +  rollingSpider.setup(Meteor.bindEnvironment(function () {
  +    rollingSpider.flatTrim();
  +    rollingSpider.startPing();
  +    rollingSpider.flatTrim();
  +
  +    // On observe la collection Notification, au premier ajout on decolle !
  +    Notification.find().observe({
  +      added: function (notification) {
  +        rollingSpider.takeOff();
  +        rollingSpider.flatTrim();
  +      }
  +    });
  +  }));
  +}));
  +----
  +
  +Le code complet :
  +[source, javascript, title=local-app/server/main.js]
  +----
  +var Notification = new Meteor.Collection("notification");
  +var remote = DDP.connect('http://sensit.meteor.com/');
  +var RemoteNotification = new Meteor.Collection('notification', { connection: remote });
  +var isFlying = false;
  +
  +
  +RemoteNotification.find().observe({
  +  added: function(notification) {
  +    console.log('-- remote item --');
  +    console.log(notification);
  +    Notification.upsert({_id: notification._id}, {$set: notification});
  +  }
  +});
  +remote.subscribe('remote-button');
  +
  +rollingSpider.connect(Meteor.bindEnvironment(function () {
  +  rollingSpider.setup(Meteor.bindEnvironment(function () {
  +    rollingSpider.flatTrim();
  +    rollingSpider.startPing();
  +    rollingSpider.flatTrim();
  +
  +    Notification.find().observe({
  +      added: function (notification) {
  +        if (!isFlying) {
  +          isFlying = true;
  +          rollingSpider.takeOff();
  +          rollingSpider.flatTrim();
  +        }
  +      }
  +    });
  +  }));
  +}));
  +----
  +
  +
  +=== Décollage !
  +
  +video::8DY4bsKOm5g[youtube]
  +
  +== Conclusion
  +
  +Ce billet est l'occasion de mettre en avant la connexion entre deux applications https://www.meteor.com[Meteor] via le protocole https://www.meteor.com/ddp[DDP] et de vous montrer qu'avec du javascript, on se marre bien (en tout cas, c'est vrai pour moi :) ).
  +
  +Si vous avez des projets similaires, n'hésitez pas à m'en faire part, ce sera un plaisir d'échanger dessus.
  
positive.code:   });
  ----
  
  Nous définissons une route `/sensit-callback/:type` dans laquelle `:type` peut prendre les valeurs `['temperature', 'motion', 'button']`. 
  
  On construit ensuite un objet `notification` à partir du `type` et des queryParam (on force la conversion en JSON du paramètre `data` car c'est un objet JSON stringifié).
  
  Enfin on insert notre `notification` en base et on répond en confirmant l'enregistrement.
  
  Pour que les informations présentes dans notre collection soient accessibles par notre "client", il faut les publier (on peut déjà gérer les différents type) :
  
  [source, javascript]
  ----
  Meteor.publish("remote-button", function (argument) {
    return Notification.find({type: 'button'});
  });
  
  // on peut déjà prévoir de gérer les autres types
  Meteor.publish("remote-temperature", function (argument) {
    return Notification.find({type: 'temperature'});
  });
  
negative.code: 
  image::https://cloud.githubusercontent.com/assets/2006548/9587833/f979b92c-5024-11e5-9fbf-20a14b2594b8.png[title=Architecture cible]
  
  1. Le {url-sensit}[Sens'it] va transmettre un message sur le réseau SIGFOX,
  2. Les serveurs SIGFOX vont communiquer aux serveurs AXIBLE qu'un message *button* a été envoyé,
  3. AXIBLE va appelé l'URL de Callback que nous aurons défini dans l'interface d'administration,
  4. Ce callback pointera sur une application *sensit.meteor.com* que nous aurons déployée au préalable,
  5. Cette dernière enregistrera une trace de l'appel dans une collection Mongo,
  6. Notre application cliente établira une connexion DDP avec l'application *sensit.meteor.com*, et observera les changements effectués sur cette collection,
  7. Au premier changement détecté, on décolle.
  
  == La remote-app : sensit.meteor.com
  
  === Définition de l'URL de callback
  Dans l'interface {url-sensit}[Sens'it], nous allons spécifier une URL de callback pour les notifications de type *button*.
  
  Pour rappel, ce callback est appelé via un GET et peut recevoir en query param certaines valeurs (via des variables {{my_var}}) :
  
  