node.js - pathname - parse url npm




adicione campos created_at e updated_at aos esquemas do mangusto (12)

Existe uma maneira de adicionar campos created_at e updated_at a um esquema de mongoose, sem ter que passá-los toda vez que um novo MyModel () é chamado?

O campo created_at seria uma data e será adicionado somente quando um documento for criado. O campo updated_at seria atualizado com nova data sempre que save () fosse chamado em um documento.

Eu tentei isso no meu esquema, mas o campo não aparece a menos que eu o adicione explicitamente:

var ItemSchema = new Schema({
    name    : { type: String, required: true, trim: true }
  , created_at    : { type: Date, required: true, default: Date.now }
});

A partir do Mongoose 4.0, agora você pode definir uma opção de registro de data e hora no esquema para que o Mongoose manipule isso para você:

var thingSchema = new Schema({..}, { timestamps: true });

Você pode alterar o nome dos campos usados ​​da seguinte forma:

var thingSchema = new Schema({..}, { timestamps: { createdAt: 'created_at' } });

#timestamps


Adicione timestamps ao seu Schema como este então createdAt e updatedAt gerará automaticamente para você

var UserSchema = new Schema({
    email: String,
    views: { type: Number, default: 0 },
    status: Boolean
}, { timestamps: {} });


Além disso, você pode alterar createdAt -> created_at por

timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }

Foi assim que consegui criar e atualizar.

Dentro do meu esquema eu adicionei o criado e atualizado assim:

   /**
     * Article Schema
     */
    var ArticleSchema = new Schema({
        created: {
            type: Date,
            default: Date.now
        },
        updated: {
            type: Date,
            default: Date.now
        },
        title: {
            type: String,
            default: '',
            trim: true,
            required: 'Title cannot be blank'
        },
        content: {
            type: String,
            default: '',
            trim: true
        },
        user: {
            type: Schema.ObjectId,
            ref: 'User'
        }
    });

Em seguida, no meu método de atualização de artigos dentro do controlador de artigos, adicionei:

/**
     * Update a article
     */
    exports.update = function(req, res) {
        var article = req.article;

        article = _.extend(article, req.body);
        article.set("updated", Date.now());

        article.save(function(err) {
            if (err) {
                return res.status(400).send({
                    message: errorHandler.getErrorMessage(err)
                });
            } else {
                res.json(article);
            }
        });
    };

As seções em negrito são as partes de interesse.


Foi o que acabei fazendo:

var ItemSchema = new Schema({
    name    : { type: String, required: true, trim: true }
  , created_at    : { type: Date }
  , updated_at    : { type: Date }
});


ItemSchema.pre('save', function(next){
  now = new Date();
  this.updated_at = now;
  if ( !this.created_at ) {
    this.created_at = now;
  }
  next();
});

Se usar update() ou findOneAndUpdate()

com a opção {upsert: true}

você pode usar $setOnInsert

var update = {
  updatedAt: new Date(),
  $setOnInsert: {
    createdAt: new Date()
  }
};

Use a opção de timestamps e timestamps interno para o seu esquema.

var ItemSchema = new Schema({
    name: { type: String, required: true, trim: true }
},
{
    timestamps: true
});

Isso adicionará automaticamente os campos updatedAt e updatedAt ao seu esquema.

#timestamps


Use uma função para retornar o valor padrão computado:

var ItemSchema = new Schema({
    name: {
      type: String,
      required: true,
      trim: true
    },
    created_at: {
      type: Date,
      default: function(){
        return Date.now();
      }
    },
    updated_at: {
      type: Date,
      default: function(){
        return Date.now();
      }
    }
});

ItemSchema.pre('save', function(done) {
  this.updated_at = Date.now();
  done();
});

Você pode usar middleware e virtuals . Aqui está um exemplo para o seu campo updated_at :

ItemSchema.virtual('name').set(function (name) {
  this.updated_at = Date.now;
  return name;
});

Você pode usar o plug mongoose-troop in de timestamp do mongoose-troop para adicionar esse comportamento a qualquer esquema.


nós podemos conseguir isso usando o plugin de esquema também.

No arquivo helpers/schemaPlugin.js

module.exports = function(schema) {

  var updateDate = function(next){
    var self = this;
    self.updated_at = new Date();
    if ( !self.created_at ) {
      self.created_at = now;
    }
    next()
  };
  // update date for bellow 4 methods
  schema.pre('save', updateDate)
    .pre('update', updateDate)
    .pre('findOneAndUpdate', updateDate)
    .pre('findByIdAndUpdate', updateDate);
};

e no arquivo models/ItemSchema.js :

var mongoose = require('mongoose'),
  Schema   = mongoose.Schema,
  SchemaPlugin = require('../helpers/schemaPlugin');

var ItemSchema = new Schema({
  name    : { type: String, required: true, trim: true },
  created_at    : { type: Date },
  updated_at    : { type: Date }
});
ItemSchema.plugin(SchemaPlugin);
module.exports = mongoose.model('Item', ItemSchema);

const mongoose = require('mongoose');
const config = require('config');
const util = require('util');

const Schema = mongoose.Schema;
const BaseSchema = function(obj, options) {
  if (typeof(options) == 'undefined') {
    options = {};
  }
  if (typeof(options['timestamps']) == 'undefined') {
    options['timestamps'] = true;
  }

  Schema.apply(this, [obj, options]);
};
util.inherits(BaseSchema, Schema);

var testSchema = new BaseSchema({
  jsonObject: { type: Object }
  , stringVar : { type: String }
});

Agora você pode usar isso, para que não haja necessidade de incluir essa opção em todas as tabelas








mongoose