stitch-ui/src/auth/reducers.js

import { combineReducers } from "redux";
import { is, Map, fromJS } from "immutable";
import { createReducer } from "redux-act";
import * as actions from "./actions";
import { makeUserReducer } from "../users/users";
import { makeAPIKeyReducer } from "./apikeys";
import { AllowedRequestOriginsEdit } from "./models/AllowedRequestOrigins";
import {
  randomAlphaNumericString,
  EDIT_TYPE_LOCAL,
  EDIT_TYPE_REMOTE,
  EDIT_TYPE_STATUS
} from "../util";

export default combineReducers({
  apiKeys: makeAPIKeyReducer(actions.apiKeyActions),
  auth: createReducer(
    {
      [actions.loadProvidersActions.req]: state => ({
        ...state,
        loadingProviders: true
      }),
      [actions.loadProvidersActions.rcv]: (state, { payload }) => ({
        ...state,
        providers: payload,
        prevProvidersInput: fromJS(payload).merge(state.providersInput),
        providersInput: fromJS(payload).merge(state.providersInput),
        loadingProviders: false
      }),
      [actions.loadProvidersActions.fail]: (state, payload) => ({
        ...state,
        error: payload.error,
        loadingProviders: false
      }),

      [actions.disableProviderActions.req]: state => ({
        ...state,
        togglingProvider: true
      }),
      [actions.disableProviderActions.rcv]: (state, payload) => ({
        ...state,
        providersInput: state.providersInput.remove(
          [payload.reqArgs[2], payload.reqArgs[3]].join("/")
        ),
        togglingProvider: false
      }),
      [actions.disableProviderActions.fail]: (state, payload) => ({
        ...state,
        togglingProvider: false,
        error: payload.error
      }),
      [actions.openProvider]: (state, { provider }) => {
        let newProviders = state.providersInput
          .set(provider, fromJS({}))
          .setIn([provider, "dirty"], true);
        if (provider === "custom/token") {
          newProviders = newProviders.setIn(
            [provider, "signingKey"],
            randomAlphaNumericString(64)
          );
        }
        return { ...state, providersInput: newProviders };
      },
      [actions.enableProviderActions.req]: state => ({
        ...state,
        togglingProvider: true
      }),
      [actions.enableProviderActions.rcv]: (state, payload) => {
        const provider = [payload.reqArgs[2], payload.reqArgs[3]].join("/");
        return {
          ...state,
          providersInput: state.providersInput
            .setIn([provider, "error"], null)
            .setIn([provider, "dirty"], false),
          prevProvidersInput: state.providersInput
            .setIn([provider, "error"], null)
            .setIn([provider, "dirty"], false),
          togglingProvider: false
        };
      },
      [actions.enableProviderActions.fail]: (state, payload) => {
        const provider = [payload.reqArgs[2], payload.reqArgs[3]].join("/");
        return {
          ...state,
          providersInput: state.providersInput
            .setIn([provider, "error"], payload.error)
            .setIn([provider, "dirty"], true),
          togglingProvider: false
        };
      },
      [actions.discardProviderUpdates]: state => ({
        ...state,
        providersInput: state.prevProvidersInput,
        togglingProvider: false
      }),
      [actions.setProviderClientIdInput]: (state, { provider, input }) => ({
        ...state,
        providersInput: state.providersInput
          .setIn([provider, "clientId"], input)
          .setIn([provider, "dirty"], true)
      }),
      [actions.setProviderClientSecretInput]: (state, { provider, input }) => ({
        ...state,
        providersInput: state.providersInput
          .setIn([provider, "clientSecret"], input)
          .setIn([provider, "dirty"], true)
      }),
      [actions.setRedirectURIInput]: (state, { provider, index, input }) => ({
        ...state,
        providersInput: state.providersInput
          .setIn([provider, "redirectURIs", index], input)
          .setIn([provider, "dirty"], true)
      }),
      [actions.removeRedirectURI]: (state, { provider, index }) => ({
        ...state,
        providersInput: state.providersInput.updateIn(
          [provider, "redirectURIs"],
          r => r.remove(index)
        )
      }),
      [actions.addRedirectURI]: (state, { provider }) => ({
        ...state,
        providersInput: state.providersInput
          .updateIn([provider, "redirectURIs"], r => (r || fromJS([])).push(""))
          .setIn([provider, "dirty"], true)
      }),
      [actions.addDomainRestriction]: (state, { provider }) => ({
        ...state,
        providersInput: state.providersInput
          .updateIn([provider, "domainRestrictions"], r =>
            (r || fromJS([])).push("")
          )
          .updateIn([provider, "metadataFields"], f =>
            (f || fromJS([])).toSet().add("email").toList()
          )
          .setIn([provider, "dirty"], true)
      }),
      [actions.removeDomainRestriction]: (state, { provider, index }) => ({
        ...state,
        providersInput: state.providersInput
          .updateIn([provider, "domainRestrictions"], r => r.remove(index))
          .setIn([provider, "dirty"], true)
      }),
      [actions.setDomainRestrictionInput]: (
        state,
        { provider, index, input }
      ) => ({
        ...state,
        providersInput: state.providersInput
          .setIn([provider, "domainRestrictions", index], input)
          .setIn([provider, "dirty"], true)
      }),
      [actions.setMetadataField]: (state, { provider, field, enabled }) => ({
        ...state,
        providersInput: state.providersInput
          .updateIn(
            [provider, "metadataFields"],
            f =>
              enabled
                ? (f || fromJS([])).toSet().add(field).toList()
                : (f || fromJS([])).toSet().remove(field).toList()
          )
          .setIn([provider, "dirty"], true)
      }),
      [actions.setSigningKey]: (state, { provider, input }) => ({
        ...state,
        providersInput: state.providersInput
          .setIn([provider, "signingKey"], input)
          .setIn([provider, "dirty"], true)
      }),
      [actions.setResetPasswordURL]: (state, { provider, input }) => ({
        ...state,
        providersInput: state.providersInput
          .setIn([provider, "resetPasswordUrl"], input)
          .setIn([provider, "dirty"], true)
      }),
      [actions.setEmailConfirmationURL]: (state, { provider, input }) => ({
        ...state,
        providersInput: state.providersInput
          .setIn([provider, "emailConfirmationUrl"], input)
          .setIn([provider, "dirty"], true)
      }),
      [actions.setEmailConfirmationSubject]: (state, { provider, input }) => ({
        ...state,
        providersInput: state.providersInput
          .setIn([provider, "emailConfirmationSubject"], input)
          .setIn([provider, "dirty"], true)
      }),
      [actions.setResetPasswordSubject]: (state, { provider, input }) => ({
        ...state,
        providersInput: state.providersInput
          .setIn([provider, "resetPasswordSubject"], input)
          .setIn([provider, "dirty"], true)
      })
    },
    {
      togglingProvider: false,
      error: null,
      providers: {},
      providersInput: new Map(),
      prevProvidersInput: new Map()
    }
  ),
  users: makeUserReducer(
    actions.loadUsersActions,
    actions.resetUsersAction,
    actions.addUserAction
  ),
  security: createReducer(
    {
      [actions.addAllowedRequestOrigin]: state => ({
        ...state,
        allowedRequestOrigins: state.allowedRequestOrigins
          .set(EDIT_TYPE_LOCAL, state.allowedRequestOrigins.local.push(""))
          .setIn([EDIT_TYPE_STATUS, "dirty"], true)
      }),
      [actions.removeAllowedRequestOrigin]: (state, { index }) => {
        const newState = state.allowedRequestOrigins.set(
          EDIT_TYPE_LOCAL,
          state.allowedRequestOrigins.local.remove(index)
        );
        let isDirty = true;
        if (is(newState.local, newState.remote)) {
          isDirty = false;
        }
        return {
          ...state,
          allowedRequestOrigins: state.allowedRequestOrigins
            .set(
              EDIT_TYPE_LOCAL,
              state.allowedRequestOrigins.local.remove(index)
            )
            .setIn([EDIT_TYPE_STATUS, "dirty"], isDirty)
        };
      },
      [actions.setAllowedRequestOriginInput]: (state, { index, input }) => ({
        ...state,
        allowedRequestOrigins: state.allowedRequestOrigins
          .set(
            EDIT_TYPE_LOCAL,
            state.allowedRequestOrigins.local.set(index, input)
          )
          .setIn([EDIT_TYPE_STATUS, "dirty"], true)
      }),
      [actions.cancelEditingAllowedRequestOrigins]: state => ({
        ...state,
        allowedRequestOrigins: state.allowedRequestOrigins
          .set(EDIT_TYPE_LOCAL, state.allowedRequestOrigins.remote)
          .setIn([EDIT_TYPE_STATUS, "dirty"], false)
      }),
      [actions.loadAllowedRequestOriginsActions.req]: state => ({
        ...state
      }),
      [actions.loadAllowedRequestOriginsActions.rcv]: (state, { payload }) => {
        const newRemote = fromJS(payload);
        return {
          ...state,
          allowedRequestOrigins: state.allowedRequestOrigins
            .set(EDIT_TYPE_REMOTE, newRemote)
            .set(
              EDIT_TYPE_LOCAL,
              state.allowedRequestOrigins.local.merge(newRemote)
            )
            .deleteIn([EDIT_TYPE_STATUS, "loadError"])
        };
      },
      [actions.loadAllowedRequestOriginsActions.fail]: (state, payload) => ({
        ...state,
        allowedRequestOrigins: state.allowedRequestOrigins.setIn(
          [EDIT_TYPE_STATUS, "loadError"],
          payload.error
        )
      }),
      [actions.saveAllowedRequestOriginsActions.req]: state => ({
        ...state
      }),
      [actions.saveAllowedRequestOriginsActions.rcv]: state => ({
        ...state,
        allowedRequestOrigins: state.allowedRequestOrigins
          .set(EDIT_TYPE_REMOTE, state.allowedRequestOrigins.local)
          .deleteIn([EDIT_TYPE_STATUS, "saveError"])
          .deleteIn([EDIT_TYPE_STATUS, "dirty"])
      }),
      [actions.saveAllowedRequestOriginsActions.fail]: (state, payload) => ({
        ...state,
        allowedRequestOrigins: state.allowedRequestOrigins.setIn(
          [EDIT_TYPE_STATUS, "saveError"],
          payload.error
        )
      })
    },
    {
      allowedRequestOrigins: new AllowedRequestOriginsEdit()
    }
  )
});