stitch-ui/src/auth/actions.js

import { createAction } from "redux-act";
import { makeAsyncActions, asyncActionExecutor } from "../util";
import { makeKeyActions } from "./apikeys";
import {
  makeLoadUsersActions,
  makeResetUsersAction,
  makeAddUserAction
} from "../users/users";

export const NAME = "auth/";

export const apiKeyActions = makeKeyActions(NAME);

export const loadProvidersActions = makeAsyncActions(`${NAME}load providers`);
export const enableProviderActions = makeAsyncActions(`${NAME}enable provider`);
export const disableProviderActions = makeAsyncActions(
  `${NAME}disable provider`
);

export const discardProviderUpdates = createAction(
  `${NAME}discard proivder updates`
);

export const loadUsersActions = makeLoadUsersActions(NAME);
export const resetUsersAction = makeResetUsersAction(NAME);
export const addUserAction = makeAddUserAction(NAME);

export const revokeSessionsActions = makeAsyncActions(
  `${NAME}revoke user sessions`
);

export const addUser = asyncActionExecutor(
  addUserAction,
  (client, groupId, appId, user) => () =>
    client.apps(groupId).app(appId).users().create(user),
  true
);

export const loadUsers = asyncActionExecutor(
  loadUsersActions,
  (client, groupId, appId, filter) => () =>
    client.apps(groupId).app(appId).users().list(filter)
);

export const revokeSessions = asyncActionExecutor(
  revokeSessionsActions,
  (client, groupId, appId, userId) =>
    client.apps(groupId).app(appId).users().user(userId).logout
);

export const loadProviders = asyncActionExecutor(
  loadProvidersActions,
  (client, groupId, appId) => () =>
    client.apps(groupId).app(appId).authProviders().list()
);

export const enableProvider = asyncActionExecutor(
  enableProviderActions,
  (client, groupId, appId, providerType, providerName, data) => () =>
    client
      .apps(groupId)
      .app(appId)
      .authProviders()
      .provider(providerType, providerName)
      .update(data),
  true
);

export const disableProvider = asyncActionExecutor(
  disableProviderActions,
  (client, groupId, appId, providerType, providerName) => () =>
    client
      .apps(groupId)
      .app(appId)
      .authProviders()
      .provider(providerType, providerName)
      .remove()
      .catch(e => {
        // Swallow the error if we tried to disable a provider
        // that was already disabled.
        if (e.code !== "AuthProviderNotFound") {
          throw e;
        }
      }),
  true
);

export const openProvider = createAction(`${NAME}open provider`);
export const closeProvider = createAction(`${NAME}close provider`);

export const setSigningKey = createAction(`${NAME}set signing key`);

export const setProviderClientIdInput = createAction(`${NAME}set client id`);
export const setProviderClientSecretInput = createAction(
  `${NAME}set client secret`
);
export const setRedirectURIInput = createAction(`${NAME}set redirect ui`);
export const addRedirectURI = createAction(`${NAME}set redirect ui`);
export const removeRedirectURI = createAction(`${NAME}remove redirect ui`);
export const removeDomainRestriction = createAction(
  `${NAME}remove domain restriction`
);
export const addDomainRestriction = createAction(
  `${NAME}add domain restriction`
);
export const setDomainRestrictionInput = createAction(
  `${NAME}set domain restriction input`
);
export const setMetadataField = createAction(`${NAME}set metadata field`);

export const setResetPasswordURL = createAction(
  `${NAME}set password reset url`
);
export const setEmailConfirmationURL = createAction(
  `${NAME}set email confirmation url`
);

export const setResetPasswordSubject = createAction(
  `${NAME}set password reset subject`
);
export const setEmailConfirmationSubject = createAction(
  `${NAME}set email confirmation subject`
);
export const removeAllowedRequestOrigin = createAction(
  `${NAME}remove allowed request origin`
);
export const cancelEditingAllowedRequestOrigins = createAction(
  `${NAME}cancel editing allowed request origins`
);
export const addAllowedRequestOrigin = createAction(
  `${NAME}add allowed request origin`
);
export const setAllowedRequestOriginInput = createAction(
  `${NAME}set allowed request origin input`
);
export const loadAllowedRequestOriginsActions = makeAsyncActions(
  `${NAME}load allowed request origins`
);
export const saveAllowedRequestOriginsActions = makeAsyncActions(
  `${NAME}save allowed request origins`
);
export const loadAllowedRequestOrigins = asyncActionExecutor(
  loadAllowedRequestOriginsActions,
  (client, groupId, appId) => () =>
    client.apps(groupId).app(appId).security().allowedRequestOrigins().get()
);
export const saveAllowedRequestOrigins = asyncActionExecutor(
  saveAllowedRequestOriginsActions,
  (client, groupId, appId, newOrigins) => () =>
    client
      .apps(groupId)
      .app(appId)
      .security()
      .allowedRequestOrigins()
      .update(newOrigins.toJS()),
  true
);