Retour Meteor.http résultats en méthode

J'ai une méthode Meteor qui recouvre un http.get. J'essaie de renvoyer les résultats de ce http.get dans le retour de la méthode afin que je puisse utiliser les résultats lorsque j'appelle la méthode.
Je ne peux pas le faire fonctionner cependant.

Voici mon code:

(Dans le dossier partagé)

Meteor.methods({ getWeather: function(zip) { console.log('getting weather'); var credentials = { client_id: "string", client_secret: "otherstring" } var zipcode = zip; var weatherUrl = "http://api.aerisapi.com/places/postalcodes/" + zipcode + "?client_id=" + credentials.client_id + "&client_secret=" + credentials.client_secret; weather = Meteor.http.get(weatherUrl, function (error, result) { if(error) { console.log('http get FAILED!'); } else { console.log('http get SUCCES'); if (result.statusCode === 200) { console.log('Status code = 200!'); console.log(result.content); return result.content; } } }); return weather; } });

Pour une raison quelconque, cela ne renvoie pas les résultats même s'ils existent et l'appel http fonctionne : console.log (result.content); Enregistre effectivement les résultats.

(Dossier client)

  Meteor.call('getWeather', somezipcode, function(error, results) { if (error) return alert(error.reason); Session.set('weatherResults', results); });

Bien sûr, la variable de session finit par être vide.
(Notez que cette partie du code semble être correcte car elle est retournée de manière appropriée si j'ai codé le retour avec une chaîne fictive dans la méthode.)

Aidez-moi?

Dans votre exemple, Meteor.http.get est exécuté de manière asynchrone.

Voir docs :

HTTP.call (méthode, url [, options] [, asyncCallback])

Sur le serveur, cette fonction peut être exécutée de manière synchrone ou asynchrone. Si le rappel est omis, il se déroule de manière synchrone et les résultats sont retournés une fois la demande terminée. Si la demande n'a pas abouti, une erreur est lancée

Passez en mode synchrone en supprimant asyncCallback:

 try { var result = HTTP.get( weatherUrl ); var weather = result.content; } catch(e) { console.log( "Cannot get weather data...", e ); }

Kuba Wyrobek est correct, mais vous pouvez également appeler HTTP.get manière asynchrone et utiliser un avenir pour arrêter la méthode de retour jusqu'à ce que le get ait répondu:

 var Future = Npm.require('fibers/future'); Meteor.methods({ getWeather: function(zip) { console.log('getting weather'); var weather = new Future(); var credentials = { client_id: "string", client_secret: "otherstring" } var zipcode = zip; var weatherUrl = "http://api.aerisapi.com/places/postalcodes/" + zipcode + "?client_id=" + credentials.client_id + "&client_secret=" + credentials.client_secret; HTTP.get(weatherUrl, function (error, result) { if(error) { console.log('http get FAILED!'); weather.throw(error); } else { console.log('http get SUCCES'); if (result.statusCode === 200) { console.log('Status code = 200!'); console.log(result.content); weather.return(result); } } }); weather.wait(); } });

Il n'y a pas vraiment beaucoup d'avantage pour cette méthode sur un get synchrone dans ce cas, mais si vous faites quelque chose sur le serveur qui peut bénéficier de quelque chose comme un appel HTTP s'exécutant de manière asynchrone (et donc ne pas bloquer le reste du code dans votre Méthode), mais vous devez attendre que cet appel soit renvoyé avant que la méthode ne puisse, alors c'est la bonne solution. Un exemple serait l'endroit où vous devez exécuter de multiples ensembles non contingents, qui devraient tous attendre l'un l'autre pour renvoyer un par un si ils sont exécutés de manière synchrone.

Plus ici .

Parfois, les appels asynchrones sont préférables. Vous pouvez utiliser la synchronisation asynchrone / attente pour cela, et vous devez promener HTTP.get .

 import { Meteor } from 'meteor/meteor'; import { HTTP } from 'meteor/http'; const httpGetAsync = (url, options) => new Promise((resolve, reject) => { HTTP.get(url, options, (err, result) => { if (err) { reject(err); } else { resolve(result); } }); }); Meteor.methods({ async 'test'({ url, options }) { try { const response = await httpGetAsync(url, options); return response; } catch (ex) { throw new Meteor.Error('some-error', 'An error has happened'); } }, });

Notez que la méthode d' test météores est marquée comme async . Cela permet d'utiliser l'opérateur à l'intérieur avec des appels de méthode qui renvoient Promise . Les lignes de code à suivre pour les opérateurs ne seront pas exécutées tant que la promesse n'est pas résolue. Dans le cas où la promesse est rejetée, le bloc catch sera exécuté.