login.ts

login.ts

import Auth0Lock from 'auth0-lock'
import { Observable } from 'rxjs'
import { push } from 'react-router-redux'

import { error as logError } from '../../util/logger'

import {
  types as userTypes,
  actions as userActions
} from '../actions/user'
const {
  loginSuccess,
  loginFail,
  setUser,
  getProfileFail
} = userActions

import {
  types as dialogTypes,
  actions as dialogActions
} from '../actions/dialogs'

let lock
const getLock = () => {
  if (lock) {
    return lock
  } else {
    lock = new Auth0Lock(
      'xxx',
      'xxx.au.auth0.com',
      {
        auth: {
          responseType: 'token',
          params: {
            scope: 'openid email user_metadata app_metadata picture'
          }
        }
      }
    )
  }
}

export const showLogin = (auth, showOpts?: {}): Promise<any> => new Promise((resolve, reject) => {
  auth.on('authenticated', result => {
    resolve(result)
  })

  auth.on('unrecoverable_error', error => {
    reject(error)
  })

  auth.on('authorization_error', error => {
    reject(error)
  })

  auth.show(showOpts)
})

export const getProfile = (auth, token): Promise<any> => new Promise((res, rej) =>
  auth.getUserInfo(token, (error, result) => {
    if (error) {
      return rej(error)
    } else {
      return res(result)
    }
  })
)

export function loginEpic(action$, store): Observable<any> {
  const dispatch = store.dispatch

  // start with an empty stream that merges child streams
  return Observable.empty().merge(

    // handle user attempting to login
    action$.ofType(dialogTypes.showLogin)
      .mergeMap(action => {
        return Observable
          .fromPromise(showLogin(getLock(), action.payload))
          .map(loginSuccess)
          .catch(error => {
            logError(error)
            dispatch(loginFail(error))
            return Observable.empty()
          })
      }),

    // handle successful login
    action$.ofType(userTypes.loginSuccess)
      .mergeMap(action => {
        return Observable
          .fromPromise(getProfile(getLock(), action.payload.accessToken))
          .catch(error => {
            dispatch(getProfileFail(error))
            return Observable.empty()
          })
          .map(payload => {
            dispatch(setUser(payload))
            getLock().hide()
          })
          .mapTo(push('/sessions'))
      }),

    // handle failed login
    action$.ofType(userTypes.loginFail)
      .map(action => {
        // set lock to undefined so a new instance will be created when
        // calling showLogin with the errors
        lock = undefined
        return dialogActions.showLogin({
          rememberLastLogin: false,
          flashMessage: {
            type: 'error',
            text: action.payload.error_description
          }
        })
      })
  )
}

export default loginEpic