Stellen Sie alle erforderlichen Felder in Mungo

Mungo scheint standardmäßig alle Felder, die nicht erforderlich sind. Gibt es eine Möglichkeit, um alle Felder erforderlich, ohne änderung jedem:

Dimension = mongoose.Schema(
  name: String
  value: String
)

zu

Dimension = mongoose.Schema(
  name:
    type: String
    required: true
  value: 
    type: String
    required: true
)

Werde es wirklich hässlich, da ich eine Menge von diesen.

InformationsquelleAutor der Frage maxko87 | 2013-11-04

  1. 10

    Könnte man etwas machen wie:

    var schema = {
  name: { type: String},
  value: { type: String}
};

var requiredAttrs = ['name', 'value'];

for (attr in requiredAttrs) { schema[attr].required = true; }

var Dimension = mongoose.schema(schema);

    oder für alle attrs (mit Unterstrich, der ist genial):

    var schema = {
  name: { type: String},
  value: { type: String}
};

_.each(_.keys(schema), function (attr) { schema[attr].required = true; });

var Dimension = mongoose.schema(schema);

    InformationsquelleAutor der Antwort 190290000 Ruble Man

  2. 9

    Landete ich, dies zu tun:

    r_string = 
  type: String
  required: true 

r_number = 
  type: Number
  required: true

    und für die anderen Datentypen.

    InformationsquelleAutor der Antwort maxko87

  3. 4

    Alle Felder Eigenschaften sind in schema.paths[attribute] oder schema.path(attribute);

    Einen richtigen Weg zu gehen : definieren, wenn ein Feld ist NICHT erforderlich, 

    Schema = mongoose.Schema;
var Myschema = new Schema({
    name : { type:String },
    type : { type:String, required:false }
})

    und machen Sie alle erforderlichen standardmäßig :

    function AllFieldsRequiredByDefautlt(schema) {
    for (var i in schema.paths) {
        var attribute = schema.paths[i]
        if (attribute.isRequired == undefined) {
            attribute.required(true);
        }
    }
}

AllFieldsRequiredByDefautlt(Myschema)

    Den Unterstrich Weg :

    _=require('underscore')
_.each(_.keys(schema.paths), function (attr) {
    if (schema.path(attr).isRequired == undefined) {
        schema.path(attr).required(true);
    }
})

    Test :

    MyTable = mongoose.model('Myschema', Myschema);
t = new MyTable()
t.save()

    InformationsquelleAutor der Antwort Flint

  4. 3

    Gut könnten Sie schreiben, eine Mungo-schema plugin-Funktion, die ging, das schema-Objekt und es angepasst, um jedes Feld erforderlich. Dann würden Sie brauchen nur 1 Zeile pro schema: Dimension.plugin(allRequired).

    InformationsquelleAutor der Antwort Peter Lyons

  5. 2

    Mongoose hat nicht die Methode der Aktivierung aller Felder, aber man kann es rekursiv.

    Wie Peter erwähnt, könnte man pluginize es um den code wiederverwenden.

    Rekursiv Einstellung: 

    //game.model.js
var fields = require('./fields');
var Game = new Schema({ ... });

for(var p in Game.paths){
  Game.path(p).required(true);
}

    Pluginized:

    //fields.js
module.exports = function (schema, options) {
  if (options && options.required) {
    for(var p in schema.paths){
      schema.path(p).required(true);
    }
  }
}

//game.model.js
var fields = require('./fields');
var Game = new Schema({ ... });
Game.plugin(fields, { required: true });

    InformationsquelleAutor der Antwort chuyik

  6. 0

    Ich bin mir nicht sicher, ob es ist ein einfacher Weg, es zu tun in Mungo, aber ich würde Folgendes tun Sie Ihre IDE/editor:

    Liste aus Sie Ihre Felder wie gewohnt:

    Dimension = mongoose.Schema(
  name: String
  value: String
)

    Dann tun Sie eine Suche durch und ersetzen Sie auf String und ersetzen Sie es mit {type: String, required: true}, Geben Sie:

    Dimension = mongoose.Schema(
  name: {type: String, required: true},
  value:  {type: String, required: true},
)

    Dann tun Sie das gleiche für Number und andere Arten.

    InformationsquelleAutor der Antwort Samuel O'Malley

  7. 0

    Aufbauend auf die vorherigen Antworten, das Modul unten machen erforderlichen Felder standardmäßig. Die vorherigen Antworten nicht Rekursion verschachtelte Objekte/arrays.

    Verwendung:

    const rSchema = require("rschema");

var mySchema = new rSchema({
    request:{
        key:String,
        value:String
    },
    responses:[{
        key:String,
        value:String
    }]
});

    Node-Modul:

    const Schema = require("mongoose").Schema;

//Extends Mongoose Schema to require all fields by default
module.exports = function(data){
    //Recursive
    var makeRequired = function(schema){
        for (var i in schema.paths) {
            var attribute = schema.paths[i];
            if (attribute.isRequired == undefined) {
                attribute.required(true);
            }
            if (attribute.schema){
                makeRequired(attribute.schema);
            }
        }
    };

    var schema = new Schema(data);
    makeRequired(schema);
    return schema;
};

    InformationsquelleAutor der Antwort koga73

Schreibe einen Kommentar