dodaj pola created_at i updated_at do schematów mangusty

Czy istnieje sposób na dodanie pól created_at i updated_at do schematu mangusty bez konieczności ich przekazywania za każdym razem, gdy wywoływana jest funkcja new MyModel ()?

Pole created_at byłoby datą i jest dodawane tylko podczas tworzenia dokumentu. Pole updated_at będzie aktualizowane nową datą za każdym razem, gdy wywoływana jest metoda save () w dokumencie.

Próbowałem tego w moim schemacie, ale pole nie pojawia się, chyba że dodam je w sposób dokładny:

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

Począwszy od Mongoose 4.0, możesz teraz ustawić opcję znaczników czasu w schemacie, aby Mongoose zajął się tym za Ciebie:

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

Możesz zmienić nazwy pól używanych w następujący sposób:

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

http://mongoosejs.com/docs/guide.html#timestamps

UPDATE: (5 lat później)

Uwaga: jeśli zdecydujesz się na korzystanie z architektury Kappa ( źródło zdarzeń + CQRS ), nie potrzebujesz w ogóle zaktualizowanej daty. Ponieważ Twoje dane są niezmiennym dziennikiem zdarzeń, który można tylko dopisać, potrzebujesz tylko daty utworzenia zdarzenia. Podobna do opisanej poniżej architektury lambda . W takim przypadku stan aplikacji jest projekcją dziennika zdarzeń (danych pochodnych). Jeśli otrzymasz kolejne zdarzenie dotyczące istniejącej encji, użyjesz daty utworzenia tego zdarzenia jako zaktualizowanej daty swojej encji. Jest to powszechnie stosowana (i często niezrozumiana) praktyka w systemach mikrousług.

UPDATE: (4 lata później)

Jeśli używasz ObjectIdjako swojego _idpola (co zwykle ma miejsce), wszystko, co musisz zrobić, to:

let document = {
  updatedAt: new Date(),
}

Sprawdź moją oryginalną odpowiedź poniżej, jak uzyskać utworzony znacznik czasu z _idpola. Jeśli potrzebujesz użyć identyfikatorów z systemu zewnętrznego, sprawdź odpowiedź Romana Rhrna Nesterova.

AKTUALIZACJA: (2,5 roku później)

Możesz teraz użyć opcji #timestamps z wersją mangusty> = 4.0.

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

Jeśli ustawisz sygnatury czasowe, przypisania mongoose createdAti updatedAtpola do schematu, przypisany typ to Date.

Możesz także określić nazwy zbiorów sygnatur czasowych:

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

Uwaga: jeśli pracujesz nad dużą aplikacją z krytycznymi danymi, powinieneś ponownie rozważyć aktualizację dokumentów. Radziłbym pracować z niezmiennymi danymi tylko do dołączania ( architektura lambda ). Oznacza to, że zezwalasz tylko na wstawianie. Aktualizacje i usuwanie nie powinny być dozwolone! Jeśli chcesz „usunąć” rekord, możesz łatwo wstawić nową wersję dokumentu z jakimś timestamp/ version wypełnionym, a następnie ustawić deletedpole na true. Podobnie, jeśli chcesz zaktualizować dokument - tworzysz nowy z zaktualizowanymi odpowiednimi polami i skopiowanymi pozostałymi polami, a następnie, aby odpytać ten dokument, otrzymasz dokument z najnowszym znacznikiem czasu lub najwyższą wersją, która jest nie „usunięte” (deleted pole jest niezdefiniowane lub fałszywe`).

Niezmienność danych zapewnia możliwość debugowania danych - możesz prześledzić historię każdego dokumentu. Możesz także przywrócić poprzednią wersję dokumentu, jeśli coś pójdzie nie tak. Jeśli wybierzesz taką architekturę, ObjectId.getTimestamp()to wszystko, czego potrzebujesz, i nie jest ona zależna od Mongoose.

ORYGINALNA ODPOWIEDŹ:

Jeśli używasz ObjectId jako pola tożsamości, nie potrzebujesz created_atpola. ObjectIds mają metodę o nazwie getTimestamp().

ObjectId ("507c7f79bcf86cd7994f6c0e"). GetTimestamp ()

To zwróci następujące dane wyjściowe:

ISODate („2012-10-15T21: 26: 17Z”)

Więcej informacji tutaj Jak wyodrębnić datę utworzenia z Mongo ObjectID

Aby dodać pole updated_at, musisz użyć tego:

var ArticleSchema = new Schema({
  updated_at: { type: Date }
  // rest of the fields go here
});

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

Oto, co ostatecznie zrobiłem:

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();
});

Użyj wbudowanej timestampsopcji dla swojego schematu.

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

To automatycznie doda createdAti updatedAtpola do schematu.

http://mongoosejs.com/docs/guide.html#timestamps

Jeśli używasz update()lubfindOneAndUpdate()

z {upsert: true}opcją

możesz użyć $setOnInsert

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

Dodaj timestampsdo swojej Schematak wtedy createdAti updatedAtbędzie automatyczne generowanie dla Ciebie

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

Ponadto można zmienić createdAt -> created_atprzez

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

W ten sposób osiągnąłem, tworząc i aktualizując.

Wewnątrz mojego schematu dodałem utworzony i zaktualizowany w następujący sposób:

   / **
     * Schemat artykułu
     * /
    var ArticleSchema = new Schema ({
        Utworzony: {
            typ: Data,
            domyślnie: Date.now
        },
        zaktualizowane: {
            typ: Data,
            domyślnie: Date.now
        },
        title: {
            typ: Sznurek,
            domyślna: '',
            wykończenie: prawda,
            wymagane: „Tytuł nie może być pusty”
        },
        zadowolony: {
            typ: Sznurek,
            domyślna: '',
            wykończenie: prawda
        },
        użytkownik: {
            type: Schema.ObjectId,
            ref: 'Użytkownik'
        }
    });

Następnie w mojej metodzie aktualizacji artykułu w kontrolerze artykułu dodałem:

/ **
     * Zaktualizuj artykuł
     * /
    exports.update = function (req, res) {
        var artykuł = req.article;

        artykuł = _.extend (artykuł, req.body);
        article.set ("zaktualizowany", Date.now ());

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

Pogrubione sekcje to części, które Cię interesują.

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

ItemSchema.set('timestamps', true); // this will add createdAt and updatedAt timestamps

Dokumenty: https://mongoosejs.com/docs/guide.html#timestamps

Możesz użyć timestampwtyczki programu, mongoose-troopaby dodać to zachowanie do dowolnego schematu.

Możesz bardzo łatwo korzystać z tej wtyczki . Z dokumentów:

var timestamps = require('mongoose-timestamp');
var UserSchema = new Schema({
    username: String
});
UserSchema.plugin(timestamps);
mongoose.model('User', UserSchema);
var User = mongoose.model('User', UserSchema)

A jeśli chcesz, ustaw również nazwy pól:

mongoose.plugin(timestamps,  {
  createdAt: 'created_at', 
  updatedAt: 'updated_at'
});

możemy to osiągnąć również za pomocą wtyczki schematu .

W helpers/schemaPlugin.jspliku

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

aw models/ItemSchema.jspliku:

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);

W schemacie modelu po prostu dodaj sygnatury czasowe atrybutu i przypisz mu wartość true , jak pokazano: -

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

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

Teraz możesz tego użyć, aby nie trzeba było uwzględniać tej opcji w każdej tabeli

Moja wersja mangusty to 4.10.2

Wygląda na findOneAndUpdateto, że działa tylko hak

ModelSchema.pre('findOneAndUpdate', function(next) {
  // console.log('pre findOneAndUpdate ....')
  this.update({},{ $set: { updatedAt: new Date() } });
  next()
})

Użyj funkcji, aby zwrócić obliczoną wartość domyślną:

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();
});

Właściwie robię to z tyłu

Jeśli wszystko pójdzie dobrze z aktualizacją:

 // All ifs passed successfully. Moving on the Model.save
    Model.lastUpdated = Date.now(); // <------ Now!
    Model.save(function (err, result) {
      if (err) {
        return res.status(500).json({
          title: 'An error occured',
          error: err
        });
      }
      res.status(200).json({
        message: 'Model Updated',
        obj: result
      });
    });

Sformatuj datę i godzinę za pomocą pakietu maszynowego-datetime.

tutorialSchema.virtual('createdOn').get(function () {
    const DateTime = require('machinepack-datetime');
    let timeAgoString = "";
    try {
        timeAgoString = DateTime.timeFrom({
            toWhen: DateTime.parse({
                datetime: this.createdAt
            }).execSync(),
            fromWhen: new Date().getTime()
        }).execSync();
    } catch(err) {
        console.log('error getting createdon', err);
    }
    return timeAgoString; // a second ago
});

Pakiet maszynowy jest świetny z przejrzystym interfejsem API, w przeciwieństwie do ekspresowego lub ogólnego świata Javascript.

Możesz użyć oprogramowania pośredniego i wirtualnych . Oto przykład dla twojego updated_atpola:

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