1

これは一日中私を手に入れています。gfs.exist() を使用して _id を持つ実際のファイルを見つけることができますが、コードの次の行を実行すると、毎回エラーが発生し、マングース接続がクラッシュします。これは非常に単純に思えますが、これまでのところ何も機能していません。

私のコード:

/**
 * 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);
                    }
                })
            }
        });
    }
};

gfs.files.remove({_id: ref}, function(.....) を無駄に使用しようとしました

gfs.files.remove({_id: ref}, {_id: 1}, function(....) も使用してみました

gfs.files.remove..... なしで gfs.remove() を使用して、上記の両方を試しました。

それは単純なことに違いないのですが、一日中私を打ちのめしていました...ありがとう

新しい編集 10/15 ............私は今、ネイティブの mongodb ドライバーだけを使用しようとしています。文字列と objectId へのキャストの両方でファイルを見つけることができます。操作は問題なく完了したようですが、シェルを使用してファイルが削除されているかどうかを確認すると、fs.files と fs.chunks の両方にまだ存在しています。これは私を殺している !

deleteFile: function(userId, fileType, objId, res) {
        var ObjectId = require('mongodb');
        var client = mongodb.MongoClient;
        var _id = new ObjectId(objId);


        client.connect(mediaUri, (err, db) => {
            assert.equal(null, err);
            db.collection('fs.files').find({_id: _id}, (err, doc) => {
                if(err) {
                    console.error('error finding that document in files collection'.red);
                } else {
                    console.info('found the document: ', doc);
                    console.info('the document type is: ', typeof(doc));
                }
            });
            db.collection('fs.chunks').find({_id: _id   }, (err, doc) => {
                if(err) {
                    console.error('error finding that document in the chunks collection'.red);
                } else {
                    console.info('found the document(s): ', doc);
                    console.info('the document type is: ', typeof(doc));
                }
            });

            db.collection('fs.files').deleteOne({_id: _id}, (err, doc) => {
                console.log('document returned for deletion is: ', doc);
            });
            db.collection('fs.chunks').deleteOne({_id: _id}, (err, doc) => {
                console.log('documents deleted: ', doc);
                res.status(200).send({id: userId, type: fileType, ref: objId});
            });
            db.close();
        })
    }
4

2 に答える 2

1

私はキャストを間違っており、間違った方法を使用していました。mongodb.ObjectiD() の代わりに mongodb.ObjectID() の新しいコンストラクターを使用した後、いくつかの成功があり、さらにいくつかの間違ったメソッドを呼び出していました。ドキュメントを参照して、問題を解決しました。

CRUD 操作の最終的なコードは次のとおりです。

/**
 * 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);
                        }
                    }
                })
            }
        });
    }
};
于 2016-10-17T01:55:46.660 に答える