Example #1
0
 schema.statics.getByIdChallenges = function (id) {
     var Arena = this.db.model(Model);
     var Challenge = this.db.model('Challenge');
     return Promise.fulfilled().then(function () {
         return Challenge.find({arena:id}).sort('order').exec();
     });
 };
Example #2
0
  handle: function handle(record) {
    var promises = [];

    if (this.filter(record)) {

      var i = this._handlers.length;
      while (i--) {
        if (record.level >= this._handlers[i].level) {
          promises.push(this._handlers[i].handle(record));
        }
      }

      // if this.propagate, tell our parent
      if (this.propagate) {
        var par = getEffectiveParent(this._name);
        if (par) {
          promises.push(par.handle(record));
        }
      }

    }

    if (promises.length > 2) {
      return Promise.all(promises);
    } else if (promises[0]) {
      return promises[0];
    } else {
      return Promise.fulfilled();
    }
  },
Example #3
0
    function createIfNewUser(req, user) {
        if (user) {
            throw {
                http_code: 400,
                message: 'User already exists'
            };
        }
        var role = getRoleByEmail(req.body.email);
        return Promise.fulfilled().then(function() {
            return User.find({}).count({}).exec();
        }).then(function(count) {

            var flags = getFlags({
                user: req.body,
                count: count
            });

            return User.create({
                username: req.body.username,
                email: req.body.email,
                uniId: req.body.uniId,
                lectureGroup: req.body.lectureGroup,
                labGroup: req.body.labGroup,
                password: req.body.password,
                role: role,
                flags: flags,
                activated: false
            });
        });
    }
Example #4
0
    .then(function(dexists) {
      if(!dexists) {
        return fs.mkdirAsync(pth);
      }

      return Promise.fulfilled();
    });
Example #5
0
File: user.js Project: amrdraz/kodr
 app.put('/api/users/:id', access.requireRole(['$self', 'teacher', 'admin']), function(req, res, next) {
     var user = req.body.user;
     Promise.fulfilled().then(function() {
         if (user.password && user.password !== user.passwordConfirmation) {
             throw {
                 http_code: 403,
                 message: "passwords didn't match"
             };
         }
         return User.findOne({
             _id: req.params.id
         }).exec();
     }).then(function(model) {
         if (!model) throw {
             http_code: 404,
             message: "Not Found"
         };
         model.set(user);
         model.save(function(err, model) {
             if (err) return next(err);
             res.json({
                 user: model,
                 access_token: user.passwordConfirmation ? model.token : undefined
             });
         });
     }).catch(function(err) {
         if (err.http_code) {
             return res.send(err.http_code, err.message);
         }
         next(err);
     });
 });
Example #6
0
  log: function log(level, msg /*, messageArs..., [callback] */) {
    level = LEVELS.getLevel(level);
    var args;
    if (arguments.length < 3) {
      args = [msg];
    } else {
      args = SLICE.call(arguments, 1);
    }
    var fn;
    if (typeof args[args.length - 1] === 'function') {
      fn = args.pop();
    }
    // if level >= this.getEffectiveLevel(), tell our handlers
    var promise;
    var record;
    if (this.isEnabledFor(level)) {
      record = this.makeRecord(this._name, level, msg, args);
      promise = this.handle(record);
    } else {
      promise = Promise.fulfilled();
    }


    if (fn) {
      promise = promise.done(fn);
    }

    return promise;
  },
Example #7
0
observer.on('userArena.complete', function(userArena) {
    Promise.fulfilled().then(function() {
        return Requirement.find({
            model1: 'Arena',
            $or: [{
                id1: {
                    $exists: false
                }
            }, {
                id1: userArena.arena
            }],
            complete: false,
            user: userArena.user
        }).exec();
    }).then(function (reqs) {
        return _.map(reqs, function (req) {
            req.completed+=1;
            if(req.completed===req.times) {
                req.complete = true;
            }
            return new Promise(function(resolve, reject) {
                req.save(function(err, model) {
                    if (err) return reject(err);
                    if (model.complete) observer.emit('requirement.complete', req);
                    resolve(model);
                });
            });
        });
    });
});
Example #8
0
 schema.statics.getMembers = function(id) {
     return Promise.fulfilled().then(function() {
         return Member.find({
             group: id
         }).exec();
     });
 };
Example #9
0
 ExpiringToken.getToken(req.body.token).then(function(token) {
     if (token) {
         return Promise.fulfilled().then(function() {
             return User.findOne({
                 _id: token.user
             }).exec();
         }).then(function(user) {
             if (req.body.password !== req.body.passwordConfirmation) {
                 throw {
                     http_code: 400,
                     message: 'Passwords do not match.'
                 };
             }
             user.password = req.body.password;
             user.save(function(err, user) {
                 if (err) throw err;
                 res.render('confirm.html', {
                     user: user,
                 });
                 ExpiringToken.useToken(token.id);
             });
         });
     } else {
         res.render("expiredToken.html");
     }
 }).catch(function(err) {
Example #10
0
 schema.methods.getMembers = function() {
     return Promise.fulfilled().then(function() {
         return Member.find({
             group: this.id
         }).exec();
     });
 };
Example #11
0
 app.get('/api/trials', access.requireRole(), function(req, res, next) {
     var promise;
     if(req.query.ids) {
         req.query._id = {$in:req.query.ids};
         delete req.query.ids;
         promise = Trial.getByQuery(req.query).then(function(model) {
             res.json({
                 trial: model
             });
         });
     } else if(req.query.arena || req.query.userArena) {
         var userId;
         if(req.user.isStudent) {
             userId = req.user.id;
         } else {
             userId = req.query.user || req.user.id;
         }
         promise = Promise.fulfilled().then(function () {
             if(!req.query.arena) {
                 return Arena.getByQuery({users: {$in:[req.query.userArena]}});
             } else {
                 return {id:req.query.arena};
             }            
         }).then(function (arena) {
             var userarena = {};
             if(req.query.userArena) {
                 userarena.id = req.query.userArena;
             } else {
                 var obj = {arena:arena.id, user:userId};
                 userarena = UserArena.getOneByQueryOrCreate(obj, obj);
             }
             return [Challenge.getByQuery({arena:arena.id}), userarena, arena];
         }).spread(function (challenges, ua, arena) {
             challenges = _.filter(challenges, 'isPublished');
             return [
                 challenges,
                 Promise.map(challenges, function (ch) {
                     var obj = {arena:arena.id, userArena:ua.id, challenge:ch.id, user:userId};
                     var update = _.clone(obj);
                     update.order = ch.order;
                     update.group = ch.group;
                     return Trial.getOneByQueryOrCreateOrUpdate(obj, update);
                 })
             ];
         }).spread(function (challenges, trials) {
             res.json({
                 challenge:challenges,
                 trial: _.filter(trials, null)
             });
         });
     } else {
         promise = Trial.getByQuery(req.query).then(function(model) {
             res.json({
                 trial: model
             });
         });
     }
     promise.catch(next);
 });
Example #12
0
 schema.methods.getUserArenaByUserId = function (userId) {
     var arena = this;
     var UserArena = this.db.model('UserArena');
     return Promise.fulfilled().then(function () {
         var obj = {arena:arena.id, user:userId};
         return UserArena.getOneByQueryOrCreate(obj, obj); 
     });
 };
Example #13
0
 schema.methods.getOwners = function() {
     var group = this;
     return Promise.fulfilled().then(function() {
         return Member.find({
             group: group.id,
             role: 'owner'
         }).exec();
     });
 };
Example #14
0
 schema.methods.addMember = function(uid) {
     var group = this;
     return Promise.fulfilled().then(function() {
         return User.findOne({_id:uid}).exec();
     }).then(function(user) {
         if(!user) throw {http_code: 404, message:"user not found"};
         return group.join(user);
     });
 };
Example #15
0
 schema.methods.getUsers = function(id) {
     return Promise.fulfilled().then(function() {
         Member.find({
             group: id
         }).populate('user').exec();
     }).then(function(members) {
         return _.map(members, 'user');
     });
 };
Example #16
0
 schema.statics.getGroups = function(uid) {
     return Promise.fulfilled().then(function() {
         return Member.find({
             user: uid
         }).populate('group').exec();
     }).then(function (memeberships) {
         return _.map(memeberships, 'group');
     });
 };
Example #17
0
File: handler.js Project: btd/rufus
  handle: function(record) {
    if (!this.filter(record)) {
      return Promise.fulfilled();
    }
    if (this.emit.length < 2) {
      throw new Error('Handler.emit requires a callback argument');
    }

    return this._emit(record);
  },
Example #18
0
 schema.methods.addMembers = function(uids) {
     var group = this;
     return Promise.fulfilled().then(function() {
         return User.find({_id:{$in:uids}}).exec();
     }).then(function(users) {
         return Promise.map(users, function (user) {
            return group.join(user);
         });
     });
 };
Example #19
0
 schema.statics.getArenaWithUserArenaByUserId = function (id, userId) {
     var Arena = this.db.model(Model);
     var UserArena = this.db.model('UserArena');
     return Promise.fulfilled().then(function (arena) {
         var obj = {arena:id, user:userId};
         return UserArena.getOneByQueryOrCreate(obj, obj); 
     }).then(function (ua) {
         return [Arena.getById_404(id), ua];
     });
 };
Example #20
0
function addHtml(fullpath, basepath) {
    if (fastfs.isPage(fullpath, basepath)) {
        return parse(fullpath, basepath).then(function(content) {
            var target = fastfs.targetPath(fullpath, basepath);
            return fs.writeFileAsync(target, content);
        });
    }

    // Dummy promise
    return Promise.fulfilled();
}
Example #21
0
 schema.statics.findOrCreateByName = function(name) {
     var Group = this.db.model('Group');
     return Promise.fulfilled().then(function() {
         return Group.findOne({
             name: name
         }).exec();
     }).then(function (group) {
         if (group) {return group;}
         return Group.create({name:name});
     });
 };
Example #22
0
File: user.js Project: amrdraz/kodr
 app.get('/profile', access.requireRole(), function(req, res) {
     Promise.fulfilled().then(function() {
         return [UserQuest.find({
             user: req.user.id
         }).exec()];
     }).spread(function(uqs) {
         res.send({
             user: req.user,
             userQuests: uqs
         });
     });
 });
Example #23
0
 beforeEach(function(done) {
     student = {
         username: 'student',
         email: 'student@place.com',
         password: 'student123',
         role: 'student',
         activated: true
     };
     student2 = {
         username: 'student2',
         email: 'student2@place.com',
         password: 'student123',
         role: 'student',
         activated: true
     };
     teacher = {
         username: 'teacher',
         email: 'teach@place.com',
         password: 'teacher123',
         role: 'teacher',
         activated: true
     };
     Promise.fulfilled().then(function() {
         return [
             User.create(teacher),
             User.create(student),
             User.create(student2)
         ];
     }).spread(function(t, st, st2) {
         student = st;
         student2 = st2;
         var at = Achievement.create({
             name:"start of a journey",
             description: "you got 10 exp points",
             requirements: [{property:'exp', condition:'>=', activation:10}],
             author: teacher.id
         });
         return [at];
     }).spread(function(g) {
         achievement = g;
         expect(achievement).to.exist;
         // console.log(achievement);
         return [User.findOne({
             _id: teacher.id
         }).exec(), User.findOne({
             _id: student.id
         }).exec()];
     }).spread(function(t, st) {
         student = st;
         teacher = t;
     }).finally(done);
 });
Example #24
0
 app.post('/signup', function(req, res, next) {
     Promise.fulfilled()
         .then(validateRequestBody(req))
         .then(processFields)
         .then(findUser)
         .spread(createIfNewUser)
         .then(emitAndRespond(res))
         .catch(function(err) {
             if (err.http_code) {
                 return res.send(err.http_code, err.message);
             }
             res.send(500, err.message);
         });
 });
Example #25
0
 schema.statics.getSubscribersFor = function(gid) {
     var Group = this.db.model('Group');
     if(_.isArray(gid)) {
         return Promise.fulfilled().then(function () {
            return Member.find({
                 group: {$in:gid},
                 role: 'subscriber'
             }).exec(); 
         });
     } else {
         return Group.getById_404(gid).then(function(group) {
             return group.getSubscribers();
         });
     }
 };
Example #26
0
 schema.methods.getIfMember = function(options) {
     var uid;
     if (_.isString(options)) {
         uid = options;
     } else {
         uid = options.isUser ? options.id : options.user.id;
     }
     var group = this;
     return Promise.fulfilled().then(function() {
         return Member.findOne({
             group: group.id,
             user: uid,
         }).exec();
     });
 };
Example #27
0
    schema.statics.KCreate = function(challenge) {
        var Challenge = this.db.model('Challenge');
        var promise = Promise.fulfilled();

        if (!challenge.order && challenge.arena) {
            promise = promise.then(function() {
                return Arena.getById(challenge.arena).then(function(arena) {
                    challenge.order = arena.challenges.length + 1;
                });
            });
        }

        return promise.then(function() {
            return Challenge.create(challenge);
        });
    };
Example #28
0
        beforeEach(function(done) {
            Promise.fulfilled().then(function() {
                var at = UserArena.create({});
                var ch = Challenge.create({});
                var ch2 = Challenge.create({});
                var usr = User.create({
                    username: 'testuser',
                    password: 'testuser12'
                });
                return [at, ch, ch2, usr];
            }).spread(function(at, ch, ch2, usr) {
                challenge = ch;
                userArena = at;
                user = usr;
                var arr = Array(num);
                var chs = Promise.each(arr, function() {
                    return Trial.create({
                        challenge: ch._id,
                        userArena: at._id,
                        user: usr
                    });
                });
                var chs2 = Promise.each(arr, function() {
                    return Trial.create({
                        challenge: ch2._id,
                        userArena: at._id,
                        user: usr

                    });
                });

                return [chs, chs2];
            }).spread(function(chs, chs2) {
                trials = chs.concat(chs2);
                return [
                    UserArena.findOne({
                        _id: userArena._id
                    }).exec(),
                    Challenge.findOne({
                        _id: challenge._id
                    }).exec()
                ];
            }).spread(function(at, ch) {
                userArena = at;
                challenge = ch;
            }).finally(done);
        });
Example #29
0
/**
 * Purges entries in database for EC2 instances not seen for a week
 */
function purgeDbEntries(){

    var weekAgo = new Date();
    //Date.now(); // create an variable with the date a week ago
    weekAgo.setDate(weekAgo.getDate() - 0);

    var queryParams = {
      TableName: tableName,
      IndexName: "timestamp",
      KeyConditionExpression: "#vid = :hkey AND #ls < :rkey",
      ExpressionAttributeNames:{
          "#vid": "vpc-id",
          "#ls": "last_seen"
      },
      ExpressionAttributeValues: {
        ":hkey": vpcId,
        ":rkey": weekAgo.getTime()
      }
    };

    var docClient = new AWS.DynamoDB.DocumentClient();

    docClient.query(queryParams).promise()
    .then(function(results){

        for (let i = 0; i < results.Items.length; i++){
            let deleteParams = {
                TableName: tableName,
                Key: {
                    'ec2-id': results.Items[i]['ec2-id']
                }
            }
            docClient.delete(deleteParams);
        }

    })
    .catch(
        function(error){
            console.log('Error purging old entries from database.\n'+error);
        }
    );

    return Promise.fulfilled(); // return promise to top level

}
Example #30
0
File: user.js Project: amrdraz/kodr
    app.post('/api/users/forgotpass', function(req, res, next) {
        var user;
        var token;
        Promise.fulfilled().then(function() {
            return User.findByIdentity(req.body.identification);
        }).then(function(usr) {
            if (!usr) {
                throw {
                    http_code: 403,
                    message: "Identity does not exist"
                };
            }
            user = usr;
            return ExpiringToken.toForgotPassword(usr);

        }).then(function(eToken) {
            token = eToken;
            var confirmURL = req.headers.host + '/forgotpass/' + eToken._id;
            // template in views/mail
            return mail.renderAndSend('forgotpass.html', {
                confirmURL: confirmURL
            }, {
                to: user.email,
                subject: 'Forgot Password Request',
                stub: process.env.NODE_ENV === 'test',
            });
        }).then(function(info) {
            if (process.env.NODE_ENV === 'test') {
                return res.send({
                    token: token._id,
                    info: info
                });
            } else {
                res.send({
                    message: "Email was sent to reset your password"
                });
            }
        }).catch(function(err) {
            console.log(err.stack);
            if (err.http_code) {
                return res.send(err.http_code, err.message);
            }
            res.send(500, err.message);
        });
    });