accounts-frontend/packages/app/components/auth/actions.ts

674 lines
19 KiB
TypeScript
Raw Normal View History

import { Action as ReduxAction } from 'redux';
import { browserHistory } from 'app/services/history';
import logger from 'app/services/logger';
import localStorage from 'app/services/localStorage';
import * as loader from 'app/services/loader';
import history from 'app/services/history';
2020-05-24 04:38:24 +05:30
import { updateUser, acceptRules as userAcceptRules } from 'app/components/user/actions';
import { authenticate, logoutAll } from 'app/components/accounts/actions';
import { getActiveAccount } from 'app/components/accounts/reducer';
import {
2020-05-24 04:38:24 +05:30
login as loginEndpoint,
forgotPassword as forgotPasswordEndpoint,
recoverPassword as recoverPasswordEndpoint,
OAuthResponse,
} from 'app/services/api/authentication';
import oauth, { OauthData, Scope } from 'app/services/api/oauth';
import {
2020-05-24 04:38:24 +05:30
register as registerEndpoint,
activate as activateEndpoint,
resendActivation as resendActivationEndpoint,
} from 'app/services/api/signup';
import dispatchBsod from 'app/components/ui/bsod/dispatchBsod';
import { create as createPopup } from 'app/components/ui/popup/actions';
import ContactForm from 'app/components/contact/ContactForm';
import { Account } from 'app/components/accounts/reducer';
import { ThunkAction, Dispatch } from 'app/reducers';
import { Resp } from 'app/services/request';
import { Credentials, Client, OAuthState, getCredentials } from './reducer';
interface ValidationErrorLiteral {
2020-05-24 04:38:24 +05:30
type: string;
payload: Record<string, any>;
}
type ValidationError = string | ValidationErrorLiteral;
/**
* Routes user to the previous page if it is possible
*
* @param {object} options
* @param {string} options.fallbackUrl - an url to route user to if goBack is not possible
*
* @returns {object} - action definition
*/
export function goBack(options: { fallbackUrl?: string }) {
2020-05-24 04:38:24 +05:30
const { fallbackUrl } = options || {};
2020-05-24 04:38:24 +05:30
if (history.canGoBack()) {
browserHistory.goBack();
} else if (fallbackUrl) {
browserHistory.push(fallbackUrl);
}
2020-05-24 04:38:24 +05:30
return {
type: 'noop',
};
}
2019-12-07 16:58:52 +05:30
export function redirect(url: string): () => Promise<void> {
2020-05-24 04:38:24 +05:30
loader.show();
2020-05-24 04:38:24 +05:30
return () =>
new Promise(() => {
// do not resolve promise to make loader visible and
// overcome app rendering
location.href = url;
});
}
2017-10-17 22:16:00 +05:30
const PASSWORD_REQUIRED = 'error.password_required';
const LOGIN_REQUIRED = 'error.login_required';
const ACTIVATION_REQUIRED = 'error.account_not_activated';
const TOTP_REQUIRED = 'error.totp_required';
2017-08-23 00:09:08 +05:30
export function login({
2020-05-24 04:38:24 +05:30
login = '',
password = '',
totp,
rememberMe = false,
2017-08-23 00:09:08 +05:30
}: {
2020-05-24 04:38:24 +05:30
login: string;
password?: string;
totp?: string;
rememberMe?: boolean;
2017-08-23 00:09:08 +05:30
}) {
2020-05-24 04:38:24 +05:30
return wrapInLoader((dispatch) =>
loginEndpoint({ login, password, totp, rememberMe })
.then(authHandler(dispatch))
.catch((resp) => {
if (resp.errors) {
if (resp.errors.password === PASSWORD_REQUIRED) {
return dispatch(setLogin(login));
} else if (resp.errors.login === ACTIVATION_REQUIRED) {
return dispatch(needActivation());
} else if (resp.errors.totp === TOTP_REQUIRED) {
return dispatch(
requestTotp({
login,
password,
rememberMe,
}),
);
} else if (resp.errors.login === LOGIN_REQUIRED && password) {
logger.warn('No login on password panel');
return dispatch(logoutAll());
}
}
return Promise.reject(resp);
})
.catch(validationErrorsHandler(dispatch)),
);
}
2016-08-03 00:29:29 +05:30
export function acceptRules() {
2020-05-24 04:38:24 +05:30
return wrapInLoader((dispatch) => dispatch(userAcceptRules()).catch(validationErrorsHandler(dispatch)));
}
export function forgotPassword({ login = '', captcha = '' }: { login: string; captcha: string }) {
return wrapInLoader((dispatch, getState) =>
forgotPasswordEndpoint(login, captcha)
.then(({ data = {} }) =>
dispatch(
updateUser({
maskedEmail: data.emailMask || getState().user.email,
}),
),
)
.catch(validationErrorsHandler(dispatch)),
);
}
export function recoverPassword({
2020-05-24 04:38:24 +05:30
key = '',
newPassword = '',
newRePassword = '',
2017-08-23 00:09:08 +05:30
}: {
2020-05-24 04:38:24 +05:30
key: string;
newPassword: string;
newRePassword: string;
}) {
2020-05-24 04:38:24 +05:30
return wrapInLoader((dispatch) =>
recoverPasswordEndpoint(key, newPassword, newRePassword)
.then(authHandler(dispatch))
.catch(validationErrorsHandler(dispatch, '/forgot-password')),
);
}
export function register({
2020-05-24 04:38:24 +05:30
email = '',
username = '',
password = '',
rePassword = '',
captcha = '',
rulesAgreement = false,
2017-08-23 00:09:08 +05:30
}: {
2020-05-24 04:38:24 +05:30
email: string;
username: string;
password: string;
rePassword: string;
captcha: string;
rulesAgreement: boolean;
}) {
2020-05-24 04:38:24 +05:30
return wrapInLoader((dispatch, getState) =>
registerEndpoint({
email,
2020-05-24 04:38:24 +05:30
username,
password,
rePassword,
rulesAgreement,
lang: getState().user.lang,
captcha,
})
.then(() => {
dispatch(
updateUser({
username,
email,
}),
);
dispatch(needActivation());
browserHistory.push('/activation');
})
.catch(validationErrorsHandler(dispatch)),
);
}
2020-05-24 04:38:24 +05:30
export function activate({ key = '' }: { key: string }): ThunkAction<Promise<Account>> {
return wrapInLoader((dispatch) =>
activateEndpoint(key)
.then(authHandler(dispatch))
.catch(validationErrorsHandler(dispatch, '/resend-activation')),
);
}
2020-05-24 04:38:24 +05:30
export function resendActivation({ email = '', captcha }: { email: string; captcha: string }) {
return wrapInLoader((dispatch) =>
resendActivationEndpoint(email, captcha)
.then((resp) => {
dispatch(
updateUser({
email,
}),
);
2020-05-24 04:38:24 +05:30
return resp;
})
.catch(validationErrorsHandler(dispatch)),
);
}
export function contactUs() {
2020-05-24 04:38:24 +05:30
return createPopup({ Popup: ContactForm });
}
interface SetCredentialsAction extends ReduxAction {
2020-05-24 04:38:24 +05:30
type: 'auth:setCredentials';
payload: Credentials | null;
}
function setCredentials(payload: Credentials | null): SetCredentialsAction {
2020-05-24 04:38:24 +05:30
return {
type: 'auth:setCredentials',
payload,
};
}
2017-08-23 00:09:08 +05:30
/**
* Sets login in credentials state
* Resets the state, when `null` is passed
*
* @param login
2017-08-23 00:09:08 +05:30
*/
export function setLogin(login: string | null): SetCredentialsAction {
2020-05-24 04:38:24 +05:30
return setCredentials(login ? { login } : null);
2017-08-23 00:09:08 +05:30
}
2019-12-07 16:58:52 +05:30
export function relogin(login: string | null): ThunkAction {
2020-05-24 04:38:24 +05:30
return (dispatch, getState) => {
const credentials = getCredentials(getState());
const returnUrl = credentials.returnUrl || location.pathname + location.search;
2020-05-24 04:38:24 +05:30
dispatch(
setCredentials({
login,
returnUrl,
isRelogin: true,
}),
);
browserHistory.push('/login');
};
}
export type CredentialsAction = SetCredentialsAction;
function requestTotp({
2020-05-24 04:38:24 +05:30
login,
password,
rememberMe,
}: {
2020-05-24 04:38:24 +05:30
login: string;
password: string;
rememberMe: boolean;
2019-12-07 16:58:52 +05:30
}): ThunkAction {
2020-05-24 04:38:24 +05:30
return (dispatch, getState) => {
// merging with current credentials to propogate returnUrl
const credentials = getCredentials(getState());
dispatch(
setCredentials({
...credentials,
login,
password,
rememberMe,
isTotpRequired: true,
}),
);
};
}
interface SetSwitcherAction extends ReduxAction {
2020-05-24 04:38:24 +05:30
type: 'auth:setAccountSwitcher';
payload: boolean;
}
export function setAccountSwitcher(isOn: boolean): SetSwitcherAction {
2020-05-24 04:38:24 +05:30
return {
type: 'auth:setAccountSwitcher',
payload: isOn,
};
2016-11-13 20:17:56 +05:30
}
export type AccountSwitcherAction = SetSwitcherAction;
interface SetErrorAction extends ReduxAction {
2020-05-24 04:38:24 +05:30
type: 'auth:error';
payload: Record<string, ValidationError> | null;
error: boolean;
}
2020-05-24 04:38:24 +05:30
export function setErrors(errors: Record<string, ValidationError> | null): SetErrorAction {
return {
type: 'auth:error',
payload: errors,
error: true,
};
}
export function clearErrors(): SetErrorAction {
2020-05-24 04:38:24 +05:30
return setErrors(null);
}
export type ErrorAction = SetErrorAction;
const KNOWN_SCOPES: ReadonlyArray<string> = [
2020-05-24 04:38:24 +05:30
'minecraft_server_session',
'offline_access',
'account_info',
'account_email',
];
/**
* @param {object} oauthData
* @param {string} oauthData.clientId
* @param {string} oauthData.redirectUrl
* @param {string} oauthData.responseType
* @param {string} oauthData.description
* @param {string} oauthData.scope
* @param {string} [oauthData.prompt='none'] - comma-separated list of values to adjust auth flow
* Posible values:
* * none - default behaviour
* * consent - forcibly prompt user for rules acceptance
* * select_account - force account choosage, even if user has only one
* @param {string} oauthData.loginHint - allows to choose the account, which will be used for auth
* The possible values: account id, email, username
* @param {string} oauthData.state
*
* @returns {Promise}
*/
2018-05-03 10:45:09 +05:30
export function oAuthValidate(oauthData: OauthData) {
2020-05-24 04:38:24 +05:30
// TODO: move to oAuth actions?
// test request: /oauth?client_id=ely&redirect_uri=http%3A%2F%2Fely.by&response_type=code&scope=minecraft_server_session&description=foo
return wrapInLoader((dispatch) =>
oauth
.validate(oauthData)
.then((resp) => {
const { scopes } = resp.session;
const invalidScopes = scopes.filter((scope) => !KNOWN_SCOPES.includes(scope));
let prompt = (oauthData.prompt || 'none').split(',').map((item) => item.trim());
if (prompt.includes('none')) {
prompt = ['none'];
}
if (invalidScopes.length) {
logger.error('Got invalid scopes after oauth validation', {
invalidScopes,
});
}
dispatch(setClient(resp.client));
dispatch(
setOAuthRequest({
...resp.oAuth,
prompt: oauthData.prompt || 'none',
loginHint: oauthData.loginHint,
}),
);
dispatch(setScopes(scopes));
localStorage.setItem(
'oauthData',
JSON.stringify({
// @see services/authFlow/AuthFlow
timestamp: Date.now(),
payload: oauthData,
}),
);
})
.catch(handleOauthParamsValidation),
);
2016-02-27 16:23:58 +05:30
}
2016-08-27 15:49:02 +05:30
/**
* @param {object} params
* @param {bool} params.accept=false
* @param params.accept
* @returns {Promise}
2016-08-27 15:49:02 +05:30
*/
export function oAuthComplete(params: { accept?: boolean } = {}) {
2020-05-24 04:38:24 +05:30
return wrapInLoader(
async (
dispatch,
getState,
): Promise<{
success: boolean;
redirectUri: string;
}> => {
const oauthData = getState().auth.oauth;
if (!oauthData) {
throw new Error('Can not complete oAuth. Oauth data does not exist');
}
2019-12-07 16:58:52 +05:30
2020-05-24 04:38:24 +05:30
try {
const resp = await oauth.complete(oauthData, params);
localStorage.removeItem('oauthData');
if (resp.redirectUri.startsWith('static_page')) {
const displayCode = /static_page_with_code/.test(resp.redirectUri);
const [, code] = resp.redirectUri.match(/code=(.+)&/) || [];
[, resp.redirectUri] = resp.redirectUri.match(/^(.+)\?/) || [];
dispatch(
setOAuthCode({
success: resp.success,
code,
displayCode,
}),
);
}
return resp;
} catch (error) {
const resp:
| {
acceptRequired: boolean;
}
| {
unauthorized: boolean;
} = error;
if ('acceptRequired' in resp) {
dispatch(requirePermissionsAccept());
return Promise.reject(resp);
}
return handleOauthParamsValidation(resp);
}
},
);
2016-02-27 16:23:58 +05:30
}
function handleOauthParamsValidation(
2020-05-24 04:38:24 +05:30
resp: {
[key: string]: any;
userMessage?: string;
} = {},
) {
2020-05-24 04:38:24 +05:30
dispatchBsod();
localStorage.removeItem('oauthData');
2016-08-07 20:20:00 +05:30
2020-05-24 04:38:24 +05:30
// eslint-disable-next-line no-alert
resp.userMessage && setTimeout(() => alert(resp.userMessage), 500); // 500 ms to allow re-render
2020-05-24 04:38:24 +05:30
return Promise.reject(resp);
2016-02-23 11:27:16 +05:30
}
interface SetClientAction extends ReduxAction {
2020-05-24 04:38:24 +05:30
type: 'set_client';
payload: Client;
}
export function setClient(payload: Client): SetClientAction {
2020-05-24 04:38:24 +05:30
return {
type: 'set_client',
payload,
};
}
export type ClientAction = SetClientAction;
interface SetOauthAction extends ReduxAction {
2020-05-24 04:38:24 +05:30
type: 'set_oauth';
payload: Pick<OAuthState, 'clientId' | 'redirectUrl' | 'responseType' | 'scope' | 'prompt' | 'loginHint' | 'state'>;
}
// Input data is coming right from the query string, so the names
// are the same, as used for initializing OAuth2 request
export function setOAuthRequest(data: {
2020-05-24 04:38:24 +05:30
client_id?: string;
redirect_uri?: string;
response_type?: string;
scope?: string;
prompt?: string;
loginHint?: string;
state?: string;
}): SetOauthAction {
2020-05-24 04:38:24 +05:30
return {
type: 'set_oauth',
payload: {
// TODO: there is too much default empty string. Maybe we can somehow validate it
// on the level, where this action is called?
clientId: data.client_id || '',
redirectUrl: data.redirect_uri || '',
responseType: data.response_type || '',
scope: data.scope || '',
prompt: data.prompt || '',
loginHint: data.loginHint || '',
state: data.state || '',
},
};
}
interface SetOAuthResultAction extends ReduxAction {
2020-05-24 04:38:24 +05:30
type: 'set_oauth_result';
payload: Pick<OAuthState, 'success' | 'code' | 'displayCode'>;
}
export const SET_OAUTH_RESULT = 'set_oauth_result'; // TODO: remove
2020-05-24 04:38:24 +05:30
export function setOAuthCode(payload: { success: boolean; code: string; displayCode: boolean }): SetOAuthResultAction {
return {
type: 'set_oauth_result',
payload,
};
2016-02-23 11:27:16 +05:30
}
2016-02-27 16:23:58 +05:30
2019-12-07 16:58:52 +05:30
export function resetOAuth(): ThunkAction {
2020-05-24 04:38:24 +05:30
return (dispatch): void => {
localStorage.removeItem('oauthData');
dispatch(setOAuthRequest({}));
};
2016-11-19 16:24:24 +05:30
}
/**
* Resets all temporary state related to auth
*/
2019-12-07 16:58:52 +05:30
export function resetAuth(): ThunkAction {
2020-05-24 04:38:24 +05:30
return (dispatch, getSate): Promise<void> => {
dispatch(setLogin(null));
dispatch(resetOAuth());
// ensure current account is valid
const activeAccount = getActiveAccount(getSate());
if (activeAccount) {
return Promise.resolve(dispatch(authenticate(activeAccount)))
.then(() => {})
.catch(() => {
// its okay. user will be redirected to an appropriate place
});
}
2020-05-24 04:38:24 +05:30
return Promise.resolve();
};
}
interface RequestPermissionsAcceptAction extends ReduxAction {
2020-05-24 04:38:24 +05:30
type: 'require_permissions_accept';
2016-02-27 16:23:58 +05:30
}
export function requirePermissionsAccept(): RequestPermissionsAcceptAction {
2020-05-24 04:38:24 +05:30
return {
type: 'require_permissions_accept',
};
}
2020-05-24 04:38:24 +05:30
export type OAuthAction = SetOauthAction | SetOAuthResultAction | RequestPermissionsAcceptAction;
interface SetScopesAction extends ReduxAction {
2020-05-24 04:38:24 +05:30
type: 'set_scopes';
payload: Array<Scope>;
}
export function setScopes(payload: Array<Scope>): SetScopesAction {
2020-05-24 04:38:24 +05:30
return {
type: 'set_scopes',
payload,
};
}
export type ScopesAction = SetScopesAction;
interface SetLoadingAction extends ReduxAction {
2020-05-24 04:38:24 +05:30
type: 'set_loading_state';
payload: boolean;
}
export function setLoadingState(isLoading: boolean): SetLoadingAction {
2020-05-24 04:38:24 +05:30
return {
type: 'set_loading_state',
payload: isLoading,
};
}
2019-12-07 16:58:52 +05:30
function wrapInLoader<T>(fn: ThunkAction<Promise<T>>): ThunkAction<Promise<T>> {
2020-05-24 04:38:24 +05:30
return (dispatch, getState) => {
dispatch(setLoadingState(true));
const endLoading = () => dispatch(setLoadingState(false));
2020-05-24 04:38:24 +05:30
return fn(dispatch, getState, undefined).then(
(resp) => {
endLoading();
2020-05-24 04:38:24 +05:30
return resp;
},
(resp) => {
endLoading();
2020-05-24 04:38:24 +05:30
return Promise.reject(resp);
},
);
};
}
export type LoadingAction = SetLoadingAction;
function needActivation() {
2020-05-24 04:38:24 +05:30
return updateUser({
isActive: false,
isGuest: false,
});
}
2019-12-07 16:58:52 +05:30
function authHandler(dispatch: Dispatch) {
2020-05-24 04:38:24 +05:30
return (oAuthResp: OAuthResponse): Promise<Account> =>
dispatch(
authenticate({
token: oAuthResp.access_token,
refreshToken: oAuthResp.refresh_token || null,
}),
).then((resp) => {
dispatch(setLogin(null));
return resp;
});
}
function validationErrorsHandler(
2020-05-24 04:38:24 +05:30
dispatch: Dispatch,
repeatUrl?: string,
): (
2020-05-24 04:38:24 +05:30
resp: Resp<{
errors?: Record<string, string | ValidationError>;
data?: Record<string, any>;
}>,
) => Promise<never> {
2020-05-24 04:38:24 +05:30
return (resp) => {
if (resp.errors) {
const [firstError] = Object.keys(resp.errors);
const firstErrorObj: ValidationError = {
type: resp.errors[firstError] as string,
payload: {
isGuest: true,
repeatUrl: '',
},
};
if (resp.data) {
// TODO: this should be formatted on backend
Object.assign(firstErrorObj.payload, resp.data);
}
2020-05-24 04:38:24 +05:30
if (['error.key_not_exists', 'error.key_expire'].includes(firstErrorObj.type) && repeatUrl) {
// TODO: this should be formatted on backend
firstErrorObj.payload.repeatUrl = repeatUrl;
}
// TODO: can I clone the object or its necessary to catch modified errors list on corresponding catches?
const { errors } = resp;
errors[firstError] = firstErrorObj;
dispatch(setErrors(errors));
}
return Promise.reject(resp);
};
}