9c0df36e16
* style: enforce sorting of imports * style: alphabetize imports * style: merge duplicated imports
220 lines
4.7 KiB
JavaScript
220 lines
4.7 KiB
JavaScript
import { send } from '../../platform/client/fetch';
|
|
import constants from '../constants';
|
|
import { addNotification } from './notifications';
|
|
import { getPayees, getAccounts } from './queries';
|
|
|
|
export function setAccountsSyncing(name) {
|
|
return {
|
|
type: constants.SET_ACCOUNTS_SYNCING,
|
|
name
|
|
};
|
|
}
|
|
|
|
export function markAccountFailed(id, errorType, errorCode) {
|
|
return {
|
|
type: 'ACCOUNT_SYNC_STATUS',
|
|
id,
|
|
failed: true,
|
|
errorType,
|
|
errorCode
|
|
};
|
|
}
|
|
export function markAccountSuccess(id) {
|
|
return {
|
|
type: 'ACCOUNT_SYNC_STATUS',
|
|
id,
|
|
failed: false
|
|
};
|
|
}
|
|
export function setFailedAccounts(syncErrors) {
|
|
return {
|
|
type: 'ACCOUNT_SYNC_FAILURES',
|
|
syncErrors
|
|
};
|
|
}
|
|
|
|
export function unlinkAccount(id) {
|
|
return async dispatch => {
|
|
await send('account-unlink', { id });
|
|
dispatch(markAccountSuccess(id));
|
|
dispatch(getAccounts());
|
|
};
|
|
}
|
|
|
|
export function linkAccount(institution, publicToken, accountId, upgradingId) {
|
|
return async dispatch => {
|
|
await send('accounts-link', {
|
|
institution,
|
|
publicToken,
|
|
accountId,
|
|
upgradingId
|
|
});
|
|
await dispatch(getPayees());
|
|
await dispatch(getAccounts());
|
|
};
|
|
}
|
|
|
|
export function connectAccounts(
|
|
institution,
|
|
publicToken,
|
|
accountIds,
|
|
offbudgetIds
|
|
) {
|
|
return async dispatch => {
|
|
let ids = await send('accounts-connect', {
|
|
institution,
|
|
publicToken,
|
|
accountIds,
|
|
offbudgetIds
|
|
});
|
|
await dispatch(getPayees());
|
|
await dispatch(getAccounts());
|
|
return ids;
|
|
};
|
|
}
|
|
|
|
export function syncAccounts(id) {
|
|
return async (dispatch, getState) => {
|
|
if (getState().account.accountsSyncing) {
|
|
return false;
|
|
}
|
|
|
|
if (id) {
|
|
let account = getState().queries.accounts.find(a => a.id === id);
|
|
dispatch(setAccountsSyncing(account.name));
|
|
} else {
|
|
dispatch(setAccountsSyncing('__all'));
|
|
}
|
|
|
|
const {
|
|
errors,
|
|
newTransactions,
|
|
matchedTransactions,
|
|
updatedAccounts
|
|
} = await send('accounts-sync', { id });
|
|
dispatch(setAccountsSyncing(null));
|
|
|
|
if (id) {
|
|
let error = errors.find(error => error.accountId === id);
|
|
|
|
if (error) {
|
|
// We only want to mark the account as having problem if it
|
|
// was a real syncing error.
|
|
if (error.type === 'SyncError') {
|
|
dispatch(markAccountFailed(id, error.category, error.code));
|
|
}
|
|
} else {
|
|
dispatch(markAccountSuccess(id));
|
|
}
|
|
} else {
|
|
dispatch(
|
|
setFailedAccounts(
|
|
errors
|
|
.filter(error => error.type === 'SyncError')
|
|
.map(error => ({
|
|
id: error.accountId,
|
|
type: error.category,
|
|
code: error.code
|
|
}))
|
|
)
|
|
);
|
|
}
|
|
|
|
errors.forEach(error => {
|
|
if (error.type === 'SyncError') {
|
|
dispatch(
|
|
addNotification({
|
|
type: 'error',
|
|
message: error.message
|
|
})
|
|
);
|
|
} else {
|
|
dispatch(
|
|
addNotification({
|
|
type: 'error',
|
|
message: error.message,
|
|
internal: error.internal
|
|
})
|
|
);
|
|
}
|
|
});
|
|
|
|
dispatch({
|
|
type: constants.SET_NEW_TRANSACTIONS,
|
|
newTransactions,
|
|
matchedTransactions,
|
|
updatedAccounts
|
|
});
|
|
|
|
return newTransactions.length > 0 || matchedTransactions.length > 0;
|
|
};
|
|
}
|
|
|
|
// Remember the last transaction manually added to the system
|
|
export function setLastTransaction(transaction) {
|
|
return {
|
|
type: constants.SET_LAST_TRANSACTION,
|
|
transaction
|
|
};
|
|
}
|
|
|
|
export function parseTransactions(filepath, options) {
|
|
return async dispatch => {
|
|
return await send('transactions-parse-file', {
|
|
filepath,
|
|
options
|
|
});
|
|
};
|
|
}
|
|
|
|
export function importTransactions(id, transactions) {
|
|
return async dispatch => {
|
|
let { errors = [], added, updated } = await send('transactions-import', {
|
|
accountId: id,
|
|
transactions
|
|
});
|
|
|
|
errors.forEach(error => {
|
|
dispatch(
|
|
addNotification({
|
|
type: 'error',
|
|
message: error.message,
|
|
internal: error.internal
|
|
})
|
|
);
|
|
});
|
|
|
|
dispatch({
|
|
type: constants.SET_NEW_TRANSACTIONS,
|
|
newTransactions: added,
|
|
matchedTransactions: updated,
|
|
updatedAccounts: added.length > 0 ? [id] : []
|
|
});
|
|
|
|
return added.length > 0 || updated.length > 0;
|
|
};
|
|
}
|
|
|
|
export function updateNewTransactions(changedId) {
|
|
return {
|
|
type: constants.UPDATE_NEW_TRANSACTIONS,
|
|
changedId
|
|
};
|
|
}
|
|
|
|
export function markAccountRead(accountId) {
|
|
return {
|
|
type: constants.MARK_ACCOUNT_READ,
|
|
accountId: accountId
|
|
};
|
|
}
|
|
|
|
export function getBanks() {
|
|
return async dispatch => {
|
|
dispatch({
|
|
type: constants.LOAD_BANKS,
|
|
banks: await send('banks')
|
|
});
|
|
};
|
|
}
|