Этот коммит содержится в:
=Corey Hulen
2015-06-14 23:53:32 -08:00
Коммит cf7a05f80f
665 изменённых файлов: 129987 добавлений и 0 удалений

255
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;

59
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;

224
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;

86
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;

328
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;