var Project = Backbone.Model.extend({
  urlRoot: '/projects'
});
Project.prototype.sync = require('backbone-orm').sync(Project);

var Project = Backbone.Model.extend({
  urlRoot: 'mongodb://localhost:27017/projects'
});
Project.prototype.sync = require('backbone-mongo').sync(Project);

// Node style
project.save(function(err, project) {
  if (err) {
    return console.log('Oh no an error');
  }
  return console.log("We're saved!");
});

// Backbone style
project.save({
  success: function(project) {
    return console.log("We're saved!");
  },
  error: function(project, err) {
    return console.log('Oh no an error');
  }
});

var MongoSync = require('backbone-mongo').sync;

var Project = Backbone.Model.extend({
  urlRoot: 'mongodb://localhost:27017/projects'
  schema: {
    tasks: function() { return ['hasMany', Task]; }
  }
});
Project.prototype.sync = MongoSync(Project);

var Task = Backbone.Model.extend({
  urlRoot: 'mongodb://localhost:27017/tasks'
  schema: {
    tasks: function() { return ['belongsTo', Project]; }
  }
});
Task.prototype.sync = MongoSync(Task);

// Find a project
Project.findOne({name: 'My project'}, function(err, project) {
  // Retrieve its tasks from mongo
  project.get('tasks', function(err, tasks) { /* do things with tasks */ });
});

// Find a project and its tasks with `$include`
Project.findOne({name: 'My project', $include: 'tasks'}, function(err, project) {
  // Tasks are already loaded, we can just use them
  var tasks = project.get('tasks');
});

// Find a project and its tasks using cursor with include
Project.cursor({name: 'My project'}).include('tasks').toModel function(err, project) {
  // Tasks are already loaded, we can just use them
  var tasks = project.get('tasks');
});

var MongoSync = require('backbone-mongo').Sync;

// manual_fetch: Tasks will not be loaded when accessing a projects tasks property
var Project = Backbone.Model.extend({
  urlRoot: 'mongodb://localhost:27017/projects',
  schema: {
    tasks: function() { return ['hasMany', Task, {manual_fetch: true}]; }
  }
});
Project.prototype.sync = MongoSync(Project);

// virtual: Tasks will not have their foreign keys updated automatically if a project is deleted
//          or it has its tasks changed while some are not loaded to memory
var Project = Backbone.Model.extend({
  urlRoot: 'mongodb://localhost:27017/projects',
  schema: {
    tasks: function() { return ['hasMany', Task, {virtual: true}]; }
  }
});

// embed: Tasks will be saved as an embedded document in each project
var Project = Backbone.Model.extend({
  urlRoot: 'mongodb://localhost:27017/projects',
  schema: {
    tasks: function() { return ['hasMany', Task, {embed: true}]; }
  }
});

// Find the Project with id = 123
Project.findOne({id: 123}, function(err, project) {});

// Find the first Project named 'my kickass project'
Project.findOne({name: 'my kickass project'}, function(err, project) {});

// Find all items with is_active = true
Project.find({is_active: true}, function(err, projects) {});

// Find the items with an id of 1, 2 or 3
Project.find({id: {$in: [1, 2, 3]}}, function(err, projects) {});

// A shortcut for `$in` when we're working with ids
Project.find({$ids: [1, 2, 3]}, function(err, projects) {});

// Find all items with is_active = true
Project.find({is_active: true, $limit: 10, $offset: 20}, function(err, projects) {});

// Select named properties from each model
Project.find({$select: ['created_at', 'name']}, function(err, array_of_json) {});

// Select values in the specified order
Project.find({$values: ['created_at', 'status']}, function(err, array_of_arrays) {});

// Find active items in pages using cursor syntax (Models or JSON)
Project.cursor({is_active: true}).limit(10).offset(20).toModels function(err, projects) {});
Project.cursor({is_active: true}).limit(10).offset(20).toJSON function(err, projects_json) {});

// Find completed tasks in a project sorted by name
project.cursor('tasks', {status: 'completed'}).sort('name').toModels function(err, tasks) {});

// Iterate through all items with is_active = true in batches of 200
Project.each({is_active: true, $each: {fetch: 200}},
  function(project, callback) {console.log('project: ' + project.get('name')); callback()},
  function(err) {return console.log('Done');}
);

// Stream all items with is_active = true in batches of 200
Project.stream({is_active: true, $each: {fetch: 200}})
  .pipe(new ModelStringifier())
  .on('finish', function() {return console.log('Done');});

var stats = [];
Task.interval({$interval: {key: 'created_at', type: 'days', length: 1}},
  function(query, info, callback) {
    var histogram = new Histogram()
    Task.stream(_.extend(query, {$select: ['created_at', 'status']}))
      .pipe(histogram)
      .on('finish', function() {stats.push(histogram.summary()); return callback();});
  },
  function(err) { return console.log('Done'); }
);

var Task = Backbone.Model.extend({
  urlRoot: '/tasks'
});
Task.prototype.sync = require('backbone-http').sync(Task);

var Task = Backbone.Model.extend({
  urlRoot: 'mongodb://localhost:27017/tasks'
});
Task.prototype.sync = require('backbone-mongo').sync(Task);

new RestController(app, {model_type: Task, route: '/tasks'});

module.exports = {
  // select id and name from the task
  {$select: ['id', 'name']}

  // use a render function
  task_custom:   function(model, options, callback) {
    callback(null, _.pick(model.attributes, 'id', 'name'))
  }

  // select properties from relationship
  project:          {$select: ['id', 'name']},

  // relationship inferred with query
  commits:          {query: {active: false}},

  // relationship with operation
  total_commits:    {key: 'commits', query: {$count: true}}
};