var model = require('model');
 
// Setup the blueprint of the model. This is where you can
// setup the model properties, defaults, and validations
var Foo = function () {
  this.setAdapter('level', {
    db: './data'
  });
 
  // Define the whitelisted properties on the model.
  // Properties not listed wont be saved
  this.defineProperties({
    name: { type: 'string', required: true },
    description: { type: 'text' },
    enabled: { type: 'boolean' },
    archived: { type: 'boolean' },
  });
};
 
// This registers the model with the model package so
// things like associations can work
Foo = model.register('Foo', Foo);
 
// Now we export Foo to create a reusable model module
module.exports = Foo;

var User = function () {
  this.property('login', 'string', {required: true});
  this.property('password', 'string', {required: true});
  this.property('lastName', 'string');
  this.property('firstName', 'string');
 
  this.validatesPresent('login');
  this.validatesFormat('login', /[a-z]+/, {message: 'Subdivisions!'});
  this.validatesLength('login', {min: 3});
  this.validatesConfirmed('password', 'confirmPassword');
  this.validatesWithFunction('password', function (s) {
      if (password.indexOf('login')) {
          // Returning a string indicates that the validation has failed.
          // The string will be used as the message.
          return "Password must not contain your username";
      }
      return true;
  });
 
  this.someMethod = function () {
    // Do some stuff
  };
};
 
// prepares the model and adds it as a property on `model`
User = model.register('User', User);

var model = require('model');
 
var Foo = function () {
  this.setAdapter('mongo', {
    "hostname":"localhost",
    "port":27017,
    "username":"",
    "password":"",
    "dbName":"mydatabase"
  });
 
  this.defineProperties({
    name: { type: 'string', required: true }
  });
};
 
Foo = model.register('Foo', Foo);
 
module.exports = Foo;

var User = function () {
  this.defineProperties({
    login: {type: 'string', required: true}
  , password: {type: 'string', required: true}
  , lastName: {type: 'string'}
  , firstName: {type: 'string'}
  });
}

var User = function () {
    this.property('email', 'string');
    this.property('sendUpdates', 'boolean');
 
    // setting a property on `this` in the constructor creates an instance method
    this.sendConfirmation = function (callback) {
        // send confirmation message
    }
}
 
// setting a property on the prototype creates an instance method
User.prototype.sendNewsletter = function (callback) {
    // send newsletter
}
 
// setting a property on the constructor creates a class method
User.sendNewsletters = function (callback) {
    // send newsletter to users that opted into updates
}
 
User = model.register('User', User);

var adapter = model.createAdapter('postgres', {
, host: 'localhost'
, username: 'user'
, password: 'password'
, database: 'mydb'
});

model.config.defaultAdapter = model.createAdapter('postgres', {
  host: 'localhost',
  username: 'user',
  password: 'password',
  database: 'mydb'
});

var params = {
  login: 'alex'
, password: 'lerxst'
, lastName: 'Lifeson'
, firstName: 'Alex'
};
var user = User.create(params);

var User = function () {
  this.property('login', 'string', {required: true});
  this.property('password', 'string', {required: true});
  this.property('lastName', 'string');
  this.property('firstName', 'string');
 
  this.validatesPresent('login');
  this.validatesFormat('login', /[a-z]+/, {message: 'Subdivisions!'});
  this.validatesLength('login', {min: 3});
  this.validatesConfirmed('password', 'confirmPassword');
  this.validatesWithFunction('password', function (s) {
      // Something that returns true or false
      return s.length > 0;
  });
  this.validatesAbsent('unconfirmed');
  this.validatesWithFunction('password', function (value, model) {
      // if the function returns false it will use a standard message
      if (typeof value != typeof "") {
      	 return false;
      }
 
      // if it returns a string the string will be used as an error message
      if  (value.length <= 3) {
      	 return "Your password must be at least 4 characters long ";
      }
 
      // return true if the validation passed
      return true;
  });
 
  // methods for instances can be defined in the constructor like this
  this.someMethod = function () {
    // Do some stuff
  };
};

var Zerb = function () {
  this.property('name', 'string');
  this.validatesLength('name', {is: 3, message: 'Try again, gotta be 3!'});
};

var User = function () {
  this.property('name', 'string', {required: false});
  this.property('password', 'string', {required: false});
 
  this.validatesLength('name', {min: 3, on: ['create', 'update']});
  this.validatesPresent('password', {on: 'create'});
  this.validatesConfirmed('password', 'confirmPassword', {on: 'create'});
};
 
// Name validation will pass, but password will fail
myUser = User.create({name: 'aaa'});
 

// Force validation with the `reify` scenario, ignore the too-short name property
myUser = User.create({name: 'aa'}, {scenario: 'reify'});
 
// You can also specify a scenario with these methods:
// Enforce 'create' validations on a fetch -- may result in invalid instances
User.first(query, {scenario: 'create'}, cb);
// Do some special validations you need for credit-card payment
User.updateProperties(newAttrs, {scenario: 'creditCardPayment'});

// Leaving out the required password field
var params = {
  login: 'alex'
};
var user = User.create(params);
 
// Prints 'false'
console.log(user.isValid());
// Prints 'Field "password" is required'
console.log(user.errors.password);

if (user.isValid()) {
  user.save(function (err, data) {
    if (err) {
      throw err;
    }
    console.log('New item saved!');
  });
}

user.updateProperties({
  login: 'alerxst'
});
if (user.isValid()) {
  user.save(function (err, data) {
    if (err) {
      throw err;
    }
    console.log('Item updated!');
  });
}

model.User.remove(user.id, function(err) {
  if (err) {
    throw err;
  }
  console.log('Item removed!');
});

var User = function () {
  this.property('name', 'string', {required: false});
 
  // Make sure there's a name in the params before validating
  this.beforeValidate = function (params) {
    params.name = params.name || 'Zerp Derp';
  };
};

var User = function () {
  this.property('login', 'string', {required: true});
  this.property('password', 'string', {required: true});
  this.property('confirmPassword', 'string', {required: true});
 
  this.hasOne('Profile');
  this.hasMany('Accounts');
};
 
var Profile = function() {
  // properties
 
  this.belongsTo('Account');
};
 
var Account = function() {
  // properties
 
  this.belongsTo('User');
};
 
// Names in association methods must match the names that models are registered with.
// The name given to hasMany is pluralized.
User = model.register('User', User);
Profile = model.register('Profile', Profile);
Account = model.register('Account', Account);

var user = User.create({
  login: 'asdf'
, password: 'zerb'
, confirmPassword: 'zerb'
});
user.save(function (err, data) {
  var profile;
  if (err) {
    throw err;
  }
  profile = Profile.create({});
  user.setProfile(profile);
  user.save(function (err, data) {
    if (err) {
      throw err;
    }
    user.getProfile(function (err, data) {
      if (err) {
        throw err;
      }
      console.log(profile.id ' is the same as ' + data.id);
    });
  });
});

var user = User.create({
  login: 'asdf'
, password: 'zerb'
, confirmPassword: 'zerb'
});
user.save(function (err, data) {
  if (err) {
    throw err;
  }
  user.addAccount(Account.create({}));
  user.addAccount(Account.create({}));
  user.save(function (err, data) {
    if (err) {
      throw err;
    }
    user.getAccounts(function (err, data) {
      if (err) {
        throw err;
      }
      console.log('This number should be 2: ' + data.length);
    });
  });
});

var book = Book.create({
  title: 'How to Eat an Entire Ham'
, description: 'Such a poignant book. I cried.'
});
book.save(function (err, data) {
  if (err) {
    throw err;
  }
  book.setAuthor(Author.create({
    familyName: 'Neeble'
  , givenName: 'Leonard'
  }));
  book.save(function (err, data) {
    if (err) {
      throw err;
    }
    book.getAuthor(function (err, data) {
      if (err) {
        throw err;
      }
      console.log('This name should be "Neeble": ' + data.familyName);
    });
  });
});

User.first({login: 'asdf'}, function (err, user) {
  if (err) {
    throw err;
  }
  // Fetch accounts
  user.getAccounts(function (err, accounts) {
    var originalCount;
    if (err) {
      throw err;
    }
    originalCount = accounts.length;
 
    // Remove the first account
    user.removeAccount(accounts[0]);
    // Save the user
    user.save(function (err) {
      if (err) {
        throw err;
      }
      // Fetch accounts again
      user.getAccounts(function (err, accounts) {
        if (err) {
          throw err;
        }
        Console.log(accounts.length + ' should be one less than ' +
            originalCount);
      });
    });
  });
});

var Player = function () {
  this.property('familyName', 'string', {required: true});
  this.property('givenName', 'string', {required: true});
  this.property('jerseyNumber', 'string', {required: true});
 
  this.hasMany('Memberships');
  this.hasMany('Teams', {through: 'Memberships'});
};
 
var Team = function () {
  this.property('name', 'string', {required: true});
 
  this.hasMany('Memberships');
  this.hasMany('Players', {through: 'Memberships'});
};
 
var Membership = function () {
  this.belongsTo('User');
  this.belongsTo('Team');
};

var User = function () {
  this.property('familyName', 'string', {required: true});
  this.property('givenName', 'string', {required: true});
 
  this.hasMany('Kids', {model: 'Users'});
};