Zauważyłem, że kiedy tworzy się projekt za pomocą Express.js, funkcje obsługi trasy są teraz oddzielone od głównego pliku „app.js”. Są teraz umieszczane w './routes/index.js'. Biorąc pod uwagę tę sytuację, w jaki sposób można teraz zapisać rekord w bazie danych (w tym przypadku przy użyciu MongoDB dostępnego przez Mongoose).

Tradycyjnie funkcja obsługi trasy miałaby w 'app.js', na przykład:

//Create document 
app.post('/documents.:format?', function(req, res) {
  var d = new Document(req.body);
  d.user_id = req.currentUser.id;
  d.save(function() {
    switch (req.params.format) {
      case 'json':
        var data = d.toObject();
        // TODO: Backbone requires 'id', but can I alias it?
        data.id = data._id;
        res.send(data);
      break;

      default:
        req.flash('info', 'Document created');
        res.redirect('/documents');
    }
  });
});

W nowym "układzie" takie wywołanie zmieniłoby się na coś takiego (w pliku 'app.js'):

app.post('/documents.:format?', routes.add_documents);

Z całym rzeczywistym przetwarzaniem zachodzącym w pliku './route/index.js':

exports.add_documents = function(req, res){
  // Processing goes here!
};

Moje pytanie brzmi, jak można włączyć oryginalną funkcję obsługi trasy do tej nowej funkcji add_documents powyżej? W szczególności, w jaki sposób można uzyskać dostęp do modelu schematu bazy danych (np. utworzyć nową instancję „Dokument”), aby uzyskać dostęp do metody zapisywania bazy danych?

Pełna zawartość 'app.js' jest następująca:

var express = require('express')
  , routes = require('./routes')
  , mongoose = require('mongoose')
  , models = require('./models')
  , Document;

var app = module.exports = express.createServer();

// Configuration

app.configure(function(){
  app.set('views', __dirname + '/views');
  app.set('view engine', 'jade');
  app.use(express.bodyParser());
  app.use(express.methodOverride());
  app.use(app.router);
  app.use(express.static(__dirname + '/public'));
});

app.configure('development', function(){
  app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
  app.set('db-uri', 'mongodb://localhost/namecards');
});

app.configure('production', function(){
  app.use(express.errorHandler());
});

models.defineModels(mongoose, function() {
  app.Document = Document = mongoose.model('Document');
  db = mongoose.connect(app.set('db-uri'));
})

// Routes

app.get('/', routes.index);

app.get('/add', routes.add_form);

app.post('/add', routes.add_document);

app.listen(3000);
console.log("Express server listening on port %d in %s mode", app.address().port, app.settings.env);

Zawartość „models.js”

function defineModels(mongoose, fn) {
  var Schema = mongoose.Schema,
      ObjectId = Schema.ObjectId;

  /**
   * Model: Document
   */
  Document = new Schema({
    'surname': String,
    'given_name': String,
    'org': String,
    'phone': String
  });

  mongoose.model('Document', Document);

  fn();
}

exports.defineModels = defineModels; 

Treść „./routes/index.js”

/*
 * GET home page.
 */

exports.index = function(req, res){
  res.render('index', { title: 'Documents' });
};

/*
 * GET add contact page.
 */
exports.add_form = function(req, res){
  res.render('add', { title: 'Add Document' });
};

/*
 * POST add contact page.
 */
exports.add_document = function(req, res){
  // Save data to DB using mongoose.
};
0
Benjen 7 marzec 2012, 10:45

2 odpowiedzi

Najlepsza odpowiedź

Znalazłem metodę, która wydaje się działać, która nie wymaga dużej liczby zmian w kodzie pierwotnie wygenerowanym przez Express. Wszystko, co musisz zrobić, to zaimportować mangusty do pliku zawierającego funkcje obsługi trasy, czyli kontrolery, a następnie załadować odpowiedni model w funkcji routingu (patrz exports.addProcess poniżej).

Oto zmodyfikowana zawartość „./routes/index.js”

var mongoose = require('mongoose');
var _ = require('underscore');


/*
 * GET home page.
 */

exports.index = function(req, res){
  res.render('index', { title: 'Documents' });
};

/*
 * POST add contact page.
 */
exports.addProcess = function(req, res){
  var Document = mongoose.model('Document');
  var document= new Document();
  document.surname = req.body.surname;
  document.given_name = req.body.given_name;
  document.org = req.body.org;
  document.phone = req.body.phone;
  document.save(function(err) {
    res.redirect('/');
  });
};
0
Benjen 8 marzec 2012, 12:53

Zwykle nazywam to kontrolerem, który podąża za MVC.

Zaimportowałbym mój model/schemat do kontrolera

Oto jak robię MVC w węźle/ekspresowym

//controller

module.exports = function (app, models) {
  var ctrl = {
    add_documents: function(req, res) {
         var document = new models.Document();
         document.something = something;
         document.save();
         res.end("Saved");
    }
  return crtl;
}

//sample model
module.exports = function(mongoose) {
var Document = new mongoose.Schema({
    field: value
});
var model = mongoose.model('Document', Document);
return model;
 }


//model loader
module.exports = function(app, mongoose) {
mongooseTypes = require("mongoose-types"); 
mongooseTypes.loadTypes(mongoose);
var obj = {
    Document: require('./models/document.js')(mongoose)
}
return obj;
}

//app.js
var mongoose = require('mongoose');
var models = require('./models')(app, mongoose);
var routes = require('./routes')(app, models); 

//routes
module.exports = function(app, models) {
    var DocumentController = require("./controllers/documents")(app, models);
    app.post('/documents:.format', DocumentController.add_documents);
}
0
j_mcnally 7 marzec 2012, 13:23