Syncs board after a period of inactivity

app/controllers/api/api_controller.rb

@@ -1,5 +1,13 @@
 module Api
   class ApiController < ApplicationController
     skip_before_action :check_account
+
+    def logged_in
+      if logged_in?
+        return render json: {success: true}
+      else
+        return render json: {success: false, status: 403}
+      end
+    end
   end
 end

app/controllers/api/issues_controller.rb

@@ -6,6 +6,11 @@ def issue
       render json: api.issue(params[:number])
     end
 
+    def issues
+      api = huboard.board(params[:user], params[:repo])
+      render json: api.issues(params[:label], params[:options])
+    end
+
     def details
       api = huboard.board(params[:user], params[:repo])
       render json: api.issue(params[:number]).activities

config/routes.rb

@@ -39,6 +39,7 @@
 
 
   namespace :api do
+    get 'logged_in' => 'api#logged_in'
     get 'uploads/asset' => 'uploads#asset_uploader'
     #Webhooks
     post '/site/webhook/issue' => 'webhooks#legacy'
@@ -72,6 +73,7 @@
 
         #Issues
         get 'issues/:number' => 'issues#issue'
+        get 'issues' => 'issues#issues'
         get 'issues/:number/details' => 'issues#details'
         get 'issues/:number/status' => 'issues#status'
         post 'issues' => 'issues#open_issue'

ember-app/app/controllers/application.js

@@ -24,6 +24,25 @@ var ApplicationController = Ember.Controller.extend(
 
   //Fix the need to delay event subscriptions
   subscribeDisabled: true,
+
+  //Browser Session Checker
+  boardSyncing: Ember.inject.service(),
+  checkBrowserSession: function(){
+    var lastFocus = this.get('browser-session.lastFocus');
+    var _self = this;
+    if(lastFocus >= _self.browserCheckInterval){
+      var since = new Date(new Date().getTime() - _self.browserCheckInterval);
+      this.validateCredentials().success((response)=>{
+        _self.get('boardSyncing').syncIssues(_self.get('model.board'), {since: since.toISOString()});
+      }).fail((error)=>{
+
+      });
+    }
+  }.observes('browser-session.lastFocus').on('init'),
+  validateCredentials: function(){
+    return Ember.$.getJSON('/api/logged_in');
+  },
+  browserCheckInterval: 3600000//One Hour
 });
 
 export default ApplicationController;

ember-app/app/initializers/browser-session.js

@@ -0,0 +1,14 @@
+import BrowserSession from 'app/services/browser-session';
+
+export function initialize(container, application){
+  application.register('browser-session:main', BrowserSession);
+  application.inject('controller', 'browser-session', 'browser-session:main');
+  application.inject('component', 'browser-session', 'browser-session:main');
+}
+
+export default {
+  name: 'browser-session',
+  after: 'advanceReadiness',
+  initialize: initialize
+}
+

ember-app/app/models/new/board.js

@@ -112,7 +112,16 @@ var Board = Model.extend({
         return issue.data.assignee && issue.data.assignee.login === assignee.login;
       });
     });
-  }).property("assignees.[]", "issues.@each.assignee")
+  }).property("assignees.[]", "issues.@each.assignee"),
+  fetchIssues: function(options){
+    var promises = this.get('repos').map((repo)=>{
+      return repo.fetchIssues(options);
+    });
+
+    return Ember.RSVP.all(promises).then((issues)=>{
+      return _.flatten(issues);
+    });
+  }
 });
 
 Board.reopenClass({

ember-app/app/models/new/repo.js

@@ -222,7 +222,11 @@ var Repo = Model.extend({
   },
   assigneesLength: function(){
     return this.get("assignees.length");
-  }.property("assignees.[]")
+  }.property("assignees.[]"),
+  fetchIssues: function(options){
+    var url = `/api/${this.get('data.repo.full_name')}/issues`
+    return Ember.$.getJSON(url,{ options: options });
+  }
 });
 
 export default Repo;

ember-app/app/services/board-syncing.js

@@ -0,0 +1,64 @@
+import Ember from 'ember';
+
+var BoardSyncingService = Ember.Service.extend({
+
+  //Sync Notifier
+  flashMessages: Ember.inject.service(),
+  syncFlashNotifier: function(){
+    if(this.get('syncInProgress')){
+      this.get('flashMessages').add(this.messageData());
+    } else {
+      var message = this.messageData().message;
+      var flash = this.get('flashMessages.queue').find((flash)=>{
+        return flash.message === message;
+      });
+      Ember.set(flash.progress, 'status', false);
+    }
+  }.observes('syncInProgress'),
+  messageData: function(){
+    return {
+      message: 'syncing your board, please wait...',
+      sticky: true,
+      type: 'info',
+      progress: {
+        status: true,
+        callback: function(){
+          this.set('message', 'sync complete!');
+          this.get('flash')._setTimer('timer', 'destroyMessage', 3000);
+        }
+      }
+    };
+  },
+
+  //Issue Syncing
+  syncIssues: function(board, opts){
+    if(this.get('syncInProgress')){ return; }
+    var _self = this;
+    _self.set('syncInProgress', true);
+
+    board.fetchIssues(opts).then((issues)=>{
+      _self.issueSuccess(board, issues);
+      _self.set('syncInProgress', false);
+    }, (error)=>{
+      _self.issueFail();
+      _self.set('syncInProgress', false);
+    });
+  },
+  issueSuccess: function(board, issues){
+    if(!issues.length){ return; }
+    Ember.run.once(()=>{
+      board.get('issues').forEach((issue)=>{
+        issues.forEach((i)=>{
+          if(i.id === issue.get('id')){
+            Ember.set(issue, 'data', i);
+          };
+        });
+      });
+    });
+  },
+  issueFail: function(error){
+
+  }
+});
+
+export default BoardSyncingService;

ember-app/app/services/browser-session.js

@@ -0,0 +1,31 @@
+import Ember from 'ember';
+
+var BrowserSessionService = Ember.Service.extend(Ember.Evented, {
+  initEventObservers: function(){
+    var _self = this;
+    Ember.$(window).on('focus blur', (e)=>{
+      _self[`${e.type}Handlers`].forEach((h) => _self[h]());
+    });
+  }.on('init'),
+  setLastFocus: function(){
+    var before = this.get('lastBlur');
+    var now = new Date().getTime();
+    this.set('lastFocus', (now - before));
+  }.on('didFocusBrowser'),
+
+  //Focus Handlers
+  focusHandlers: ['sendFocusEvent'],
+  sendFocusEvent: function(){
+    this.trigger('didFocusBrowser');
+  },
+
+  //Blur Handlers
+  blurHandlers: ['updateLastBlur'],
+  lastBlur: new Date().getTime(),
+  updateLastBlur: function(){
+    var time = new Date().getTime();
+    this.set('lastBlur', time);
+  }
+});
+
+export default BrowserSessionService;

ember-app/app/templates/components/flash/hb-message.hbs

@@ -1,9 +1,12 @@
-{{#if flash.sticky}}
-  <i class='ui-icon ui-icon-x-thin'></i>
+{{#if progress}}
+  {{hb-spinner}}
 {{/if}}
 
+{{#unless progress}}
+  {{#if flash.sticky}}
+    <i class='ui-icon ui-icon-x-thin'></i>
+  {{/if}}
+{{/unless}}
+
 <div class='message-copy'>{{truncate message 50}}</div>
 
-{{#if progress}}
-  {{hb-spinner}}
-{{/if}}

ember-app/tests/unit/services/board-syncing-test.js

@@ -0,0 +1,64 @@
+import Ember from 'ember';
+import {
+  moduleFor,
+  test
+} from 'ember-qunit';
+
+var sut;
+var fakeServer;
+var fakeResponse;
+moduleFor('service:board-syncing', {
+  setup: function(){
+    sut = this.subject();
+  }
+});
+
+test('syncs the boards issues successfuly', (assert)=>{
+  var issues = ['issue1', 'issue2'];
+  var success = $.ajax().then(()=>{return issues});
+  var board = { fetchIssues: sinon.stub().returns(success) };
+  sut.syncFlashNotifier = sinon.stub();
+  sut.issueSuccess = sinon.stub();
+
+  var done = assert.async();
+  sut.syncIssues(board, {});
+  setTimeout(()=>{
+    assert.ok(board.fetchIssues.calledWith({}));
+    assert.ok(sut.issueSuccess.calledWith(board, issues));
+    assert.ok(sut.get('syncInProgress') === false);
+    done();
+  }, 10);
+});
+
+test('fails gracefully on syncing the boards issues', (assert)=>{
+  var fail = $.ajax('fail');
+  var board = { fetchIssues: sinon.stub().returns(fail) };
+  sut.syncFlashNotifier = sinon.stub();
+  sut.issueFail = sinon.stub();
+
+  var done = assert.async();
+  sut.syncIssues(board, {});
+  setTimeout(()=>{
+    assert.ok(board.fetchIssues.calledWith({}));
+    assert.ok(sut.issueFail.called);
+    assert.ok(sut.get('syncInProgress') === false);
+    done();
+  }, 10);
+});
+
+test('sends a flash notifier on sync', (assert)=> {
+  var flash = { add: sinon.stub() };
+  sut.messageData = sinon.stub();
+  sut.set('flashMessages', flash);
+  sut.set('syncInProgress', true);
+
+  assert.ok(sut.get('flashMessages').add.calledWith(sut.messageData()));
+});
+
+test('clears flash when sync is finished', (assert)=> {
+  var flash = { queue: [sut.messageData()] };
+  sut.set('flashMessages', flash);
+  sut.set('syncInProgress', false);
+
+  assert.ok(flash.queue[0].progress.status === false);
+});

ember-app/tests/unit/services/browser-session-test.js

@@ -0,0 +1,65 @@
+import Ember from 'ember';
+import {
+  moduleFor,
+  test
+} from 'ember-qunit';
+
+var sut;
+moduleFor('service:browser-session', {
+  setup: function(){
+    sut = this.subject();
+    sut.focusHandlers = ['focusHandler1', 'focusHandler2'];
+    sut.get('focusHandlers').forEach((handler) => {
+      sut[handler] = sinon.stub();
+    });
+
+    sut.blurHandlers = ['blurHandler1', 'blurHandler2'];
+    sut.get('blurHandlers').forEach((handler) => {
+      sut[handler] = sinon.stub();
+    });
+  }
+});
+
+test('Runs Blur Handlers on window.blur', (assert)=>{
+  $(window).trigger('blur');
+
+  assert.ok(sut.blurHandler1.called);
+  assert.ok(sut.blurHandler2.called);
+});
+
+test('sets last focus interval', (assert)=>{
+  var done = assert.async();
+  var interval;
+  var interval2;
+
+  sut.trigger('didFocusBrowser');
+  interval = sut.get('lastFocus');
+
+  setTimeout(()=>{
+    sut.trigger('didFocusBrowser');
+    interval2 = sut.get('lastFocus');
+    assert.ok(interval < interval2);
+    done();
+  }, 10);
+});
+
+//Focus Handlers
+test('Send ember observable didFocusBrowser event', (assert)=>{
+  sinon.stub(sut, 'trigger');
+
+  sut.sendFocusEvent();
+  assert.ok(sut.trigger.calledWith('didFocusBrowser'));
+});
+
+//Blur Handlers
+test('Set lastBlur with time of last blur', (assert)=>{
+  var done = assert.async();
+  var current = sut.get('lastBlur');
+
+  setTimeout(()=>{
+    sut.updateLastBlur();
+    var updated = sut.get('lastBlur');
+    assert.ok((updated - current) >= 100);
+    done();
+  }, 100);
+});

lib/bridge/github/issues.rb

@@ -10,8 +10,8 @@ def overridable(&blk)
 
 class Huboard
   module Issues
-    def issues(label = nil)
-      params = {direction: "asc"}
+    def issues(label = nil, opts={})
+      params = {direction: "asc"}.merge(opts)
       params = params.merge(labels: label) if label
 
       gh.issues(params).all.each{