Some old ways of implementing flux architecture

BaseStore.js

import {EventEmitter} from 'events';
import AppDispatcher from '../dispatcher/AppDispatcher';

export default class BaseStore extends EventEmitter {
  constructor() {
    super();
  }
  subscribe(actionSubscribe) {
    this._dispatchToken = AppDispatcher.register(actionSubscribe());
  }
  get dispatchToken() {
    return this._dispatchToken;
  }
  emitChange() {
    this.emit('CHANGE');
  }
  addChangeListener(callback) {
    this.on('CHANGE', callback);
  }
  removeChangeListener(callback) {
    this.removeListener('CHANGE', callback);
  }
}

UserStore.js

import AppDispatcher from '../dispatcher/AppDispatcher';

class UserStore extends BaseStore {
  constructor() {
    super();
    this._users = {};
    this.subscribe(() => this._registerActions.bind(this));
    this._currentUser = {};
  }

  update(id, updates) {
    this._users[id] = assign({}, this._users[id], updates);
  }

  updateCurrentUser(user) {
    user = (typeof user === 'object') ? JSON.stringify(user) : user;
    $.cookie(CVar.this.currentUser, user || {});
    this.update(user.id, user);
  }

  getAllUsers() {
    return this._users;
  }

  getUser(id) {
    return this._users[id];
  }

  getCurrentUser() {
    return AuthStore.getCurrentUser();
  }

  getFullName(user) {
    return (user.first_name || '') + (user.last_name || '');
  }

  _registerActions(action) {
    switch (action.actionType) {
      case ZhishiConstants.RECEIVE_USER:
        if (AppDispatcher.isDispatching()) {
          AppDispatcher.waitFor([AuthStore.dispatchToken]);
        }
        if (action.data) {
          this.update(action.data.id, action.data);
          this.emitChange();
        }
        break;
      default:
          // Nothing for now
    }
  }
}
export default new UserStore();