odm.prototype.getModel = function(modelName, action, json) {
if (modelName == 'token') {
var OAuthAccessTokens = mongoose.model('OAuthAccessTokens');
if (action === 'create') {
token = new OAuthAccessTokens(json);
return token;
}
return OAuthAccessTokens;
}
if (modelName == 'client') {
var OAuthClients = mongoose.model('OAuthClients');
if (action === 'create') {
var client = new OAuthClients(json);
return client;
}
return OAuthClients;
}
if (modelName == 'user') {
var OAuthUsers = mongoose.model('OAuthUsers');
if (action === 'create') {
users = new OAuthUsers(json);
return users;
}
return OAuthUsers;
}
}
before(function defineProductAndCategoryModels() {
var Team = app.model(
'Team',
{ properties: { name: 'string' },
dataSource: 'db'
}
);
var Reader = app.model(
'Reader',
{ properties: { name: 'string' },
dataSource: 'db'
}
);
var Picture = app.model(
'Picture',
{ properties: { name: 'string', imageableId: 'number', imageableType: 'string'},
dataSource: 'db'
}
);
Reader.hasMany(Picture, { polymorphic: { // alternative syntax
as: 'imageable', // if not set, default to: reference
foreignKey: 'imageableId', // defaults to 'as + Id'
discriminator: 'imageableType' // defaults to 'as + Type'
} });
Picture.belongsTo('imageable', { polymorphic: {
foreignKey: 'imageableId',
discriminator: 'imageableType'
} });
Reader.belongsTo(Team);
});
before(function defineModels() {
var Book = app.model(
'Book',
{ properties: { name: 'string' }, dataSource: 'db',
plural: 'books' }
);
var Page = app.model(
'Page',
{ properties: { name: 'string' }, dataSource: 'db',
plural: 'pages' }
);
var Image = app.model(
'Image',
{ properties: { name: 'string' }, dataSource: 'db',
plural: 'images' }
);
var Note = app.model(
'Note',
{ properties: { text: 'string' }, dataSource: 'db',
plural: 'notes' }
);
var Chapter = app.model(
'Chapter',
{ properties: { name: 'string' }, dataSource: 'db',
plural: 'chapters' }
);
Book.hasMany(Page);
Book.hasMany(Chapter);
Page.hasMany(Note);
Chapter.hasMany(Note);
Image.belongsTo(Book);
// fake a remote method that match the filter in Model.nestRemoting()
Page.prototype['__throw__errors'] = function() {
throw new Error('This should not crash the app');
};
Page.remoteMethod('__throw__errors', { isStatic: false, http: { path: '/throws', verb: 'get' } });
Book.nestRemoting('pages');
Book.nestRemoting('chapters');
Image.nestRemoting('book');
expect(Book.prototype['__findById__pages__notes']).to.be.a.function;
expect(Image.prototype['__findById__book__pages']).to.be.a.function;
Page.beforeRemote('prototype.__findById__notes', function(ctx, result, next) {
ctx.res.set('x-before', 'before');
next();
});
Page.afterRemote('prototype.__findById__notes', function(ctx, result, next) {
ctx.res.set('x-after', 'after');
next();
});
});
before(function defineProductAndCategoryModels() {
var recipe = app.model(
'recipe',
{ properties: { name: 'string' }, dataSource: 'db' }
);
var ingredient = app.model(
'ingredient',
{ properties: { name: 'string' }, dataSource: 'db' }
);
recipe.referencesMany(ingredient);
});
beforeEach(function defineProductAndCategoryModels() {
var product = app.model(
'product',
{ properties: { id: 'string', name: 'string' }, dataSource: 'db' }
);
var category = app.model(
'category',
{ properties: { id: 'string', name: 'string' }, dataSource: 'db' }
);
product.hasAndBelongsToMany(category);
category.hasAndBelongsToMany(product);
});
before(function defineGroupAndPosterModels() {
var group = app.model(
'group',
{ properties: { name: 'string' },
dataSource: 'db',
plural: 'groups'
}
);
var poster = app.model(
'poster',
{ properties: { url: 'string' }, dataSource: 'db' }
);
group.embedsOne(poster, { as: 'cover' });
});
before(function defineProductAndCategoryModels() {
var todoList = app.model(
'todoList',
{ properties: { name: 'string' },
dataSource: 'db',
plural: 'todo-lists'
}
);
var todoItem = app.model(
'todoItem',
{ properties: { content: 'string' }, dataSource: 'db' }
);
todoList.embedsMany(todoItem, { as: 'items' });
});
exports.getSignature = function(request, response){
AWS.config.update(assets.AWSCredentials);
orm.model("User").then(function(User){
var user = User.current(request);
var date = new Date();
var filename = date.getTime()+assets.randomString(15);
var s3 = new AWS.S3();
var s3_params = {
Bucket: request.params.folder,
Key: ""+filename,
Expires: 60,
ContentType: request.params.file_type,
ACL: 'public-read'
};
s3.getSignedUrl('putObject', s3_params, function(err, data){
if(err){
response.error(err);
}else{
var return_data = {
signed_request: data,
filename: filename,
contentType: request.params.file_type,
folder: request.params.folder,
url: 'https://'+request.params.folder+'.s3.amazonaws.com/'+filename
};
response.success(return_data);
}
});
});
};
load: function(callback) {
console.log(__filename, ':: load() starting');
require('./accessors').load();
require('./tile_lat_long').load();
if (!(MOLA.extensions.hasOwnProperty('tile_data') && MOLA.extensions.tile_data)) {
for (var prop in module.exports) {
if (prop != 'load') {
MOLA.prototype[prop] = module.exports[prop];
}
}
MOLA.extensions.tile_data = true;
mm.model('map_sectors', function(err, ms) {
sectors_model = ms;
console.log(__filename, ': LOADED');
callback();
})
}
}
module.exports = function(context) {
var params = context.params();
var self = this;
mm.model('sector_models', function(err, s_model) {
var params = context.request.params;
var sector_web_root = '/img/maps/sectors/' + params.id + '/' + params.x + '/' + params.y + '/' + params.w;
var sector_img_root = MVC_PUBLIC + sector_web_root;
fs_utils.ensure_dir(sector_img_root);
var web_file = '/' + params.h + '.png';
var out_path = sector_img_root + web_file;
s_model.get(params.id, function(err, sector) {
s_model.region(sector, params.x, params, y, params.w, params.h, function(err, heights) {
var mola = new MOLA('', params.w, params.h, scale());
mola.data = heights;
mola.draw(out_path, function() {
context.flash('image made', 'info', '/maps/' + sector.map);
// context.redirect(sector_web_root + web_file + '?redirect=1');
// which should be a file at this point
});
})
});
});
}
exports.teamMembersForProject = function(request, response){
orm.model(["User", "Project"]).then(function(d){
var user = d.User.current(request);
var id_user = user.id;
var id_project = request.params.id_project;
var authorized = false;
d.Project.teamMembersForProject(id_project).then(function(members){
_.each(members, function(member){
if(member.id == id_user){
authorized = true;
}
});
if(!authorized){
response.error('You cannot retrieve the team members for a project in which you do not belong.');
reject('You cannot retrieve the team members for a project in which you do not belong.');
} else {
response.success(members);
}
}, function(err){
response.error(err);
});
});
};
it('should report 404 for HEAD /:id not found', function(done) {
app.model(MyModel);
app.use(loopback.rest());
request(app).head('/mymodels/1')
.expect(404)
.end(done);
});
it('works out-of-the-box', function(done) {
app.model(MyModel);
app.use(loopback.rest());
request(app).get('/mymodels')
.expect(200)
.end(done);
});
exports.recoverPassword = function(request, response){
var email = request.params.email;
// Sends an email to the user to recover the password
orm.model(["UserRecoverPassword", "User"]).then(function(d){
d.User.userByEmail(email).then(function(user){
d.UserRecoverPassword.createToken(user.id).then(function(token){
Synchronise.Component.run("d886097f-e243-482e-8343-e3b546a14546", {
from : emailTemplate.recoverPassword.from,
to : email,
subject : emailTemplate.recoverPassword.subject,
html : emailTemplate.recoverPassword.body.replace('{{TOKEN}}', token),
api_key : "key-78ce158d4339b8f8a14f2d730444e534",
domain : "synchronise.io"
}, {
success: function(data){
response.success();
},
error: function(err){
response.error(err);
}
});
});
}, function(err){
response.error(err);
});
});
};
exports.unreadNotification = function(request, response){
var unreadNotifications = [];
orm.model(["User", "UserCreditCard"]).then(function(d){
var user = d.User.current(request);
var millisSinceRegister = new Date().getTime()-new Date(user.created_at).getTime();
var millisInADay = 86400000;
var promises = [];
promises.push(new Promise(function(resolve, reject){
// The user is registered for more than a day
if((millisSinceRegister/millisInADay)>1){
d.UserCreditCard.cardsForUser(user).then(function(cards){
if(!cards.length){
unreadNotifications.push({
type : "billing",
label : "noCard",
quantity : 1
});
}
resolve();
}, reject);
}else{
resolve();
}
}));
Promise.all(promises).then(function(){
response.success(unreadNotifications);
}, function(err){
response.error(err);
});
});
};
exports.userObject = function(request, response){
orm.model("User").then(function(User){
userH.getUserObject(request).then(function(user){
if(typeof(user) != "undefined"){
userH.hasRole(user, ["superadmin", "marketplaceValidation", "admin"]).then(function(hasRole){
if(user.id == request.params.user_id || user.email == request.params.user_id || hasRole){
User.userById(request.params.user_id).then(function(userObject){
userObject.emailVerified = undefined;
userObject.encryption_key = undefined;
userObject.password = undefined;
userObject.password_matcher = undefined;
userObject.private_key = undefined;
response.success(userObject);
}, function(error){
response.error(error);
});
}
});
}else{
response.error("Session expired");
}
});
});
};
return new Promise(function(resolve, reject){
ormLoader.model("Query").then(function(Query){
Query.queriesUsingField(id_field).then(function(results){
var tasks = Array();
_.each(Object.keys(results), function(row){
var currentQueryID = row;
var currentQueryData = results[currentQueryID];
_.each(currentQueryData, function(match){
tasks.push(new Promise(function(res, rej){
QueryCorruptedState.create({
id_field : id_field,
id_query : currentQueryID,
id_reason : 1, // Only one reason at the moment so by default we select the first reason
type_task : match.type,
id_task : match.id_task
}, function(err){
if(err){ rej(err); }else{ res(); }
});
}));
});
});
Promise.all(tasks).then(resolve, reject);
});
});
});
files.forEach( function ( file ){
if( utils.regex.is_js_file.test( file )){
var model = file.replace( '.js', '' );
require( path + file );
ctx[ model ] = mongoose.model( model );
}
});
function givenUserModelWithAuth() {
var AccessToken = app.registry.getModel('AccessToken');
app.model(AccessToken, { dataSource: 'db' });
var User = app.registry.getModel('User');
app.model(User, { dataSource: 'db' });
// NOTE(bajtos) This is puzzling to me. The built-in User & AccessToken
// models should come with both relations already set up, i.e. the
// following two lines should not be neccessary.
// And it does behave that way when only tests in this file are run.
// However, when I run the full test suite (all files), the relations
// get broken.
AccessToken.belongsTo(User, { as: 'user', foreignKey: 'userId' });
User.hasMany(AccessToken, { as: 'accessTokens', foreignKey: 'userId' });
return User;
}
it('should report 200 for HEAD /:id found', function(done) {
app.model(MyModel);
app.use(loopback.rest());
MyModel.create({ name: 'm2' }, function(err, inst) {
request(app).head('/mymodels/' + inst.id)
.expect(200)
.end(done);
});
});
"Model with generics": function (test) {
test.expect(1);
// Test
var entity = ast.type.forall(["a"], ast.model("A",[ast.type.variable("a")],[]));
test.deepEqual(types.genericsAndType(entity),
pair(list("a"),entity.type),
"Generics and model");
test.done();
},
d.ProjectShared.addMemberToProject(id_project, searchEmail, permissions).then(function(id_user_new){
orm.model("UserConnection").then(function(UserConnection){
_.each(IDsToPingAtTheEnd, function(id){
UserConnection.addUserConnection(id, id_user_new);
});
});
response.success("", 200, {}, IDsToPingAtTheEnd);
}, function(err){
exports.countReferrals = function(request, response){
orm.model(["User"]).then(function(d){
d.User.countReferrals(d.User.current(request)).then(function(amount){
response.success(amount);
}, function(err){
response.error(err);
});
});
}
exports.removeProject = function(request, response){
orm.model(["User", "Project", "ProjectShared"]).then(function(d){
var user = d.User.current(request);
var projectId = request.params.id_project;
var project;
var canContinue = true;
var projectName = "";
var promises = [];
var IDsToPingAtTheEnd = [];
var id_user = user.id;
new Promise(function(resolve, reject){
d.Project.one({id: projectId}, function(err, projectFound){
if(!err && projectFound.user_id == id_user){
project = projectFound;
// We set that we want to ping the owner of the project at then end
IDsToPingAtTheEnd.push(project.user_id);
resolve(project);
}else{
canContinue = false;
response.error('An error occured while trying to fetch the project, please try again.');
reject('An error occured while trying to fetch the project, please try again.');
}
});
}).then(function(){
if(canContinue){
promises.push(new Promise(function(resolve){
d.ProjectShared.membersForProject(projectId).then(function(members){
var promisesLocal = [];
_.each(members, function(member){
IDsToPingAtTheEnd.push(member.id_user);
promisesLocal.push(new Promise(function(resolveLocal){
member.remove(function(){
resolveLocal();
});
}));
});
Promise.all(promisesLocal).then(resolve);
});
}));
}
}).then(function(){
return Promise.all(promises);
}).then(function(){
if(canContinue){
project.remove(function(err){
if(!err){
response.success("Project " + projectName + " removed", 200, {}, IDsToPingAtTheEnd);
}else{
response.error(err);
}
});
}
});
});
};
'Model with one attribute': function (test) {
test.expect(1);
var aPackages = packages(option.none());
test.deepEqual(objcode.generateObjCode(deBruijn.indexes(compiler.entity(environment(aPackages),
ast.model("A",[],[ast.param("a",ast.type.native("a"))])).success())),
[ [$i.code.MODEL, ['A', [["a", [ [$i.code.ACCESS, 1],$i.code.RETURN]]]]]] );
test.done();
},
before(function defineProductAndCategoryModels() {
var recipe = app.model(
'recipe',
{ properties: { name: 'string' }, dataSource: 'db' }
);
var ingredient = app.model(
'ingredient',
{ properties: { name: 'string' }, dataSource: 'db' }
);
var photo = app.model(
'photo',
{ properties: { name: 'string' }, dataSource: 'db' }
);
recipe.referencesMany(ingredient);
// contrived example for test:
recipe.hasOne(photo, { as: 'picture', options: {
http: { path: 'image' }
} });
});
it('allows models to provide a custom HTTP path', function(done) {
var CustomModel = app.registry.createModel('CustomModel',
{name: String},
{http: {'path': 'domain1/CustomModelPath'}});
app.model(CustomModel, {dataSource: 'db'});
app.use(loopback.rest());
request(app).get('/domain1/CustomModelPath').expect(200).end(done);
});
it('should report 200 for url-encoded HTTP path', function(done) {
var CustomModel = app.registry.createModel('CustomModel',
{name: String},
{http: {path: 'domain%20one/CustomModelPath'}});
app.model(CustomModel, {dataSource: 'db'});
app.use(loopback.rest());
request(app).get('/domain%20one/CustomModelPath').expect(200).end(done);
});
Database.model("Type").find({slug : ''}).exec(function(err, typeDocs){
if(err) return next(err);
/**
* If we do not have any Types check the Taxonomies
*/
if(!typeDocs)
{
Database.model('Taxonomy').find({path : false}, function(err, taxonomies){
if(err) return next(err);
if(docs)
{
console.log("@ Found Taxonomy with path 0");
taxonomies.populate('terms').where({'terms.path' : true}).exec(function(err, taxonomies){
if(err) return next(err);
console.log("@ Got taxonomies where terms.path = 1", taxonomies.length);
Database.model('Entity').find({term : taxonomies.term}, function(err, posts){
if(err) return next(err);
console.log("@ Found a total of (%d) where slug = ");
posts.populate('type').where({'type.slug' : ''}).exec(function(err, posts){
if(err) return next(err);
});
});
});
return;
}
});
return;
}
/**
* Check for posts that match the slug
*/
if(typeDocs)
{
Database.model('Entity').find({slug : slug}, ['_id'], function(err, post){
if(err) return next(err);
post[0] ? displayPost(req, res, next, post[0]._id) : next(404);
})
}
});
before(function defineModels() {
var Book = app.model(
'Book',
{ properties: { name: 'string' }, dataSource: 'db',
plural: 'books' }
);
var Page = app.model(
'Page',
{ properties: { name: 'string' }, dataSource: 'db',
plural: 'pages' }
);
var Image = app.model(
'Image',
{ properties: { name: 'string' }, dataSource: 'db',
plural: 'images' }
);
var Note = app.model(
'Note',
{ properties: { text: 'string' }, dataSource: 'db',
plural: 'notes' }
);
Book.hasMany(Page);
Page.hasMany(Note);
Image.belongsTo(Book);
Book.nestRemoting('pages');
Image.nestRemoting('book');
expect(Book.prototype['__findById__pages__notes']).to.be.a.function;
expect(Image.prototype['__findById__book__pages']).to.be.a.function;
Page.beforeRemote('prototype.__findById__notes', function(ctx, result, next) {
ctx.res.set('x-before', 'before');
next();
});
Page.afterRemote('prototype.__findById__notes', function(ctx, result, next) {
ctx.res.set('x-after', 'after');
next();
});
});