From cf7a05f80f68b5b1c8bcc0089679dd497cec2506 Mon Sep 17 00:00:00 2001 From: =Corey Hulen Date: Sun, 14 Jun 2015 23:53:32 -0800 Subject: first commit --- web/react/stores/channel_store.jsx | 255 ++++++++++++++++++++++++++++ web/react/stores/error_store.jsx | 59 +++++++ web/react/stores/post_store.jsx | 224 +++++++++++++++++++++++++ web/react/stores/socket_store.jsx | 86 ++++++++++ web/react/stores/user_store.jsx | 328 +++++++++++++++++++++++++++++++++++++ 5 files changed, 952 insertions(+) create mode 100644 web/react/stores/channel_store.jsx create mode 100644 web/react/stores/error_store.jsx create mode 100644 web/react/stores/post_store.jsx create mode 100644 web/react/stores/socket_store.jsx create mode 100644 web/react/stores/user_store.jsx (limited to 'web/react/stores') 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; + + -- cgit v1.2.3-1-g7c22