Comment récupérer des données à partir d'une requête Mongoose?

Question

J'écris une application dans la pile MEAN en utilisant mongoose comme ORM.

J'implémente les opérations Créer et Lire dans le processus CRUD.

Mon schéma page est comme suit

const mongoose = require('mongoose'); 
var pageSchema = new moongose.Schema({ 
pageExtension:{ 
    type:String, 
    default:"html" 
}, 
publicFileRoot:{ 
    type:String, 
    default:"/dist/" 
}, 
testAttribute:{ 
    type:String 
}, 
title:{ 
    type:String, 
    required:[true ,'title is required'] 
}, 
pageName:{ 
    type:String, 
    required:[true, "the page name for this page is required"] 
}, 
routeUri:{ 
    type:String 
}, 
projects:[{ 
    type:Schema.Types.ObjectId, ref:projectSchema 
}], 
fileUrl:{ 
    type:String, 
    required:[true, "the file url is requred"], 
    default:this.publicFileRoot + this.pageName 
}, 
pageID:{ 
    type:Number, 
    index:true, 
    unique:true, 
    required:true 
}, 
webUrl:{ 
    type:String 
}, 
lastUpdated:{type:Date, default:Date.now, required:[true, 'the last updated Date is required']}, 
_mongoID: {type:Schema.Types.ObjectId, description:"mongoDB's Unique ID"}, 
staticFiles:{ 
    css:{ 
     type:Array, 
     url:{ 
      type:String 
     } 
    }, 
    js:[{ 
     type:Array, 
     url:{ 
      type:String 
     } 
    }], 
    html:[{ 
     url:{ 
      type:String 
     } 
    }], 
    img:[{ 
     type:Array, 
     imgID:{ 
      type:String 
     }, 
     imgUrl:{ 

     } 

    }] 
} 
}); 
module.exports = pageSchema; 

Mon script de base de données est la suivante

var mongoose = require('mongoose'), 
var mongoDB = 'mongodb://127.0.0.1/test'; 
var conn = mongoose.createConnection(mongoDBConnectionURI,{useMongoClient:true}) 
.on('connected',function(){ 
    console.log("connected to database"); 
}); 
var pageModel = conn.model('PageModel',pageSchema); 
var readCallback = function(err,doc){ 
    if(err){ 
     console.error.bind(console,err); 
    } 
    else{ 
    return doc.collections; 
    } 
} 
var create = function(Model,options = {}{ 
var newDocument = new Model(options); 
validationError = newDocument.validateSync(); 
if(validationError){ 
    console.log("on create: validation error:" + validationError); 
} 
else{ 
    newDocument.save(function(err,newDocument){ 
     if(err) return console.log(err); 
     else return newDocument; 
    }); 
} 
} 
//this function should query the database and return the result of the query 
var read = function(Model, options, callback){ 
//options should contain an object with the format {attribute:value} 
//check if the Model variable is defined 
if(Model===undefined){ 
// the model reference is required 
    throw new Error("Error on db.read: Model is undefined"); 
} 
//check if the attribute 
else if(options.attribute === undefined){ 
    //if no attribute is specified then just return the result of a model.find operation 
    return Model.find({attribute:value},readCallback); 
} 
else{ 
    //if value is undefined assume user wants to return all results limited to attribute only 
    if(options[options.attribute] === undefined){ 

     return Model.find({}) 
      .exec(
        function(err,doc){ 
        if (err) console.error.bind(console,error); 
        else return doc; 
      }); 
    } 
    //model, attribute, value are defined. perform a specific search 
    else{ 

      return Model.findOne(options,readcallback); 
     } 
    } 
    } 
} 

Test de la fonction créer:

create(pageModel, 
{ 
    pageName:"testpage 1", 
    title:"testing the functioning of the database", 
    pageID:4 
}, 
); 

Voici les résultats de la création fonction comme indiqué par la boussole MongoDB

Test de la fonction de lecture:

console.log(pageModel.find({"pageName":"testpage 1"},readCallback);

Voici le résultat d'une console.log sur la fonction ci-dessus

Query { 
    _mongooseOptions: {}, 
    mongooseCollection: 
    NativeCollection { 
    collection: null, 
    opts: { bufferCommands: true, capped: false }, 
    name: 'pagemodels', 
    collectionName: 'pagemodels', 
    conn: 
     NativeConnection { 
     base: [Object], 
     collections: [Object], 
     models: [Object], 
     config: [Object], 
     replica: false, 
     hosts: null, 
     host: null, 
     port: null, 
     user: null, 
     pass: null, 
     name: null, 
     options: null, 
     otherDbs: [], 
     _readyState: 2, 
     _closeCalled: false, 
     _hasOpened: false, 
     _listening: false, 
     _connectionOptions: {}, 
     then: [Function], 
     catch: [Function], 
     _events: [Object], 
     _eventsCount: 1 }, 
    queue: [], 
    buffer: true, 
    emitter: 
     EventEmitter { 
     domain: null, 
     _events: {}, 
     _eventsCount: 0, 
     _maxListeners: undefined } }, 
    model: 
    { [Function: model] 
    hooks: Kareem { _pres: {}, _posts: {} }, 
    base: 
     Mongoose { 
     connections: [Array], 
     models: {}, 
     modelSchemas: [Object], 
     options: [Object], 
     plugins: [Array] }, 
    modelName: 'PageModel', 
    model: [Function: model], 
    db: 
     NativeConnection { 
     base: [Object], 
     collections: [Object], 
     models: [Object], 
     config: [Object], 
     replica: false, 
     hosts: null, 
     host: null, 
     port: null, 
     user: null, 
     pass: null, 
     name: null, 
     options: null, 
     otherDbs: [], 
     _readyState: 2, 
     _closeCalled: false, 
     _hasOpened: false, 
     _listening: false, 
     _connectionOptions: {}, 
     then: [Function], 
     catch: [Function], 
     _events: [Object], 
     _eventsCount: 1 }, 
    discriminators: undefined, 
    '$appliedHooks': true, 
    _events: { init: [Function], save: [Function] }, 
    _eventsCount: 2, 
    schema: 
     Schema { 
     obj: [Object], 
     paths: [Object], 
     aliases: {}, 
     subpaths: {}, 
     virtuals: [Object], 
     singleNestedPaths: {}, 
     nested: [Object], 
     inherits: {}, 
     callQueue: [Array], 
     _indexes: [], 
     methods: {}, 
     statics: {}, 
     tree: [Object], 
     query: {}, 
     childSchemas: [Array], 
     plugins: [Array], 
     s: [Object], 
     options: [Object], 
     '$globalPluginsApplied': true }, 
    collection: 
     NativeCollection { 
     collection: null, 
     opts: [Object], 
     name: 'pagemodels', 
     collectionName: 'pagemodels', 
     conn: [Object], 
     queue: [], 
     buffer: true, 
     emitter: [Object] }, 
    Query: { [Function] base: [Object] }, 
    '$__insertMany': [Function], 
    insertMany: [Function] }, 
    schema: 
    Schema { 
    obj: 
     { pageExtension: [Object], 
     publicFileRoot: [Object], 
     testAttribute: [Object], 
     title: [Object], 
     pageName: [Object], 
     routeUri: [Object], 
     projects: [Array], 
     fileUrl: [Object], 
     pageID: [Object], 
     webUrl: [Object], 
     lastUpdated: [Object], 
     _mongoID: [Object], 
     staticFiles: [Object] }, 
    paths: 
     { pageExtension: [Object], 
     publicFileRoot: [Object], 
     testAttribute: [Object], 
     title: [Object], 
     pageName: [Object], 
     routeUri: [Object], 
     projects: [Object], 
     fileUrl: [Object], 
     pageID: [Object], 
     webUrl: [Object], 
     lastUpdated: [Object], 
     _mongoID: [Object], 
     'staticFiles.css': [Object], 
     'staticFiles.js': [Object], 
     'staticFiles.html': [Object], 
     'staticFiles.img': [Object], 
     _id: [Object], 
     __v: [Object] }, 
    aliases: {}, 
    subpaths: {}, 
    virtuals: { id: [Object] }, 
    singleNestedPaths: {}, 
    nested: { staticFiles: true }, 
    inherits: {}, 
    callQueue: [ [Array], [Array], [Array], [Array], [Array], [Array] ], 
    _indexes: [], 
    methods: {}, 
    statics: {}, 
    tree: 
     { pageExtension: [Object], 
     publicFileRoot: [Object], 
     testAttribute: [Object], 
     title: [Object], 
     pageName: [Object], 
     routeUri: [Object], 
     projects: [Array], 
     fileUrl: [Object], 
     pageID: [Object], 
     webUrl: [Object], 
     lastUpdated: [Object], 
     _mongoID: [Object], 
     staticFiles: [Object], 
     _id: [Object], 
     id: [Object], 
     __v: [Function: Number] }, 
    query: {}, 
    childSchemas: [ [Object] ], 
    plugins: [ [Object], [Object], [Object] ], 
    s: { hooks: [Object], kareemHooks: [Object] }, 
    options: 
     { retainKeyOrder: false, 
     typeKey: 'type', 
     id: true, 
     noVirtualId: false, 
     _id: true, 
     noId: false, 
     validateBeforeSave: true, 
     read: null, 
     shardKey: null, 
     autoIndex: null, 
     minimize: true, 
     discriminatorKey: '__t', 
     versionKey: '__v', 
     capped: false, 
     bufferCommands: true, 
     strict: true, 
     pluralization: true }, 
    '$globalPluginsApplied': true }, 
    op: 'find', 
    options: { retainKeyOrder: false }, 
    _conditions: {}, 
    _fields: undefined, 
    _update: undefined, 
    _path: undefined, 
    _distinct: undefined, 
    _collection: 
    NodeCollection { 
    collection: 
     NativeCollection { 
     collection: null, 
     opts: [Object], 
     name: 'pagemodels', 
     collectionName: 'pagemodels', 
     conn: [Object], 
     queue: [], 
     buffer: true, 
     emitter: [Object] }, 
    collectionName: 'pagemodels' }, 
    _traceFunction: undefined, 
    _count: [Function], 
    _execUpdate: [Function], 
    _find: [Function], 
    _findOne: [Function], 
    _findOneAndRemove: [Function], 
    _findOneAndUpdate: [Function], 
    _replaceOne: [Function], 
    _updateMany: [Function], 
    _updateOne: [Function] } 

Juste pour une aide supplémentaire, voici mon MongoDB log pour aujourd'hui (était trop grand pour tenir ici): mongodb.log

La dernière partie de la question:

Comment effectuer une opération de recherche renvoie les résultats de la fonction de création comme indiqué dans l'image de la boussole MongoDB? J'ai creusé mon cerveau pendant trois jours en essayant de comprendre cela et je ne comprends pas ce que je fais de mal. Toute aide ou explication des processus impliqués serait très utile.

Answer 1

//this function should query the database and return the result of the  query 
var read = function(Model, options, callback){ 
//options should contain an object with the format {attribute:value} 
//check if the Model variable is defined 
if(Model===undefined){ 
// the model reference is required 
throw new Error("Error on db.read: Model is undefined"); 
} 
//check if the attribute 
else if(options.attribute === undefined){ 
    //if no attribute is specified then just return the result of a model.find operation 
return Model.find({attribute:value},readCallback); 
} 

En ce qui concerne la définition de la fonction de lecture au-dessus de votre troisième paramètre est fonction de rappel et lorsque vous retournez le résultat que vous ne l'utilisez rappel.