Comment paginer avec la Mangouste dans Node.js?

Après la prise de regarder de plus près, la Mangouste API avec les informations fournies par Rodolphe, j'ai pensé à cette solution:

MyModel.find(query, fields, { skip: 10, limit: 5 }, function(err, results) { ... });

Vous pouvez enchaîner comme ça:

var query = Model.find().sort('mykey', 1).skip(2).limit(5)

L'exécution de la requête à l'aide de exec

query.exec(callback);

Mieux vaut tard que jamais.

var pageOptions = {
    page: req.query.page || 0,
    limit: req.query.limit || 10
}

sexyModel.find()
    .skip(pageOptions.page*pageOptions.limit)
    .limit(pageOptions.limit)
    .exec(function (err, doc) {
        if(err) { res.status(500).json(err); return; };
        res.status(200).json(doc);
    })

Dans ce cas vous pouvez ajouter la requête page et/ou limit de votre url http. Exemple de ?page=0&limit=25

BTW
La Pagination commence avec 0

Essayez d'utiliser la mangouste fonction de la pagination. Limite est le nombre d'enregistrements par page et le numéro de la page.

var limit = parseInt(body.limit);
var skip = (parseInt(body.page)-1) * parseInt(limit);

 db.Rankings.find({})
            .sort('-id')
            .limit(limit)
            .skip(skip)
            .exec(function(err,wins){
 });

Voici une version que j'accorde à tous mes modèles. Il dépend de soulignement pour des raisons de commodité et asynchrone pour la performance. Le opte permet de champ de sélection et de tri à l'aide de la mangouste syntaxe.

var _ = require('underscore');
var async = require('async');
function findPaginated(filter, opts, cb) {
var defaults = {skip : 0, limit : 10};
opts = _.extend({}, defaults, opts);
filter = _.extend({}, filter);
var cntQry = this.find(filter);
var qry = this.find(filter);
if (opts.sort) {
qry = qry.sort(opts.sort);
}
if (opts.fields) {
qry = qry.select(opts.fields);
}
qry = qry.limit(opts.limit).skip(opts.skip);
async.parallel(
[
function (cb) {
cntQry.count(cb);
},
function (cb) {
qry.exec(cb);
}
],
function (err, results) {
if (err) return cb(err);
var count = 0, ret = [];
_.each(results, function (r) {
if (typeof(r) == 'number') {
count = r;
} else if (typeof(r) != 'number') {
ret = r;
}
});
cb(null, {totalCount : count, results : ret});
}
);
return qry;
}

Joindre à votre schéma de modèle.

MySchema.statics.findPaginated = findPaginated;

La meilleure approche (OMI) est d'utiliser le saut et limite, MAIS dans des collections ou des documents.

De faire la requête sur un nombre limité de documents, nous pouvons utiliser des index comme indice sur un champ de type DATE. Voir qu'en dessous de

let page = ctx.request.body.page || 1
let size = ctx.request.body.size || 10
let DATE_FROM = ctx.request.body.date_from
let DATE_TO = ctx.request.body.date_to
var start = (parseInt(page) - 1) * parseInt(size)
let result = await Model.find({ created_at: { $lte: DATE_FROM, $gte: DATE_TO } })
.sort({ _id: -1 })
.select('<fields>')
.skip( start )
.limit( size )        
.exec(callback)

Ceci est un exemple de fonction pour obtenir le résultat du modèle de la pagination et de limiter les options

 export function get_skills(req, res){
console.log('get_skills');
var page = req.body.page; //1 or 2
var size = req.body.size; //5 or 10 per page
var query = {};
if(page < 0 || page === 0)
{
result = {'status': 401,'message':'invalid page number,should start with 1'};
return res.json(result);
}
query.skip = size * (page - 1)
query.limit = size
Skills.count({},function(err1,tot_count){ //to get the total count of skills
if(err1)
{
res.json({
status: 401,
message:'something went wrong!',
err: err,
})
}
else 
{
Skills.find({},{},query).sort({'name':1}).exec(function(err,skill_doc){
if(!err)
{
res.json({
status: 200,
message:'Skills list',
data: data,
tot_count: tot_count,
})
}
else
{
res.json({
status: 401,
message: 'something went wrong',
err: err
})
}
}) //Skills.find end
}
});//Skills.count end

}

Simple et puissant de la pagination solution

last_doc_id: le dernier id de document que vous obtenez

no_of_docs_required: le nombre de documents que vous souhaitez chercher à savoir 5, 10, 50, etc.

async getNextDocs(no_of_docs_required: number, last_doc_id?: string) {
let docs
if (!last_doc_id) {
//get first 5 docs
docs = await MySchema.find().sort({ _id: -1 }).limit(no_of_docs_required)
}
else {
//get next 5 docs according to that last document id
docs = await MySchema.find({_id: {$lt: last_doc_id}})
.sort({ _id: -1 }).limit(no_of_docs_required)
}
return docs
}

1. Si vous ne fournissez pas le dernier id de document de la méthode, vous en aurez 5 dernières docs
2. Si vous avez fourni le dernier id de document-là, vous aurez les 5 prochaines documents.

Vous pouvez écrire des requêtes de ce genre.

mySchema.find().skip((page-1)*per_page).limit(per_page).exec(function(err, articles) {
if (err) {
return res.status(400).send({
message: err
});
} else {
res.json(articles);
}
});

page : numéro de la page à venir à partir d'un client comme les paramètres de la demande.

per_page : pas de résultats affichés par page

Si vous utilisez la MOYENNE de la pile blog suivant fournit une grande partie de l'information pour créer de la pagination dans l'extrémité avant à l'aide de angular-UI bootstrap et à l'aide de la mangouste sauter et de limiter les méthodes dans le backend.

voir : https://techpituwa.wordpress.com/2015/06/06/mean-js-pagination-with-angular-ui-bootstrap/

Si vous utilisez de la mangouste comme source d'une api restful ont un coup d'oeil à
'restify-mangouste", et à ses requêtes. Il a exactement cette fonctionnalité intégrée.

Une requête sur une collection fournit les en-têtes qui sont utiles ici

test-01:~$ curl -s -D - localhost:3330/data?sort=-created -o /dev/null
HTTP/1.1 200 OK
link: </data?sort=-created&p=0>; , </data?sort=-created&p=1>; rel="next", </data?sort=-created&p=134715>; rel="last"
.....
Response-Time: 37

Donc, fondamentalement, vous obtenez un serveur générique avec un relativement linéaire du temps de chargement pour les requêtes pour les collections. C'est génial et quelque chose à regarder si vous voulez aller dans un propre mise en œuvre.

**//localhost:3000/asanas/?pageNo=1&size=3**
//requiring asanas model
const asanas = require("../models/asanas");
const fetchAllAsanasDao = () => {
return new Promise((resolve, reject) => {
var pageNo = parseInt(req.query.pageNo);
var size = parseInt(req.query.size);
var query = {};
if (pageNo < 0 || pageNo === 0) {
response = {
"error": true,
"message": "invalid page number, should start with 1"
};
return res.json(response);
}
query.skip = size * (pageNo - 1);
query.limit = size;
asanas
.find(pageNo , size , query)
.then((asanasResult) => {
resolve(asanasResult);
})
.catch((error) => {
reject(error);
});
});
}