TypeScript mongoose.model函数代码示例

			$addToSet: { following: to }
		}
	).exec(function (err) {
		if (err)
			return callback(err);

		callback(null, null);
	});
};

// authenticate input against database
OrderSchema.statics.unFollow = function (from, to, callback) {

	Order.update(
		{
			_id: from,
		},
		{
			$inc: { followingCount: -1 },
			$pull: { following: to }
		}
	).exec(function (err) {
		if (err)
			return callback(err);

		callback(null, null);
	});
};

export const Order = model('Order', OrderSchema);

                    zip: String,
                    website: String,
                    latitude: Number,
                    longitude: Number
                }
            },
            date: Date,
            category: String,
            content: String
        }
    ],
    books: [
        {
            id: Number,
            isbn10: Number,
            isbn13: Number,
            title: String,
            category: String
        }
    ]
}

// userSchema.method['comparePassword'] = function(candidatePassword: String, cb: Function) {
//     bcrypt.compare(candidatePassword, this.password, function(err: Error, isMatch: Boolean) {
//         if (err) return cb(err);
//         cb(null, isMatch);
//     });
// };

export let User: mongoose.Model<IUser> = mongoose.model<IUser>('User', userSchema);

import * as mongoose from 'mongoose';

export interface IBlogModel extends app.i.IBlog, mongoose.Document{}


let blogSchema = new mongoose.Schema({
  title: { type: String, required: true },
  datePosted: { type: Number },
  body: { type: String, required: true },
  imageURL: { type: String, default: 'http://1.bp.blogspot.com/-Bsv5jXiALOk/UdXLHs5jwaI/AAAAAAAAIU0/JuhiK3PvL10/s541/kune-kune-piglets-stacked.jpg' },
  tags: String
});

export let Blog = mongoose.model<IBlogModel>('Blog', blogSchema);

var mongoose = require('mongoose');


var ThingSchema = new mongoose.Schema({
    userid: {
        type: String,
        required: true
    },
    expireAt: {
        type: Date,
        required: true,
        default: function() {
        // 60 seconds from now
        return new Date(new Date().valueOf() + 7260000);
    }
    }
});

// Expire at the time indicated by the expireAt field
ThingSchema.index({ expireAt: 1 }, { expireAfterSeconds : 0 });

export = mongoose.model('Recovery', ThingSchema);

PlatformSchema.pre('save', function(next: Function): void {
  let user = this

  // generate a salt then run callback
  if (user.isNew) {
    bcrypt
    .genSalt(10, (err: Error, salt: string) => {
      if (err) { return next(err) }

      // encrypt password with salt
      bcrypt.hash(user.password, salt, null, (err, hash) => {
        if (err) { return next(err) }

        // overwrite plain text password with encrypted password
        user.password = hash

        next()
      })
    })
  } else {
    UTIL.setUpdateTime(user, ['username', 'password', 'nickname', 'name', 'gender', 'mobile', 'email', 'pid', 'avatar', 'background', 'locale', 'city', 'country'])
    user.wasNew = user.isNew

    next()
  }
})

export { IPlatform }

export default model<IPlatform>('Platform', PlatformSchema)

import { Schema, model } from 'mongoose';
const JobSchema = new Schema({
    companyName: {type: String, required: true},
    fantasyName: {type: String, required: true},
    cnpj: {type: String, required: true},
    showCompanyName: Boolean,
    opportunityName: {type: String, required: true},
    opportunityDecription: {type: String, required: true},
    howToSubscribe: {type: String, required: true},
    contact: {
        email: {type: String, required: true},
        name: {type: String, required: true},
        phone: {type: String, required: true}
    },
    salaryRange: {type: String, required: true},
    opportunityType: {type: String, required: true},
    contractType: {type: String, required: true},
    city: {type: String, required: true},
    state: {type: String, required: true}
});
export const Job = model('Job', JobSchema);

 before((done) => {
     User = mongoose.model("User");
     user = new User();
     done();
 })

import * as mongoose from 'mongoose';

export interface ICommentModel extends app.i.IComment, mongoose.Document{}

let commentSchema = new mongoose.Schema({
    message: {type: String, required: true},
    datePosted: Number,
    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    event: {type: mongoose.Schema.Types.ObjectId, ref: 'Event', required: true}
});

export let Comment = mongoose.model<ICommentModel>('Comment', commentSchema);

import * as mongoose from 'mongoose';

export interface ITodoModel extends ITodo, mongoose.Document { }

let todoSchema = new mongoose.Schema({
  task: String,
  status: String,
});

export let Todo = mongoose.model('Todo', todoSchema);

        let user: IUser = users[0];
        user.compare(password, (bcryptErr, isAuth) => {
          if (bcryptErr) {
            cb(bcryptErr);
            return;
          }
          if (isAuth) {
            // remove the password from the fetched object
            delete user.password;
            cb(undefined, user);
            return;
          } else {
            cb(undefined, undefined);
          }
        });
      } else {
        cb(undefined, undefined);
      }
    });
  });
  
  userSchema.method('compare', function (password: string, cb: {(err: Error, isValid: boolean): void}): void {
    console.log('compare');
    bcrypt.compare(password, this.password, cb);
  });

  export const User: Model<IUser> = mongoose.model<IUser>('User', userSchema);

}
export = User;