5 files changed, 952 insertions, 0 deletions
diff --git a/web/react/stores/channel_store.jsx b/web/react/stores/channel_store.jsx
new file mode 100644
index 000000000..3f259bc7d
--- /dev/null
+++ b/web/react/stores/channel_store.jsx
@@ -0,0 +1,255 @@
+// Copyright (c) 2015 Spinpunch, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+var AppDispatcher = require('../dispatcher/app_dispatcher.jsx');
+var EventEmitter = require('events').EventEmitter;
+var assign = require('object-assign');
+
+var Constants = require('../utils/constants.jsx');
+var ActionTypes = Constants.ActionTypes;
+
+
+var CHANGE_EVENT = 'change';
+var MORE_CHANGE_EVENT = 'change';
+var EXTRA_INFO_EVENT = 'extra_info';
+
+var ChannelStore = assign({}, EventEmitter.prototype, {
+  emitChange: function() {
+    this.emit(CHANGE_EVENT);
+  },
+  addChangeListener: function(callback) {
+    this.on(CHANGE_EVENT, callback);
+  },
+  removeChangeListener: function(callback) {
+    this.removeListener(CHANGE_EVENT, callback);
+  },
+  emitMoreChange: function() {
+    this.emit(MORE_CHANGE_EVENT);
+  },
+  addMoreChangeListener: function(callback) {
+    this.on(MORE_CHANGE_EVENT, callback);
+  },
+  removeMoreChangeListener: function(callback) {
+    this.removeListener(MORE_CHANGE_EVENT, callback);
+  },
+  emitExtraInfoChange: function() {
+    this.emit(EXTRA_INFO_EVENT);
+  },
+  addExtraInfoChangeListener: function(callback) {
+    this.on(EXTRA_INFO_EVENT, callback);
+  },
+  removeExtraInfoChangeListener: function(callback) {
+    this.removeListener(EXTRA_INFO_EVENT, callback);
+  },
+  get: function(id) {
+    var current = null;
+    var c = this._getChannels();
+
+    c.some(function(channel) {
+      if (channel.id == id) {
+        current = channel;
+        return true;
+      }
+      return false;
+    });
+
+    return current;
+  },
+  getMember: function(id) {
+    var current = null;
+    return this.getAllMembers()[id];
+  },
+  getByName: function(name) {
+    var current = null;
+    var c = this._getChannels();
+
+    c.some(function(channel) {
+      if (channel.name == name) {
+        current = channel;
+        return true;
+      }
+
+      return false;
+
+    });
+
+    return current;
+
+  },
+  getAll: function() {
+    return this._getChannels();
+  },
+  getAllMembers: function() {
+    return this._getChannelMembers();
+  },
+  getMoreAll: function() {
+    return this._getMoreChannels();
+  },
+  setCurrentId: function(id) {
+    if (id == null)
+      sessionStorage.removeItem("current_channel_id");
+    else
+      sessionStorage.setItem("current_channel_id", id);
+  },
+  setLastVisitedName: function(name) {
+    if (name == null)
+      localStorage.removeItem("last_visited_name");
+    else
+      localStorage.setItem("last_visited_name", name);
+  },
+  getLastVisitedName: function() {
+    return localStorage.getItem("last_visited_name");
+  },
+  resetCounts: function(id) {
+      var cm = this._getChannelMembers();
+      for (var cmid in cm) {
+          if (cm[cmid].channel_id == id) {
+              var c = this.get(id);
+              if (c) {
+                  cm[cmid].msg_count = this.get(id).total_msg_count;
+                  cm[cmid].mention_count = 0;
+              }
+              break;
+          }
+      }
+      this._storeChannelMembers(cm);
+  },
+  getCurrentId: function() {
+    return sessionStorage.getItem("current_channel_id");
+  },
+  getCurrent: function() {
+    var currentId = ChannelStore.getCurrentId();
+
+    if (currentId != null)
+      return this.get(currentId);
+    else
+      return null;
+  },
+  getCurrentMember: function() {
+    var currentId = ChannelStore.getCurrentId();
+
+    if (currentId != null)
+      return this.getAllMembers()[currentId];
+    else
+      return null;
+  },
+  setChannelMember: function(member) {
+    var members = this._getChannelMembers();
+    members[member.channel_id] = member;
+    this._storeChannelMembers(members);
+    this.emitChange();
+  },
+  getCurrentExtraInfo: function() {
+    var currentId = ChannelStore.getCurrentId();
+    var extra = null;
+
+    if (currentId != null)
+      extra = this._getExtraInfos()[currentId];
+
+    if (extra == null)
+      extra = {members: []};
+
+    return extra;
+  },
+  getExtraInfo: function(channel_id) {
+    var extra = null;
+
+    if (channel_id != null)
+      extra = this._getExtraInfos()[channel_id];
+
+    if (extra == null)
+      extra = {members: []};
+
+    return extra;
+  },
+  _storeChannels: function(channels) {
+    sessionStorage.setItem("channels", JSON.stringify(channels));
+  },
+  _getChannels: function() {
+    var channels = [];
+    try {
+        channels = JSON.parse(sessionStorage.channels);
+    }
+    catch (err) {
+    }
+
+    return channels;
+  },
+  _storeChannelMembers: function(channelMembers) {
+    sessionStorage.setItem("channel_members", JSON.stringify(channelMembers));
+  },
+  _getChannelMembers: function() {
+    var members = {};
+    try {
+        members = JSON.parse(sessionStorage.channel_members);
+    }
+    catch (err) {
+    }
+
+    return members;
+  },
+  _storeMoreChannels: function(channels) {
+    sessionStorage.setItem("more_channels", JSON.stringify(channels));
+  },
+  _getMoreChannels: function() {
+    var channels = [];
+    try {
+        channels = JSON.parse(sessionStorage.more_channels);
+    }
+    catch (err) {
+    }
+
+    return channels;
+  },
+  _storeExtraInfos: function(extraInfos) {
+    sessionStorage.setItem("extra_infos", JSON.stringify(extraInfos));
+  },
+  _getExtraInfos: function() {
+    var members = {};
+    try {
+        members = JSON.parse(sessionStorage.extra_infos);
+    }
+    catch (err) {
+    }
+
+    return members;
+  }
+});
+
+ChannelStore.dispatchToken = AppDispatcher.register(function(payload) {
+  var action = payload.action;
+
+  switch(action.type) {
+
+    case ActionTypes.CLICK_CHANNEL:
+      ChannelStore.setCurrentId(action.id);
+      ChannelStore.setLastVisitedName(action.name);
+      ChannelStore.resetCounts(action.id);
+      ChannelStore.emitChange();
+      break;
+
+    case ActionTypes.RECIEVED_CHANNELS:
+      ChannelStore._storeChannels(action.channels);
+      ChannelStore._storeChannelMembers(action.members);
+      var currentId = ChannelStore.getCurrentId();
+      if (currentId) ChannelStore.resetCounts(currentId);
+      ChannelStore.emitChange();
+      break;
+
+    case ActionTypes.RECIEVED_MORE_CHANNELS:
+      ChannelStore._storeMoreChannels(action.channels);
+      ChannelStore.emitMoreChange();
+      break;
+
+    case ActionTypes.RECIEVED_CHANNEL_EXTRA_INFO:
+      var extra_infos = ChannelStore._getExtraInfos();
+      extra_infos[action.extra_info.id] = action.extra_info;
+      ChannelStore._storeExtraInfos(extra_infos);
+      ChannelStore.emitExtraInfoChange();
+      break;
+
+    default:
+  }
+});
+
+module.exports = ChannelStore;
diff --git a/web/react/stores/error_store.jsx b/web/react/stores/error_store.jsx
new file mode 100644
index 000000000..82170034a
--- /dev/null
+++ b/web/react/stores/error_store.jsx
@@ -0,0 +1,59 @@
+// Copyright (c) 2015 Spinpunch, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+var AppDispatcher = require('../dispatcher/app_dispatcher.jsx');
+var EventEmitter = require('events').EventEmitter;
+var assign = require('object-assign');
+
+var Constants = require('../utils/constants.jsx');
+var ActionTypes = Constants.ActionTypes;
+
+var CHANGE_EVENT = 'change';
+
+var ErrorStore = assign({}, EventEmitter.prototype, {
+
+  emitChange: function() {
+    this.emit(CHANGE_EVENT);
+  },
+
+  addChangeListener: function(callback) {
+    this.on(CHANGE_EVENT, callback);
+  },
+
+  removeChangeListener: function(callback) {
+    this.removeListener(CHANGE_EVENT, callback);
+  },
+  handledError: function() {
+    sessionStorage.removeItem("last_error");
+  },
+  getLastError: function() {
+    var error = null;
+    try {
+        error = JSON.parse(sessionStorage.last_error);
+    }
+    catch (err) {
+    }
+
+    return error;
+  },
+
+  _storeLastError: function(error) {
+    sessionStorage.setItem("last_error", JSON.stringify(error));
+  },
+});
+
+ErrorStore.dispatchToken = AppDispatcher.register(function(payload) {
+  var action = payload.action;
+  switch(action.type) {
+    case ActionTypes.RECIEVED_ERROR:
+      ErrorStore._storeLastError(action.err);
+      ErrorStore.emitChange();
+      break;
+
+    default:
+  }
+});
+
+module.exports = ErrorStore;
+
+
diff --git a/web/react/stores/post_store.jsx b/web/react/stores/post_store.jsx
new file mode 100644
index 000000000..05479f444
--- /dev/null
+++ b/web/react/stores/post_store.jsx
@@ -0,0 +1,224 @@
+// Copyright (c) 2015 Spinpunch, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+var AppDispatcher = require('../dispatcher/app_dispatcher.jsx');
+var EventEmitter = require('events').EventEmitter;
+var assign = require('object-assign');
+
+var ChannelStore = require('../stores/channel_store.jsx');
+var UserStore = require('../stores/user_store.jsx');
+
+var Constants = require('../utils/constants.jsx');
+var ActionTypes = Constants.ActionTypes;
+
+var CHANGE_EVENT = 'change';
+var SEARCH_CHANGE_EVENT = 'search_change';
+var SEARCH_TERM_CHANGE_EVENT = 'search_term_change';
+var SELECTED_POST_CHANGE_EVENT = 'selected_post_change';
+var MENTION_DATA_CHANGE_EVENT = 'mention_data_change';
+var ADD_MENTION_EVENT = 'add_mention';
+
+var PostStore = assign({}, EventEmitter.prototype, {
+
+  emitChange: function() {
+    this.emit(CHANGE_EVENT);
+  },
+
+  addChangeListener: function(callback) {
+    this.on(CHANGE_EVENT, callback);
+  },
+
+  removeChangeListener: function(callback) {
+    this.removeListener(CHANGE_EVENT, callback);
+  },
+
+  emitSearchChange: function() {
+    this.emit(SEARCH_CHANGE_EVENT);
+  },
+
+  addSearchChangeListener: function(callback) {
+    this.on(SEARCH_CHANGE_EVENT, callback);
+  },
+
+  removeSearchChangeListener: function(callback) {
+    this.removeListener(SEARCH_CHANGE_EVENT, callback);
+  },
+
+  emitSearchTermChange: function(doSearch, isMentionSearch) {
+    this.emit(SEARCH_TERM_CHANGE_EVENT, doSearch, isMentionSearch);
+  },
+
+  addSearchTermChangeListener: function(callback) {
+    this.on(SEARCH_TERM_CHANGE_EVENT, callback);
+  },
+
+  removeSearchTermChangeListener: function(callback) {
+    this.removeListener(SEARCH_TERM_CHANGE_EVENT, callback);
+  },
+
+  emitSelectedPostChange: function(from_search) {
+    this.emit(SELECTED_POST_CHANGE_EVENT, from_search);
+  },
+
+  addSelectedPostChangeListener: function(callback) {
+    this.on(SELECTED_POST_CHANGE_EVENT, callback);
+  },
+
+  removeSelectedPostChangeListener: function(callback) {
+    this.removeListener(SELECTED_POST_CHANGE_EVENT, callback);
+  },
+
+  emitMentionDataChange: function(id, mentionText, excludeList) {
+    this.emit(MENTION_DATA_CHANGE_EVENT, id, mentionText, excludeList);
+  },
+
+  addMentionDataChangeListener: function(callback) {
+    this.on(MENTION_DATA_CHANGE_EVENT, callback);
+  },
+
+  removeMentionDataChangeListener: function(callback) {
+    this.removeListener(MENTION_DATA_CHANGE_EVENT, callback);
+  },
+
+  emitAddMention: function(id, username) {
+    this.emit(ADD_MENTION_EVENT, id, username);
+  },
+
+  addAddMentionListener: function(callback) {
+    this.on(ADD_MENTION_EVENT, callback);
+  },
+
+  removeAddMentionListener: function(callback) {
+    this.removeListener(ADD_MENTION_EVENT, callback);
+  },
+
+  getCurrentPosts: function() {
+    var currentId = ChannelStore.getCurrentId();
+
+    if (currentId != null)
+      return this.getPosts(currentId);
+    else
+      return null;
+  },
+  storePosts: function(channelId, posts) {
+    this._storePosts(channelId, posts);
+    this.emitChange();
+  },
+  _storePosts: function(channelId, posts) {
+    sessionStorage.setItem("posts_" + channelId, JSON.stringify(posts));
+  },
+  getPosts: function(channelId) {
+    var posts = null;
+    try {
+        posts = JSON.parse(sessionStorage.getItem("posts_" + channelId));
+    }
+    catch (err) {
+    }
+
+    return posts;
+  },
+  storeSearchResults: function(results, is_mention_search) {
+    sessionStorage.setItem("search_results", JSON.stringify(results));
+    is_mention_search = is_mention_search ? true : false; // force to bool
+    sessionStorage.setItem("is_mention_search", JSON.stringify(is_mention_search));
+  },
+  getSearchResults: function() {
+    var results = null;
+    try {
+        results = JSON.parse(sessionStorage.getItem("search_results"));
+    }
+    catch (err) {
+    }
+
+    return results;
+  },
+  getIsMentionSearch: function() {
+    var result = false;
+    try {
+        result = JSON.parse(sessionStorage.getItem("is_mention_search"));
+    }
+    catch (err) {
+    }
+
+    return result;
+  },
+  storeSelectedPost: function(post_list) {
+    sessionStorage.setItem("select_post", JSON.stringify(post_list));
+  },
+  getSelectedPost: function() {
+    var post_list = null;
+    try {
+        post_list = JSON.parse(sessionStorage.getItem("select_post"));
+    }
+    catch (err) {
+    }
+
+    return post_list;
+  },
+  storeSearchTerm: function(term) {
+    sessionStorage.setItem("search_term", term);
+  },
+  getSearchTerm: function() {
+    return sessionStorage.getItem("search_term");
+  },
+  storeCurrentDraft: function(draft) {
+    var channel_id = ChannelStore.getCurrentId();
+    var user_id = UserStore.getCurrentId();
+    localStorage.setItem("draft_" + channel_id + "_" + user_id, JSON.stringify(draft));
+  },
+  getCurrentDraft: function() {
+    var channel_id = ChannelStore.getCurrentId();
+    var user_id = UserStore.getCurrentId();
+    return JSON.parse(localStorage.getItem("draft_" + channel_id + "_" + user_id));
+  },
+  storeDraft: function(channel_id, user_id, draft) {
+    localStorage.setItem("draft_" + channel_id + "_" + user_id, JSON.stringify(draft));
+  },
+  getDraft: function(channel_id, user_id) {
+    return JSON.parse(localStorage.getItem("draft_" + channel_id + "_" + user_id));
+  },
+  clearDraftUploads: function() {
+    for (key in localStorage) {
+        if (key.substring(0,6) === "draft_") {
+            var d = JSON.parse(localStorage.getItem(key));
+            if (d) {
+                d['uploadsInProgress'] = 0;
+                localStorage.setItem(key, JSON.stringify(d));
+            }
+        }
+    }
+  }
+});
+
+PostStore.dispatchToken = AppDispatcher.register(function(payload) {
+  var action = payload.action;
+
+  switch(action.type) {
+    case ActionTypes.RECIEVED_POSTS:
+      PostStore._storePosts(action.id, action.post_list);
+      PostStore.emitChange();
+      break;
+    case ActionTypes.RECIEVED_SEARCH:
+      PostStore.storeSearchResults(action.results, action.is_mention_search);
+      PostStore.emitSearchChange();
+      break;
+    case ActionTypes.RECIEVED_SEARCH_TERM:
+      PostStore.storeSearchTerm(action.term);
+      PostStore.emitSearchTermChange(action.do_search, action.is_mention_search);
+      break;
+    case ActionTypes.RECIEVED_POST_SELECTED:
+      PostStore.storeSelectedPost(action.post_list);
+      PostStore.emitSelectedPostChange(action.from_search);
+      break;
+    case ActionTypes.RECIEVED_MENTION_DATA:
+      PostStore.emitMentionDataChange(action.id, action.mention_text, action.exclude_list);
+      break;
+    case ActionTypes.RECIEVED_ADD_MENTION:
+      PostStore.emitAddMention(action.id, action.username);
+      break;
+
+    default:
+  }
+});
+
+module.exports = PostStore;
diff --git a/web/react/stores/socket_store.jsx b/web/react/stores/socket_store.jsx
new file mode 100644
index 000000000..8ebb854c9
--- /dev/null
+++ b/web/react/stores/socket_store.jsx
@@ -0,0 +1,86 @@
+// Copyright (c) 2015 Spinpunch, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+var AppDispatcher = require('../dispatcher/app_dispatcher.jsx');
+var UserStore = require('./user_store.jsx')
+var EventEmitter = require('events').EventEmitter;
+var assign = require('object-assign');
+var client = require('../utils/client.jsx');
+
+var Constants = require('../utils/constants.jsx');
+var ActionTypes = Constants.ActionTypes;
+
+var CHANGE_EVENT = 'change';
+
+var conn;
+
+var SocketStore = assign({}, EventEmitter.prototype, {
+  initialize: function(self) {
+    if (!UserStore.getCurrentId()) return;
+
+    if (!self) self = this;
+    self.setMaxListeners(0);
+
+    if (window["WebSocket"] && !conn) {
+      var protocol = window.location.protocol == "https:" ? "wss://" : "ws://";
+      var port = window.location.protocol == "https:" ? ":8443" : "";
+      var conn_url = protocol + location.host + port + "/api/v1/websocket";
+      console.log("connecting to " + conn_url);
+      conn = new WebSocket(conn_url);
+
+      conn.onclose = function(evt) {
+        console.log("websocket closed");
+        console.log(evt);
+        conn = null;
+        setTimeout(function(){self.initialize(self)}, 3000);
+      };
+
+      conn.onerror = function(evt) {
+        console.log("websocket error");
+        console.log(evt);
+      };
+
+      conn.onmessage = function(evt) {
+        AppDispatcher.handleServerAction({
+          type: ActionTypes.RECIEVED_MSG,
+          msg: JSON.parse(evt.data)
+        });
+      };
+    }
+  },
+  emitChange: function(msg) {
+    this.emit(CHANGE_EVENT, msg);
+  },
+  addChangeListener: function(callback) {
+    this.on(CHANGE_EVENT, callback);
+  },
+  removeChangeListener: function(callback) {
+    this.removeListener(CHANGE_EVENT, callback);
+  },
+  sendMessage: function (msg) {
+    if (conn && conn.readyState === WebSocket.OPEN) {
+      conn.send(JSON.stringify(msg));
+    } else if (!conn || conn.readyState === WebSocket.Closed) {
+      conn = null;
+      this.initialize();
+    }
+  }
+});
+
+SocketStore.dispatchToken = AppDispatcher.register(function(payload) {
+  var action = payload.action;
+
+  switch(action.type) {
+    case ActionTypes.RECIEVED_MSG:
+      SocketStore.emitChange(action.msg);
+      break;
+    default:
+  }
+});
+
+SocketStore.initialize();
+module.exports = SocketStore;
+
+
+
+
diff --git a/web/react/stores/user_store.jsx b/web/react/stores/user_store.jsx
new file mode 100644
index 000000000..bbca92c84
--- /dev/null
+++ b/web/react/stores/user_store.jsx
@@ -0,0 +1,328 @@
+// Copyright (c) 2015 Spinpunch, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+var AppDispatcher = require('../dispatcher/app_dispatcher.jsx');
+var EventEmitter = require('events').EventEmitter;
+var assign = require('object-assign');
+var client = require('../utils/client.jsx');
+
+var Constants = require('../utils/constants.jsx');
+var ActionTypes = Constants.ActionTypes;
+
+var CHANGE_EVENT = 'change';
+var CHANGE_EVENT_SESSIONS = 'change_sessions';
+var CHANGE_EVENT_AUDITS = 'change_audits';
+var CHANGE_EVENT_TEAMS = 'change_teams';
+var CHANGE_EVENT_STATUSES = 'change_statuses';
+
+var UserStore = assign({}, EventEmitter.prototype, {
+
+  emitChange: function(userId) {
+    this.emit(CHANGE_EVENT, userId);
+  },
+  addChangeListener: function(callback) {
+    this.on(CHANGE_EVENT, callback);
+  },
+  removeChangeListener: function(callback) {
+    this.removeListener(CHANGE_EVENT, callback);
+  },
+  emitSessionsChange: function() {
+    this.emit(CHANGE_EVENT_SESSIONS);
+  },
+  addSessionsChangeListener: function(callback) {
+    this.on(CHANGE_EVENT_SESSIONS, callback);
+  },
+  removeSessionsChangeListener: function(callback) {
+    this.removeListener(CHANGE_EVENT_SESSIONS, callback);
+  },
+  emitAuditsChange: function() {
+    this.emit(CHANGE_EVENT_AUDITS);
+  },
+  addAuditsChangeListener: function(callback) {
+    this.on(CHANGE_EVENT_AUDITS, callback);
+  },
+  removeAuditsChangeListener: function(callback) {
+    this.removeListener(CHANGE_EVENT_AUDITS, callback);
+  },
+  emitTeamsChange: function() {
+    this.emit(CHANGE_EVENT_TEAMS);
+  },
+  addTeamsChangeListener: function(callback) {
+    this.on(CHANGE_EVENT_TEAMS, callback);
+  },
+  removeTeamsChangeListener: function(callback) {
+    this.removeListener(CHANGE_EVENT_TEAMS, callback);
+  },
+  emitStatusesChange: function() {
+    this.emit(CHANGE_EVENT_STATUSES);
+  },
+  addStatusesChangeListener: function(callback) {
+    this.on(CHANGE_EVENT_STATUSES, callback);
+  },
+  removeStatusesChangeListener: function(callback) {
+    this.removeListener(CHANGE_EVENT_STATUSES, callback);
+  },
+  setCurrentId: function(id) {
+    if (id == null)
+      sessionStorage.removeItem("current_user_id");
+    else
+      sessionStorage.setItem("current_user_id", id);
+  },
+  getCurrentId: function(skipFetch) {
+    var current_id =  sessionStorage.current_user_id;
+
+    // this is a speical case to force fetch the
+    // current user if it's missing
+    // it's synchronous to block rendering
+    if (current_id == null && !skipFetch) {
+      var me = client.getMeSynchronous();
+      if (me != null) {
+        this.setCurrentUser(me);
+        current_id = me.id;
+      }
+    }
+
+    return current_id;
+  },
+  getCurrentUser: function(skipFetch) {
+    if (this.getCurrentId(skipFetch) == null) {
+      return null;
+    }
+
+    return this._getProfiles()[this.getCurrentId()];
+  },
+  setCurrentUser: function(user) {
+    this.saveProfile(user);
+    this.setCurrentId(user.id);
+  },
+  getLastDomain: function() {
+    return localStorage.last_domain;
+  },
+  setLastDomain: function(domain) {
+    localStorage.setItem("last_domain", domain);
+  },
+  getLastEmail: function() {
+    return localStorage.last_email;
+  },
+  setLastEmail: function(email) {
+    localStorage.setItem("last_email", email);
+  },
+  removeCurrentUser: function() {
+    this.setCurrentId(null);
+  },
+  hasProfile: function(userId) {
+    return this._getProfiles()[userId] != null;
+  },
+  getProfile: function(userId) {
+    return this._getProfiles()[userId];
+  },
+  getProfileByUsername: function(username) {
+    return this._getProfilesUsernameMap()[username];
+  },
+  getProfilesUsernameMap: function() {
+    return this._getProfilesUsernameMap();
+  },
+  getProfiles: function() {
+
+    return this._getProfiles();
+  },
+  getActiveOnlyProfiles: function() {
+    active = {};
+    current = this._getProfiles();
+
+    for (var key in current) {
+      if (current[key].delete_at == 0) {
+        active[key] = current[key];
+      }
+    }
+
+    return active;
+  },
+  saveProfile: function(profile) {
+    var ps = this._getProfiles();
+    ps[profile.id] = profile;
+    this._storeProfiles(ps);
+  },
+  _storeProfiles: function(profiles) {
+    sessionStorage.setItem("profiles", JSON.stringify(profiles));
+    var profileUsernameMap = {};
+    for (var id in profiles) {
+        profileUsernameMap[profiles[id].username] = profiles[id];
+    }
+    sessionStorage.setItem("profileUsernameMap", JSON.stringify(profileUsernameMap));
+  },
+  _getProfiles: function() {
+    var profiles = {};
+    try {
+        profiles = JSON.parse(sessionStorage.getItem("profiles"));
+
+        if (profiles == null) {
+            profiles = {};
+        }
+    }
+    catch (err) {
+    }
+
+    return profiles;
+  },
+  _getProfilesUsernameMap: function() {
+    var profileUsernameMap = {};
+    try {
+        profileUsernameMap = JSON.parse(sessionStorage.getItem("profileUsernameMap"));
+
+        if (profileUsernameMap == null) {
+            profileUsernameMap = {};
+        }
+    }
+    catch (err) {
+    }
+
+    return profileUsernameMap;
+  },
+  setSessions: function(sessions) {
+    sessionStorage.setItem("sessions", JSON.stringify(sessions));
+  },
+  getSessions: function() {
+    var sessions = [];
+    try {
+        sessions = JSON.parse(sessionStorage.getItem("sessions"));
+
+        if (sessions == null) {
+            sessions = [];
+        }
+    }
+    catch (err) {
+    }
+
+    return sessions;
+  },
+  setAudits: function(audits) {
+    sessionStorage.setItem("audits", JSON.stringify(audits));
+  },
+  getAudits: function() {
+    var audits = [];
+    try {
+        audits = JSON.parse(sessionStorage.getItem("audits"));
+
+        if (audits == null) {
+            audits = [];
+        }
+    }
+    catch (err) {
+    }
+
+    return audits;
+  },
+  setTeams: function(teams) {
+    sessionStorage.setItem("teams", JSON.stringify(teams));
+  },
+  getTeams: function() {
+    var teams = [];
+    try {
+        teams = JSON.parse(sessionStorage.getItem("teams"));
+
+        if (teams == null) {
+            teams = [];
+        }
+    }
+    catch (err) {
+    }
+
+    return teams;
+  },
+  getCurrentMentionKeys: function() {
+    var user = this.getCurrentUser();
+    if (user.notify_props && user.notify_props.mention_keys) {
+      var keys = user.notify_props.mention_keys.split(',');
+
+      if (user.full_name.length > 0 && user.notify_props.first_name === "true") {
+        var first = user.full_name.split(' ')[0];
+        if (first.length > 0) keys.push(first);
+      }
+
+      return keys;
+    } else {
+      return [];
+    }
+  },
+  getLastVersion: function() {
+    return sessionStorage.last_version;
+  },
+  setLastVersion: function(version) {
+    sessionStorage.setItem("last_version", version);
+  },
+  setStatuses: function(statuses) {
+    this._setStatuses(statuses);
+    this.emitStatusesChange();
+  },
+  _setStatuses: function(statuses) {
+    sessionStorage.setItem("statuses", JSON.stringify(statuses));
+  },
+  setStatus: function(user_id, status) {
+    var statuses = this.getStatuses();
+    statuses[user_id] = status;
+    this._setStatuses(statuses);
+    this.emitStatusesChange();
+  },
+  getStatuses: function() {
+    var statuses = {};
+    try {
+        statuses = JSON.parse(sessionStorage.getItem("statuses"));
+
+        if (statuses == null) {
+            statuses = {};
+        }
+    }
+    catch (err) {
+    }
+
+    return statuses;
+  },
+  getStatus: function(id) {
+    return this.getStatuses()[id];
+  }
+});
+
+UserStore.dispatchToken = AppDispatcher.register(function(payload) {
+  var action = payload.action;
+
+  switch(action.type) {
+    case ActionTypes.RECIEVED_PROFILES:
+      for(var id in action.profiles) {
+        // profiles can have incomplete data, so don't overwrite current user
+        if (id === UserStore.getCurrentId()) continue;
+        var profile = action.profiles[id];
+        UserStore.saveProfile(profile);
+        UserStore.emitChange(profile.id);
+      }
+      break;
+    case ActionTypes.RECIEVED_ME:
+      UserStore.setCurrentUser(action.me);
+      UserStore.emitChange(action.me.id);
+      break;
+    case ActionTypes.RECIEVED_SESSIONS:
+      UserStore.setSessions(action.sessions);
+      UserStore.emitSessionsChange();
+      break;
+    case ActionTypes.RECIEVED_AUDITS:
+      UserStore.setAudits(action.audits);
+      UserStore.emitAuditsChange();
+      break;
+    case ActionTypes.RECIEVED_TEAMS:
+      UserStore.setTeams(action.teams);
+      UserStore.emitTeamsChange();
+      break;
+    case ActionTypes.RECIEVED_STATUSES:
+      UserStore._setStatuses(action.statuses);
+      UserStore.emitStatusesChange();
+      break;
+
+    default:
+  }
+});
+
+UserStore.setMaxListeners(0);
+global.window.UserStore = UserStore;
+module.exports = UserStore;
+
+