Warum kann ich gfs.files nicht mit einer ObjectId löschen?

Question

Das hat mich den ganzen Tag bekommen. Ich kann die eigentliche Datei finden mit _sid mit gfs.exist(), aber wenn ich zur nächsten Codezeile gehe, erhalte ich jedes Mal einen Fehler und die Mungoverbindung stürzt ab. Das scheint so einfach zu sein, aber bisher hat noch nichts funktioniert.

mein Code:

/** 
* Created by foolishklown on 10/2/2016. 
*/ 

var Grid = require('gridfs-stream'), 
    User = require('../../models/user'), 
    mongoose = require('mongoose'); 


module.exports = function(id, ref, type, res) { 
    console.log(ref.green); 
    Grid.mongo = mongoose.mongo; 

    var conn = mongoose.createConnection('mongodb://localhost/media'); 
    conn.once('open', function() { 
     var gfs = Grid(conn.db); 
     gfs.exist({_id: ref}, function(err, found) { 
      if(err) { 
       console.error('error finding file'.red); 
      } else { 
       console.info('found file', found); 
       gfs.files.remove({_id: ref }, function(err) { 
        if(err) { 
         console.error('error removing that file'); 
         process.exit(1); 
        } else { 
         console.info('removed file: ', found.green); 
         deleteFromUserDb(id, type, ref); 
         res.status(200).send({id: id, type: type, ref: ref}); 
        } 
       }); 
      } 
     }); 
    }); 
    conn.close(); 

    function deleteFromUserDb(userId, fileType, refId) { 
     var userConn = mongoose.createConnection('mongodb://localhost/mean-auth', (error) => { 
      if(error) { 
       console.error('Error connecting to the mean-auth instance'.red); 
       process.exit(1); 
      } else { 
       User.findById(userId, (err, doc) => { 
        if(err) { 
         console.error('Error finding user with id: ', uid); 
         process.exit(1); 
        } else { 
         console.log('original doc: ', doc); 
         doc.removeMedia(fileType, refId); 
         doc.save(); 
         console.log('new doc: ', doc); 
        } 
       }) 
      } 
     }); 
    } 
}; 

ich versucht habe mit gfs.files.remove ({_ id: ref} function (.....) ohne Erfolg

i auch versucht haben, mit gfs.files.remove ({_id: ref}, {_id: 1}, function (....)

Ich habe auch beide oben mit gfs.remove() ohne gfs.files.remove versucht. ....

muss es etwas einfaches sein aber es hat mich geschlagen p ganzen tag ... danke

new edit 10/15 .......... ich versuche jetzt nur den nativen mongodb-treiber zu verwenden. Ich kann die Datei sowohl mit der Zeichenfolge als auch mit einer Objekt-ID suchen. Es sieht so aus, als wäre die Operation kein Problem, aber wenn ich die Shell benutze, um zu sehen, ob die Datei gelöscht wurde, existiert sie immer noch sowohl in fs.files als auch in fs chunks. Dieser bringt mich um!

Answer 1

Ich habe die Besetzung falsch gemacht und die falschen Methoden verwendet. Nachdem ich einen neuen Konstruktor für mongodb.ObjectID() anstelle von mongodb.ObjectID() benutzt hatte, hatte ich einige Erfolge, plus ich rief einige der falschen Methoden auf. Ich konsultierte die Dokumentation und richtete die Dinge auf.

Mein letzter Code für CRUD-Operationen ist:

/** 
* Created by foolishklown on 10/13/2016. 
*/ 
var assert = require('assert'), 
    path = require('path'), 
    Grid = require('gridfs-stream'), 
    fs = require('fs'), 
    mongodb = require('mongodb'), 
    mongoose = require('mongoose'), 
    User = require('../../models/user'), 
    mediaUri = 'mongodb://localhost/media', 
    userUri = 'mongodb://localhost/mean-auth'; 

module.exports = { 


    writeFile: function (file, userId, fileType, fileInfo, res) { 
     var fileId; 
     var fileTitle = file.originalFilename; 
     var conn = mongoose.createConnection('mongodb://localhost/media', (error) => { 
      if (error) { 
       console.error('Error connecting to mongod media instance'.red); 
       process.exit(1); 
      } else { 
       console.info('Connected successfully to mongod media instance in the write file!'.blue); 
      } 
     }); 
     // The following line is designating a file to grab/read, and save into mongo 
     // in our case it will be something from ng-file-upload that the user wants to upload 
     var myFile = file.path; 

     // Connect gridFs and mongo 
     Grid.mongo = mongoose.mongo; 

     conn.once('open', function() { 
      console.log('connection open, ready for I/O!'); 
      var gfs = Grid(conn.db); 

      // This write stream is how well write to mongo 
      var writeStream = gfs.createWriteStream({ 
       // Name the file the way you want it stored in mongo 
       filename: file.originalFilename, 
       type: fileType, 
       info: fileInfo 
      }); 

      // Create a read stream, so that we can read its data, and then with that well use the 
      // write stream to write to the DB via piping the writestream 
      var readStream = fs.createReadStream(myFile) 
       .on('end',() => { 
        writeToUserDb(userId, fileType, readStream.id, fileInfo, fileTitle); 
        res.status(200).send(
         { 
          ref: readStream.id, 
          type: fileType, 
          user: userId, 
          mediaInfo: fileInfo, 
          title: fileTitle 
         } 
        ); 
       }) 
       .on('error',() => { 
        res.status(500).send('error in writing with gridfs'); 
       }) 
       .pipe(writeStream); 
      writeStream.on('close', function (file) { 
       console.log(file.filename + 'written to DB'); 
       fs.unlink(myFile); 
       myFile = null; 
       conn.close(); 
      }); 
     }); 

     function writeToUserDb(uid, type, fileId, authInfo, title) { 
      console.info('called to write to user db without a \'this\' reference'); 
      var userConn = mongoose.createConnection('mongodb://localhost/mean-auth', (error) => { 
       if (error) { 
        console.error('Error connecting to the mean-auth instance'.red); 
        process.exit(1); 
       } else { 
        User.findById(uid, (err, doc) => { 
         if (err) { 
          console.error('Error finding user with id: ', uid); 
          process.exit(1); 
         } else { 
          console.log('original doc: ', doc); 
          doc.addMedia(type, fileId, authInfo, title); 
          doc.save(); 
          console.log('new doc: ', doc); 
         } 
        }) 
       } 
      }); 
      userConn.close(); 
     } 
    }, 

    downloadFile: function (userId, file, fileType, objId, location, res) { 
     console.info('called to download file'); 
     var id = new mongodb.ObjectID(objId); 
     var conn = mongoose.createConnection(mediaUri, (error) => { 
      assert.ifError(error); 

      var gfs = Grid(conn.db, mongoose.mongo); 

      gfs.findOne({_id: id}, (err, result) => { 
       if (err) { 
        res.status(400).send(err); 
       } else if (!result) { 
        res.status(404).send('Error finding file') 
       } else { 
        res.set('Content-Type', result.contentType); 
        res.set('Content-Disposition', 'attachment; filename="' + result.filename + '"'); 
        var readStream = gfs.createReadStream({ 
         _id: id, 
         root: 'resume' 
        }); 
        readStream.on('error', (err) => { 
         res.end(); 
        }); 
        readStream.pipe(res); 
       } 
      }); 
     }); 
     conn.close(); 
    }, 

    deleteFile: function (userId, fileType, objId, res) { 
     var client = mongodb.MongoClient; 
     var id = new mongodb.ObjectID(objId); 

     console.log('object id to find is: ', id); 
     client.connect('mongodb://localhost/media', (err, db) => { 
      db.collection('fs.files', {}, (err, files) => { 
       files.remove({_id: id}, (err, result) => { 
        if (err) { 
         console.log(err); 
         res.status(500); 
        } 
        console.log(result); 
       }); 
      }); 
      db.collection('fs.chunks', {}, (err, chunks) => { 
       chunks.removeMany({files_id: id}, (err, result) => { 
        if (err) { 
         console.log(err); 
         res.status(500); 
        } 
        console.log(result); 
       }); 
      }); 
      db.close(); 
     }); 
     res.status(200).send({id: userId, type: fileType, ref: id}); 
    }, 

    getAll: function (req, res) { 
     var uid = req.query.id; 
     var conn = mongoose.createConnection('mongodb://localhost/mean-auth', (err) => { 
      if (err) { 
       console.error('Error connecting to mean-auth instance to read all'); 
       process.exit(1); 
      } else { 
       User.findById(uid, (err, doc) => { 
        if (err) { 
         console.error('Error finding user with id: ', uid); 
         process.exit(1); 
        } else { 
         if (doc) { 
          console.log('original doc: ', doc); 
          res.status(200).send({media: doc.media}); 
         } else { 
          res.status(200); 
         } 
        } 
       }) 
      } 
     }); 
    } 
};