1 files changed, 272 insertions, 0 deletions

diff --git a/src/stores/UserStore.js b/src/stores/UserStore.js
new file mode 100644
index 000000000..4927d615f
--- /dev/null
+++ b/src/stores/UserStore.js
@@ -0,0 +1,272 @@
+import { observable, computed, action } from 'mobx';
+import moment from 'moment';
+import jwt from 'jsonwebtoken';
+
+import Store from './lib/Store';
+import Request from './lib/Request';
+import CachedRequest from './lib/CachedRequest';
+import { gaEvent } from '../lib/analytics';
+
+// TODO: split stores into UserStore and AuthStore
+export default class UserStore extends Store {
+  BASE_ROUTE = '/auth';
+  WELCOME_ROUTE = `${this.BASE_ROUTE}/welcome`;
+  LOGIN_ROUTE = `${this.BASE_ROUTE}/login`;
+  LOGOUT_ROUTE = `${this.BASE_ROUTE}/logout`;
+  SIGNUP_ROUTE = `${this.BASE_ROUTE}/signup`;
+  PRICING_ROUTE = `${this.BASE_ROUTE}/signup/pricing`;
+  IMPORT_ROUTE = `${this.BASE_ROUTE}/signup/import`;
+  INVITE_ROUTE = `${this.BASE_ROUTE}/signup/invite`;
+  PASSWORD_ROUTE = `${this.BASE_ROUTE}/password`;
+
+  @observable loginRequest = new Request(this.api.user, 'login');
+  @observable signupRequest = new Request(this.api.user, 'signup');
+  @observable passwordRequest = new Request(this.api.user, 'password');
+  @observable inviteRequest = new Request(this.api.user, 'invite');
+  @observable getUserInfoRequest = new CachedRequest(this.api.user, 'getInfo');
+  @observable updateUserInfoRequest = new Request(this.api.user, 'updateInfo');
+  @observable getLegacyServicesRequest = new CachedRequest(this.api.user, 'getLegacyServices');
+
+  @observable isImportLegacyServicesExecuting = false;
+  @observable isImportLegacyServicesCompleted = false;
+
+  @observable id;
+  @observable authToken = localStorage.getItem('authToken') || null;
+  @observable accountType;
+
+  @observable hasCompletedSignup = null;
+
+  @observable userData = {};
+
+  @observable actionStatus = [];
+
+  logoutReasonTypes = {
+    SERVER: 'SERVER',
+  };
+  @observable logoutReason = null;
+
+  constructor(...args) {
+    super(...args);
+
+    // Register action handlers
+    this.actions.user.login.listen(this._login.bind(this));
+    this.actions.user.retrievePassword.listen(this._retrievePassword.bind(this));
+    this.actions.user.logout.listen(this._logout.bind(this));
+    this.actions.user.signup.listen(this._signup.bind(this));
+    this.actions.user.invite.listen(this._invite.bind(this));
+    this.actions.user.update.listen(this._update.bind(this));
+    this.actions.user.resetStatus.listen(this._resetStatus.bind(this));
+    this.actions.user.importLegacyServices.listen(this._importLegacyServices.bind(this));
+
+    // Reactions
+    this.registerReactions([
+      this._requireAuthenticatedUser,
+      this._getUserData.bind(this),
+    ]);
+  }
+
+  // Routes
+  get loginRoute() {
+    return this.LOGIN_ROUTE;
+  }
+
+  get logoutRoute() {
+    return this.LOGOUT_ROUTE;
+  }
+
+  get signupRoute() {
+    return this.SIGNUP_ROUTE;
+  }
+
+  get pricingRoute() {
+    return this.PRICING_ROUTE;
+  }
+
+  get inviteRoute() {
+    return this.INVITE_ROUTE;
+  }
+
+  get importRoute() {
+    return this.IMPORT_ROUTE;
+  }
+
+  get passwordRoute() {
+    return this.PASSWORD_ROUTE;
+  }
+
+  // Data
+  @computed get isLoggedIn() {
+    return this.authToken !== null && this.authToken !== undefined;
+  }
+
+  // @computed get isTokenValid() {
+  //   return this.authToken !== null && moment(this.tokenExpiry).isAfter(moment());
+  // }
+
+  @computed get isTokenExpired() {
+    if (!this.authToken) return false;
+
+    const { tokenExpiry } = this._parseToken(this.authToken);
+    return this.authToken !== null && moment(tokenExpiry).isBefore(moment());
+  }
+
+  @computed get data() {
+    this.getUserInfoRequest.execute();
+    return this.getUserInfoRequest.result || {};
+  }
+
+  @computed get legacyServices() {
+    this.getLegacyServicesRequest.execute();
+    return this.getLegacyServicesRequest.result || [];
+  }
+
+  // Actions
+  @action async _login({ email, password }) {
+    const authToken = await this.loginRequest.execute(email, password)._promise;
+    this._setUserData(authToken);
+
+    this.stores.router.push('/');
+
+    gaEvent('User', 'login');
+  }
+
+  @action async _signup({ firstname, lastname, email, password, accountType, company }) {
+    const authToken = await this.signupRequest.execute({
+      firstname,
+      lastname,
+      email,
+      password,
+      accountType,
+      company,
+    });
+
+    this.hasCompletedSignup = false;
+
+    this._setUserData(authToken);
+
+    this.stores.router.push(this.PRICING_ROUTE);
+
+    gaEvent('User', 'signup');
+  }
+
+  @action async _retrievePassword({ email }) {
+    const request = this.passwordRequest.execute(email);
+
+    await request._promise;
+    this.actionStatus = request.result.status || [];
+
+    gaEvent('User', 'retrievePassword');
+  }
+
+  @action _invite({ invites }) {
+    const data = invites.filter(invite => invite.email !== '');
+
+    this.inviteRequest.execute(data);
+
+    // we do not wait for a server response before redirecting the user
+    this.stores.router.push('/');
+
+    gaEvent('User', 'inviteUsers');
+  }
+
+  @action async _update({ userData }) {
+    const response = await this.updateUserInfoRequest.execute(userData)._promise;
+
+    this.getUserInfoRequest.patch(() => response.data);
+    this.actionStatus = response.status || [];
+
+    gaEvent('User', 'update');
+  }
+
+  @action _resetStatus() {
+    this.actionStatus = [];
+  }
+
+  @action _logout() {
+    localStorage.removeItem('authToken');
+    this.getUserInfoRequest.invalidate().reset();
+    this.authToken = null;
+    // this.data = {};
+  }
+
+  @action async _importLegacyServices({ services }) {
+    this.isImportLegacyServicesExecuting = true;
+
+    for (const service of services) {
+      this.actions.service.createFromLegacyService({
+        data: service,
+      });
+      await this.stores.services.createServiceRequest._promise; // eslint-disable-line
+    }
+
+    this.isImportLegacyServicesExecuting = false;
+    this.isImportLegacyServicesCompleted = true;
+  }
+
+  // This is a mobx autorun which forces the user to login if not authenticated
+  _requireAuthenticatedUser = () => {
+    if (this.isTokenExpired) {
+      this._logout();
+    }
+
+    const { router } = this.stores;
+    const currentRoute = router.location.pathname;
+    if (!this.isLoggedIn
+      && !currentRoute.includes(this.BASE_ROUTE)) {
+      router.push(this.WELCOME_ROUTE);
+    } else if (this.isLoggedIn
+      && currentRoute === this.LOGOUT_ROUTE) {
+      this.actions.user.logout();
+      router.push(this.LOGIN_ROUTE);
+    } else if (this.isLoggedIn
+      && currentRoute.includes(this.BASE_ROUTE)
+      && (this.hasCompletedSignup
+        || this.hasCompletedSignup === null)) {
+      this.stores.router.push('/');
+    }
+  };
+
+  // Reactions
+  async _getUserData() {
+    if (this.isLoggedIn) {
+      const data = await this.getUserInfoRequest.execute()._promise;
+
+      // We need to set the beta flag for the SettingsStore
+      this.actions.settings.update({
+        settings: {
+          beta: data.beta,
+        },
+      });
+    }
+  }
+
+  // Helpers
+  _parseToken(authToken) {
+    try {
+      const decoded = jwt.decode(authToken);
+
+      return ({
+        id: decoded.userId,
+        tokenExpiry: moment.unix(decoded.exp).toISOString(),
+        authToken,
+      });
+    } catch (err) {
+      console.error('AccessToken Invalid');
+
+      return false;
+    }
+  }
+
+  _setUserData(authToken) {
+    const data = this._parseToken(authToken);
+    if (data.authToken) {
+      localStorage.setItem('authToken', data.authToken);
+
+      this.authToken = data.authToken;
+      this.id = data.id;
+    } else {
+      this.authToken = null;
+      this.id = null;
+    }
+  }
+}