timers3000/app/controller/timerscontroller.js

Provides a graphical interface in your browser to create and manage incremental timers for your daily tasks.

var pantexdb             = require('pantexdb')
    , sessionscontroller = require('./sessionscontroller.js')
    , utils              = require('../../lib/timerUtils.js');

var db = new pantexdb(process.env.TIMERDB, 'timers3000db', ["timers"], false).open();

/**
 * Create a new timer
 * Timerstructure:
 *     {name : Stirng,
 *     group: ID,
 *     active: boolean
 *     lastTimeStarted: Date
 *     time: Integer}
 * @param  {String}   name The timer's name
 * @param  {Function} done Function to call when the timer was created
 */
exports.create = function(data, done){
    var timer = { "name": data.name,
                  "group": data.group,
                  "active": false,
                  "lastTimeStarted": Date.now(),
                  "time": 0 }

    db.timers.save(timer, function(err, obj){
        if(err) console.warn(err);
        return done(timer._id);
    });
}

/**
 * Delete a timer
 * @param  {String}   id   The timer's id
 * @param  {Function} done Function to call when the timer was deleted
 */
exports.delete = function(id, done){
    db.timers.delete({_id:id}, function(err,num){
        if(err) console.warn(err);
        return done();
    });
}

exports.addTime = function(id, _time, done){
    db.timers.findOne({"_id":id},function(err,timer){
        db.timers.update(id,{time: (timer.time + _time)},function(err, timer){
            if(err || !timer){
              console.log(err)
              return done(err,null);  
            } 
            return done(null, err);  
        });
    });
}

/**
 * Delete all timers that belong to the specified group
 * @param  {String}   group_id The group's id
 * @param  {Function} done     Function to call when the timers are deleted
 */
exports.deleteByGroup = function(group_id, done){    
    db.timers.delete({group: group_id}, function(err, num){
        if(err) console.log(err);
        done();
    });
}

/**
 * Start a timer:
 * Update a timer's active and lastTimeStarted field.
 * If the timer is already active, don't update the fields - the sessions has not
 * ended yet.
 * @param  {String}   id   The timer's id
 * @param  {Function} done Function to call when the timer was started
 */
exports.startTimer = function(id,done){
    db.timers.findOne({"_id":id},function(err,timer){
        //Timer is already active, don't set new startdate
        if(timer.active){
            var diff = (Date.now() - timer.lastTimeStarted);
            var secs = Math.floor(diff / 1000);
            done(timer.time, secs);
        }else{
            db.timers.update(id, {lastTimeStarted: Date.now(), active: true}, function(err, timer){
                if(err || !timer){
                    console.log(err);
                    done(-999);
                }else{
                    done(timer.time);  
                }
            });
        }
    
    });
}


/**
 * Stop a timer:
 * Update the time and active field of a timer
 * @param  {String}   id   The timer's id
 * @param  {Function} done Function to call when the timer was stopped
 */
exports.stopTimer = function(id, done){
    db.timers.findOne({_id: id}, function(err, timer){
        if(err || !timer){
            console.log(err)
            return done();
        }
        //Calculate session time and save a session
        var secs = Math.floor((Date.now() - timer.lastTimeStarted) / 1000);
        sessionscontroller.create(id,secs,timer.lastTimeStarted,function(){});
        //Update the timer
        db.timers.update(id, {time: timer.time + secs, active: false}, 
                         function(err, timer){
            if(err || !timer) console.log(err);
            done();
        });
    });
}

/**
 * Change a timer's group
 * @param  {String}   id        The timers's id
 * @param  {String}   new_group the new group's id
 * @param  {Function} done Function to call when the group field was updated
 */
exports.changeGroup = function(id, new_group, done){
    db.timers.update(id, {group: new_group}, function(err, obj){
        if(err) console.warn(err);
        return done();
    });
}

/**
 * Change a timer's name
 * @param  {String}   id       the timer's id
 * @param  {String}   new_name the new name for the timer
 * @param  {Function} done Function to call when the name field was updated
 */
exports.renameTimer = function(id, new_name, done){
    db.timers.update(id, {name: new_name}, function(err, obj){
        if(err) console.warn(err);
        return done();
    });
}

/**
 * Finds the timerobject to the specified id
 * @param  {String}   id   The timers id
 * @param  {Function} done the callback function
 */
exports.getTimer = function(id, done){
    db.timers.findOne({"_id":id},function(err, timer){
        if(err || !timer){
            return done(err,null);
        }else{
            return done(null,timer);
        }
    });
}

/**
 * Get all timers in the collection and update their time-field (not in db)
 * if they are marked as active.
 * @param  {Function} done Function to call when all timers are grabbed
 */
exports.getTimers = function(done){
    db.timers.find({}, function(err, timers){
        if(err){
            console.warn(err);
        }else{
            for (var i = 0; i < timers.length; i++){
                if(timers[i].active){
                    var diff = (Date.now() - timers[i].lastTimeStarted);
                    var secs = Math.floor(diff / 1000);
                    timers[i].time += secs;
                }
            }
        }
         switch(process.env.TIMERSORTINGKEY){
            case "ID"   : done(timers);break;
            case "TIME" : done(timers.sort(utils.predicatBy('time', -1)));break;
            case "NAME" : done(timers.sort(utils.predicatBy('name', 1)));break;
            case "LTS"  : done(timers.sort(utils.predicatBy('lastTimeStarted', -1)));break;
          }
        return;
    });
}