Discussion :

[Rtransat]

Bonjour,

Je commence Node.js et quoi de mieux que de tenter de faire une app pour comprendre son fonctionnement ^^.

J'ai une question concernant un appel d'une API externe (TMDB) et côté client j'utilise AngularJS

Le but est de mettre à jour les infos de la série. J'utilise http://docs.themoviedb.apiary.io/#re...discovertv/get pour sauvegarder en masse des séries télé, mais n'ayant pas toutes les infos dans cette requête je fais appel à http://docs.themoviedb.apiary.io/#reference/tv/tvid/get lorsque je visite une série sur mon application.

Ce que je voudrais c'est éviter l'appel de MovieDB.tvInfo si dans mon schema Moogouse j'ai la valeur fully_scraped à true

Voici mon code actuel (l'avantage de ça c'est que lors que la requête est fini, dans ma vue via angular, la valeur plot n'est pas vide et s'affiche correctement)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
app.get('/api/shows/:id', function(req, res, next) {
 
    MovieDB.tvInfo({id: req.params.id, language: 'fr'}, function(err, data) {
        Show.findById(req.params.id, function(err, show) {
            if(err) return next(err);
 
            if(!show.fully_scraped) {
                show.plot = data.overview;
                show.fully_scraped = true;
 
                console.log("it's now scrapped");
 
                show.save(function(err) {
                    if (err)
                        console.log('error')
                    else
                        console.log('success')
                });
            }
            res.send(show);
        });
    });
});

Autrement si je fais ceci j'évite bien la requête vers l'api de tmdb mais dans ma vue, angular ne connait pas encore la valeur de "plot"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
app.get('/api/shows/:id', function(req, res, next) {
 
    Show.findById(req.params.id, function(err, show) {
        if(err) return next(err);
 
        if(!show.fully_scraped) {
            MovieDB.tvInfo({id: req.params.id, language: 'fr'}, function(err, data) {
                show.plot = data.overview;
                show.fully_scraped = true;
 
                console.log("it's now scrapped");
 
                show.save(function(err) {
                    if (err)
                        console.log('error')
                    else
                        console.log('success')
                });
            });
 
 
 
        }
        res.send(show);
    });
});

Comment optimiser tout ça ?

Merci d'avance.

[xulien]

Comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
app.get('/api/shows/:id', function(req, res, next) {
 
    Show.findById(req.params.id, function(err, show) {
        if(err) return next(err);
 
        if (show.fully_scraped) return res.send(show);
 
        MovieDB.tvInfo({id: req.params.id, language: 'fr'}, function(err, data) {
                show.plot = data.overview;
                show.fully_scraped = true;
 
                console.log("it's now scrapped");
 
                show.save(function(err) {
                    if(err) return next(err);
                    res.send(show);
                });
            });
        }
 
    });
});

la fonction "return" met fin à la fonction en renvoyant son résultat.

[Rtransat]

Merci pour ta réponse, au final pour mieux structurer le code j'utilise async.waterfall pour faire une suite d'exécution. (Je sais pas si c'est mieux mais bon).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
app.get('/api/shows/:id', function(req, res, next) {
 
    async.waterfall([
        function(callback) {
            Show.findById(req.params.id, function(err, show) {
                if(err) return next(err);
                if(show.fully_scraped) {res.send(show); return;}
                callback(err, show);
            });
        },
        function(show, callback) {
            MovieDB.tvInfo({id: show._id, language: 'fr'}, function(err, data) {
 
                show.plot = data.overview;
                show.background = 'http://image.tmdb.org/t/p/w780' + data.backdrop_path;
                show.episode_count = data.number_of_episodes;
                show.tmdb_id = data.id;
                show.poster = 'http://image.tmdb.org/t/p/w342' + data.poster_path;
                show.season_number = data.number_of_seasons;
                show.fully_scraped = true;
                show.in_production = data.in_production;
                show.last_air_date = data.last_air_date;
 
                console.log('info');
                callback(err, show, data);
            });
        },
        function(show, data) {
            var seasons = data.seasons;
            var seasonsArray = [];
 
            _.each(seasons, function(season) {
                if(season.season_number != 0) {
                    seasonsArray.push({
                        release_date: season.air_date,
                        episode_count: season.episode_count,
                        tmdb_id: season.id,
                        poster: 'http://image.tmdb.org/t/p/w342' + season.poster_path,
                        season_number: season.season_number,
                        fully_scraped: true,
                        allow_update: false,
                    });
                }
            });
 
            show.fully_scraped = true;
            show.seasons = seasonsArray;
 
            show.save(function(err) {
                if (err)
                    console.log('error')
                else {
                    console.log('saved')
                }
            });
 
 
 
            res.send(show);
        }
    ]);
 
});

[xulien]

au final pour mieux structurer le code j'utilise async.waterfall pour faire une suite d'exécution. (Je sais pas si c'est mieux mais bon).

Bha non, pas tellement. waterfall sert effectivement à mieux structurer le code (Control Flow), alors que eachSeries sert à gérer les collections de façon asynchrone; parce que ta boucle _.each, elle est bloquante tout le temps de son traitement... rien ne t'empeche d'ailleurs de coupler les deux, waterfall et eachSeries, mais dans ton cas, pour deux malheureux callback, waterfall me semble un peu overkilled.

[Rtransat]

Ah ok, j'ai voulu m'inspirer de ça : https://github.com/sahat/tvshow-trac...server.js#L249

Dans mon cas, lorsque je visite une série, je voudrais ajouter les données de la série via mongoose, saisons et épisodes. Pour toi quelle est la bonne pratique à appliquer ? Sachant que par la suite, il faudra gérer un event (genre toute les semaines) pour mettre à jour la série (le nombre de saisons, nombre d'épisodes) et ajouter les nouveau épisode chaque semaine (pour avertir par la suite un utilisateur).

[xulien]

En fait, quand je t'ai répondu, j'avais en tête un autre fil de discussion process out of memory, où il est question d'un problème de boucle avec 350000 éléments... j'ai un peu tout mélangé...

toujours est-il que:

Ah ok, j'ai voulu m'inspirer de ça

Dans la mesure où il fait 3 request et 3 parsage, soit 6 callback, waterfall est parfaitement justifié. En comparaison, pour tes deux callbacks c'est à mon sens ajouter de la complexité, mais tu fais comme tu le sens.

Pour toi quelle est la bonne pratique à appliquer ?

De façon générale, les boucles tel qu'on les pratiques avec JavaScript, càd synchrone, ne sont pas appropriés avec Node, d'où toutes les fonctions que propose Async.js dans la partie «Collections» pour les traiter.

Comme dis précédemment, la boucle d'underscore est bloquante, si ta collection a 10 éléments, ce n'est pas bien méchant, si c'est 100000 c'est pas bon, car dans l'intervalle du traitement ton serveur n'est plus disponible pour répondre aux nouvelles requêtes, à toi de voir en fonction de la quantité de données à traiter. Mais encore une fois, quand je t'ai parlé de Async.eachSeries, va savoir pourquoi, je pensais à 350000 éléments et pas du tout à la bonne problématique.