turniere
/
turniere-frontend
mirror of https://github.com/turniere/turniere-frontend.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Formatting: satisfy Hound

This commit is contained in:
Felix Hamme 2019-05-08 13:59:11 +02:00
parent 6b4e0c36a5
commit f4cf04ad25
1 changed files with 187 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

374
js/api.js
View File

@ -150,215 +150,215 @@ function checkForAuthenticationHeaders(response) {
const reducer_userinfo = (state = defaultstate_userinfo, action) => { const reducer_userinfo = (state = defaultstate_userinfo, action) => {
switch(action.type) { switch(action.type) {
case actiontypes_userinfo.REGISTER: case actiontypes_userinfo.REGISTER:
postRequest(action.state, '/users', { postRequest(action.state, '/users', {
'username' : action.parameters.username, 'username' : action.parameters.username,
'email' : action.parameters.email, 'email' : action.parameters.email,
'password' : action.parameters.password 'password' : action.parameters.password
}).then((resp) => { }).then((resp) => {
__store.dispatch({
type : actiontypes_userinfo.REGISTER_RESULT_SUCCESS
});
storeOptionalToken(resp);
}).catch((error) => {
if (error.response) {
__store.dispatch({ __store.dispatch({
type : actiontypes_userinfo.REGISTER_RESULT_SUCCESS 'type' : actiontypes_userinfo.REGISTER_RESULT_ERROR,
}); 'parameters' : {
storeOptionalToken(resp); 'errorMessages' : error.response.data.errors.full_messages
}).catch((error) => {
if (error.response) {
__store.dispatch({
'type' : actiontypes_userinfo.REGISTER_RESULT_ERROR,
'parameters' : {
'errorMessages' : error.response.data.errors.full_messages
}
});
storeOptionalToken(error.response);
} else {
__store.dispatch({
'type' : actiontypes_userinfo.REGISTER_RESULT_ERROR,
'parameters' : {
'errorMessages' : [
errorMessages['registration_errorunknown']['en']
]
}
});
}
});
return Object.assign({}, state, {});
case actiontypes_userinfo.REGISTER_RESULT_SUCCESS:
return Object.assign({}, state, {
error : false,
errorMessages : []
});
case actiontypes_userinfo.REGISTER_RESULT_ERROR:
return Object.assign({}, state, {
error : true,
errorMessages : action.parameters.errorMessages
});
case actiontypes_userinfo.LOGIN:
postRequest(action.state, '/users/sign_in', {
email : action.parameters.email,
password : action.parameters.password
}).then((resp) => {
__store.dispatch({
type : actiontypes_userinfo.LOGIN_RESULT_SUCCESS,
parameters : {
username : resp.data.username,
successCallback: action.parameters.successCallback
} }
}); });
storeOptionalToken(resp); storeOptionalToken(error.response);
}).catch((error) => { } else {
if(error.response) { __store.dispatch({
__store.dispatch({ 'type' : actiontypes_userinfo.REGISTER_RESULT_ERROR,
'type' : actiontypes_userinfo.LOGIN_RESULT_ERROR, 'parameters' : {
'parameters' : { 'errorMessages' : [
'errorMessages' : error.response.data.errors errorMessages['registration_errorunknown']['en']
} ]
}); }
storeOptionalToken(error.response); });
} else { }
__store.dispatch({ });
'type' : actiontypes_userinfo.LOGIN_RESULT_ERROR, return Object.assign({}, state, {});
'parameters' : { case actiontypes_userinfo.REGISTER_RESULT_SUCCESS:
'errorMessages' : [ errorMessages['login_errorunknown']['en'] ] return Object.assign({}, state, {
} error : false,
}); errorMessages : []
});
case actiontypes_userinfo.REGISTER_RESULT_ERROR:
return Object.assign({}, state, {
error : true,
errorMessages : action.parameters.errorMessages
});
case actiontypes_userinfo.LOGIN:
postRequest(action.state, '/users/sign_in', {
email : action.parameters.email,
password : action.parameters.password
}).then((resp) => {
__store.dispatch({
type : actiontypes_userinfo.LOGIN_RESULT_SUCCESS,
parameters : {
username : resp.data.username,
successCallback: action.parameters.successCallback
} }
}); });
return Object.assign({}, state, {}); storeOptionalToken(resp);
case actiontypes_userinfo.LOGIN_RESULT_SUCCESS: }).catch((error) => {
action.parameters.successCallback(action.parameters.username); if(error.response) {
return Object.assign({}, state, { __store.dispatch({
isSignedIn : true, 'type' : actiontypes_userinfo.LOGIN_RESULT_ERROR,
error : false, 'parameters' : {
errorMessages : [], 'errorMessages' : error.response.data.errors
username : action.parameters.username, }
}); });
case actiontypes_userinfo.LOGIN_RESULT_ERROR: storeOptionalToken(error.response);
return Object.assign({}, state, { } else {
error : true, __store.dispatch({
errorMessages : action.parameters.errorMessages 'type' : actiontypes_userinfo.LOGIN_RESULT_ERROR,
}); 'parameters' : {
case actiontypes_userinfo.LOGOUT: 'errorMessages' : [ errorMessages['login_errorunknown']['en'] ]
deleteRequest(action.state, '/users/sign_out').then(() => { }
action.parameters.successCallback(); });
__store.dispatch({ type : actiontypes_userinfo.CLEAR }); }
}).catch(() => { });
__store.dispatch({ type : actiontypes_userinfo.CLEAR }); return Object.assign({}, state, {});
}); case actiontypes_userinfo.LOGIN_RESULT_SUCCESS:
return Object.assign({}, state, {}); action.parameters.successCallback(action.parameters.username);
case actiontypes_userinfo.STORE_AUTH_HEADERS: return Object.assign({}, state, {
return Object.assign({}, state, { isSignedIn : true,
accesstoken : action.parameters.accesstoken, error : false,
client : action.parameters.client, errorMessages : [],
expiry : action.parameters.expiry, username : action.parameters.username,
uid : action.parameters.uid });
}); case actiontypes_userinfo.LOGIN_RESULT_ERROR:
case actiontypes_userinfo.VERIFY_CREDENTIALS: return Object.assign({}, state, {
getRequest(action.state, '/users/validate_token').then((resp) => { error : true,
storeOptionalToken(resp); errorMessages : action.parameters.errorMessages
}).catch(() => { });
__store.dispatch({ type: actiontypes_userinfo.CLEAR }); case actiontypes_userinfo.LOGOUT:
}); deleteRequest(action.state, '/users/sign_out').then(() => {
return Object.assign({}, state, {}); action.parameters.successCallback();
case actiontypes_userinfo.REHYDRATE: __store.dispatch({ type : actiontypes_userinfo.CLEAR });
return Object.assign({}, state, action.parameters, { error: false, errorMessages: [] }); }).catch(() => {
case actiontypes_userinfo.CLEAR: __store.dispatch({ type : actiontypes_userinfo.CLEAR });
return Object.assign({}, state, { });
isSignedIn : false, return Object.assign({}, state, {});
username : null, case actiontypes_userinfo.STORE_AUTH_HEADERS:
error : false, return Object.assign({}, state, {
errorMessages : [], accesstoken : action.parameters.accesstoken,
client : action.parameters.client,
expiry : action.parameters.expiry,
uid : action.parameters.uid
});
case actiontypes_userinfo.VERIFY_CREDENTIALS:
getRequest(action.state, '/users/validate_token').then((resp) => {
storeOptionalToken(resp);
}).catch(() => {
__store.dispatch({ type: actiontypes_userinfo.CLEAR });
});
return Object.assign({}, state, {});
case actiontypes_userinfo.REHYDRATE:
return Object.assign({}, state, action.parameters, { error: false, errorMessages: [] });
case actiontypes_userinfo.CLEAR:
return Object.assign({}, state, {
isSignedIn : false,
username : null,
error : false,
errorMessages : [],
accesstoken : null, accesstoken : null,
client : null, client : null,
expiry : null, expiry : null,
uid : null uid : null
}); });
default: return state; default: return state;
} }
}; };
const reducer_tournamentinfo = (state = defaultstate_tournamentinfo, action) => { const reducer_tournamentinfo = (state = defaultstate_tournamentinfo, action) => {
switch(action.type) { switch(action.type) {
case actiontypes_tournamentinfo.CREATE_TOURNAMENT: case actiontypes_tournamentinfo.CREATE_TOURNAMENT:
postRequest(action.state, '/tournaments', action.parameters.tournament).then((resp) => { postRequest(action.state, '/tournaments', action.parameters.tournament).then((resp) => {
storeOptionalToken(resp); storeOptionalToken(resp);
action.parameters.successCallback(); action.parameters.successCallback();
}).catch(() => { }).catch(() => {
action.parameters.errorCallback(); action.parameters.errorCallback();
});
return Object.assign({}, state, {});
case actiontypes_tournamentinfo.REQUEST_TOURNAMENT:
getRequest(action.state, '/tournaments/' + action.parameters.code).then((resp) => {
__store.dispatch({
type: actiontypes_tournamentinfo.REQUEST_TOURNAMENT_SUCCESS,
parameters: resp.data
}); });
return Object.assign({}, state, {}); storeOptionalToken(resp);
case actiontypes_tournamentinfo.REQUEST_TOURNAMENT: action.parameters.successCallback();
getRequest(action.state, '/tournaments/' + action.parameters.code).then((resp) => { }).catch(() => {
__store.dispatch({ action.parameters.errorCallback();
type: actiontypes_tournamentinfo.REQUEST_TOURNAMENT_SUCCESS, });
parameters: resp.data return Object.assign({}, state, {});
}); case actiontypes_tournamentinfo.REQUEST_TOURNAMENT_SUCCESS:
storeOptionalToken(resp); return Object.assign({}, state, {
action.parameters.successCallback(); code : action.parameters.code,
}).catch(() => { description : action.parameters.description,
action.parameters.errorCallback(); id : action.parameters.id,
}); name : action.parameters.name,
return Object.assign({}, state, {}); ownerUsername : action.parameters.owner_username,
case actiontypes_tournamentinfo.REQUEST_TOURNAMENT_SUCCESS: isPublic : action.parameters.public,
return Object.assign({}, state, { stages: action.parameters.stages,
code : action.parameters.code, teams : action.parameters.teams
description : action.parameters.description, });
id : action.parameters.id, case actiontypes_tournamentinfo.MODIFY_TOURNAMENT:
name : action.parameters.name, patchRequest(action.state, '/teams/' + action.parameters.teamid, {
ownerUsername : action.parameters.owner_username, name: action.parameters.name
isPublic : action.parameters.public, }).then((resp) => {
stages: action.parameters.stages, storeOptionalToken(resp);
teams : action.parameters.teams action.parameters.onSuccess();
}); }).catch((error) => {
case actiontypes_tournamentinfo.MODIFY_TOURNAMENT: if(error.response) {
patchRequest(action.state, '/teams/' + action.parameters.teamid, { storeOptionalToken(error.response);
name: action.parameters.name }
}).then((resp) => { action.parameters.onError();
storeOptionalToken(resp); });
action.parameters.onSuccess(); return Object.assign({}, state, {});
}).catch((error) => { case actiontypes_tournamentinfo.MODIFY_TOURNAMENT_SUCCESS:
if(error.response) {
storeOptionalToken(error.response);
}
action.parameters.onError();
});
return Object.assign({}, state, {});
case actiontypes_tournamentinfo.MODIFY_TOURNAMENT_SUCCESS:
return Object.assign({}, state, {}); return Object.assign({}, state, {});
case actiontypes_tournamentinfo.MODIFY_TOURNAMENT_ERROR: case actiontypes_tournamentinfo.MODIFY_TOURNAMENT_ERROR:
return Object.assign({}, state, {}); return Object.assign({}, state, {});
case actiontypes_tournamentinfo.REHYDRATE: case actiontypes_tournamentinfo.REHYDRATE:
return Object.assign({}, state, {}); return Object.assign({}, state, {});
case actiontypes_tournamentinfo.CLEAR: case actiontypes_tournamentinfo.CLEAR:
return Object.assign({}, state, {}); return Object.assign({}, state, {});
default: return state; default: return state;
} }
}; };
const reducer_tournamentlist = (state = defaultstate_tournamentlist, action) => { const reducer_tournamentlist = (state = defaultstate_tournamentlist, action) => {
switch (action.type) { switch (action.type) {
case actiontypes_tournamentlist.FETCH: case actiontypes_tournamentlist.FETCH:
getRequest(action.state, '/tournaments?type=' + action.parameters.type).then((resp) => { getRequest(action.state, '/tournaments?type=' + action.parameters.type).then((resp) => {
__store.dispatch({ __store.dispatch({
type: actiontypes_tournamentlist.FETCH_SUCCESS, type: actiontypes_tournamentlist.FETCH_SUCCESS,
parameters: resp.data parameters: resp.data
});
storeOptionalToken(resp);
action.parameters.successCallback(resp.data);
}).catch((error) => {
if(error.response) {
storeOptionalToken(error.response);
}
action.parameters.errorCallback();
}); });
return state; storeOptionalToken(resp);
case actiontypes_tournamentlist.FETCH_SUCCESS: action.parameters.successCallback(resp.data);
return Object.assign({}, state, {tournaments: action.parameters}); }).catch((error) => {
default: if(error.response) {
return state; storeOptionalToken(error.response);
}
action.parameters.errorCallback();
});
return state;
case actiontypes_tournamentlist.FETCH_SUCCESS:
return Object.assign({}, state, {tournaments: action.parameters});
default:
return state;
} }
}; };