code refactor

src/Mobile.vue

@@ -60,6 +60,19 @@ export default {
             }
         }
     },
+    created() {
+        if (this.$user.isUserLogined()) {
+            if (!this.$settings.isEnableApplicationLock()) {
+                // refresh token if user is logined
+                this.$store.dispatch('refreshTokenAndRevokeOldToken');
+
+                // auto refresh exchange rates data
+                if (this.$settings.isAutoUpdateExchangeRatesData()) {
+                    this.$services.autoRefreshLatestExchangeRates();
+                }
+            }
+        }
+    },
     methods: {
         isiOSHomeScreenMode() {
             if ((/iphone|ipod|ipad/gi).test(navigator.platform) && (/Safari/i).test(navigator.appVersion) &&

src/lib/services.js

@@ -96,31 +96,22 @@ export default {
         return axios.get('logout.json');
     },
     refreshToken: () => {
-        needBlockRequest = true;
+        return new Promise((resolve) => {
+            needBlockRequest = true;
 
-        return axios.post('v1/tokens/refresh.json', {} , {
+            axios.post('v1/tokens/refresh.json', {}, {
-            ignoreBlocked: true
+                ignoreBlocked: true
-        }).then(response => {
+            }).then(response => {
-            const data = response.data;
+                const data = response.data;
 
-            if (data && data.success && data.result && data.result.newToken) {
+                resolve(response);
-                userState.updateToken(data.result.newToken);
+                needBlockRequest = false;
-                userState.updateUserInfo(data.result.user);
 
-                if (data.result.oldTokenId) {
+                return data.result.newToken;
-                    axios.post('v1/tokens/revoke.json', {
+            }).then(newToken => {
-                        tokenId: data.result.oldTokenId
+                blockedRequests.forEach(func => func(newToken));
-                    }, {
+                blockedRequests.length = 0;
-                        ignoreError: true
+            });
-                    });
-                }
-            }
-
-            needBlockRequest = false;
-            return data.result.newToken;
-        }).then(newToken => {
-            blockedRequests.forEach(func => func(newToken));
-            blockedRequests.length = 0;
         });
     },
     getDataExportUrl: () => {
@@ -130,9 +121,11 @@ export default {
     getTokens: () => {
         return axios.get('v1/tokens/list.json');
     },
-    revokeToken: ({ tokenId }) => {
+    revokeToken: ({ tokenId, ignoreError }) => {
         return axios.post('v1/tokens/revoke.json', {
             tokenId
+        }, {
+            ignoreError: !!ignoreError
         });
     },
     revokeAllTokens: () => {

src/lib/userstate.js

@@ -160,16 +160,8 @@ function updateUserInfo(user) {
     }
 }
 
-function updateTokenAndUserInfo(item) {
+function clearUserInfo() {
-    if (utils.isObject(item)) {
+    localStorage.removeItem(userInfoLocalStorageKey);
-        if (item.token) {
-            updateToken(item.token);
-        }
-
-        if (item.user) {
-            updateUserInfo(item.user);
-        }
-    }
 }
 
 function clearTokenAndUserInfo(clearAppLockState) {
@@ -179,7 +171,7 @@ function clearTokenAndUserInfo(clearAppLockState) {
 
     sessionStorage.removeItem(tokenSessionStorageKey);
     localStorage.removeItem(tokenLocalStorageKey);
-    localStorage.removeItem(userInfoLocalStorageKey);
+    clearUserInfo();
 }
 
 export default {
@@ -198,6 +190,6 @@ export default {
     isCorrectPinCode,
     updateToken,
     updateUserInfo,
-    updateTokenAndUserInfo,
+    clearUserInfo,
     clearTokenAndUserInfo
 };

src/mobile-main.js

@@ -227,18 +227,6 @@ Vue.filter('tokenIcon', (value) => tokenIconFilter(value));
 
 Vue.prototype.$locale.init();
 
-if (userstate.isUserLogined()) {
-    if (!settings.isEnableApplicationLock()) {
-        // refresh token if user is logined
-        services.refreshToken();
-
-        // auto refresh exchange rates data
-        if (settings.isAutoUpdateExchangeRatesData()) {
-            services.autoRefreshLatestExchangeRates();
-        }
-    }
-}
-
 new Vue({
     el: '#app',
     i18n: i18n,

src/store/index.js

@@ -1,6 +1,12 @@
+import userState from "../lib/userstate.js";
 import utils from "../lib/utils.js";
 
 import {
+    RESET_STATE,
+
+    STORE_USER_INFO,
+    CLEAR_USER_INFO,
+
     LOAD_ACCOUNT_LIST,
     ADD_ACCOUNT_TO_ACCOUNT_LIST,
     SAVE_ACCOUNT_IN_ACCOUNT_LIST,
@@ -20,12 +26,15 @@ import {
     UPDATE_TRANSACTION_TAG_LIST_INVALID_STATE
 } from './mutations.js';
 
+import user from './user.js';
+import token from './token.js';
 import account from './account.js';
 import transactionTag from './transactionTag.js';
 
 const stores = {
     strict: process.env.NODE_ENV !== 'production',
     state: {
+        currentUserInfo: userState.getUserInfo(),
         allAccounts: [],
         allAccountsMap: {},
         allCategorizedAccounts: {},
@@ -38,10 +47,32 @@ const stores = {
         transactions: [],
     },
     getters: {
+        currentUserNickname: user.currentUserNickname,
+        currentUserDefaultCurrency: user.currentUserDefaultCurrency,
         allAvailableAccountsCount: account.allAvailableAccountsCount,
         allVisibleAccountsCount: account.allVisibleAccountsCount,
     },
     mutations: {
+        [RESET_STATE] (state) {
+            state.allAccounts = [];
+            state.allAccountsMap = {};
+            state.allCategorizedAccounts = {};
+            state.accountListStateInvalid = true;
+            state.allTransactionCategories = [];
+            state.allTransactionCategoriesMap = {};
+            state.allTransactionTags = [];
+            state.allTransactionTagsMap = {};
+            state.transactionTagListStateInvalid = true;
+            state.transactions = [];
+        },
+        [STORE_USER_INFO] (state, userInfo) {
+            state.currentUserInfo = userInfo;
+            userState.updateUserInfo(userInfo);
+        },
+        [CLEAR_USER_INFO] (state) {
+            state.currentUserInfo = null;
+            userState.clearUserInfo();
+        },
         [LOAD_ACCOUNT_LIST] (state, accounts) {
             state.allAccounts = accounts;
             state.allAccountsMap = {};
@@ -212,6 +243,17 @@ const stores = {
         },
     },
     actions: {
+        authorize: user.authorize,
+        authorize2FA: user.authorize2FA,
+        register: user.register,
+        logout: user.logout,
+        getCurrentUserProfile: user.getCurrentUserProfile,
+        updateUserProfile: user.updateUserProfile,
+        clearUserInfoState: user.clearUserInfoState,
+        getAllTokens: token.getAllTokens,
+        refreshTokenAndRevokeOldToken: token.refreshTokenAndRevokeOldToken,
+        revokeToken: token.revokeToken,
+        revokeAllTokens: token.revokeAllTokens,
         loadAllAccounts: account.loadAllAccounts,
         saveAccount: account.saveAccount,
         getAccount: account.getAccount,

src/store/mutations.js

@@ -1,3 +1,8 @@
+export const RESET_STATE = 'RESET_STATE';
+
+export const STORE_USER_INFO = 'STORE_USER_INFO';
+export const CLEAR_USER_INFO = 'CLEAR_USER_INFO';
+
 export const LOAD_ACCOUNT_LIST = 'LOAD_ACCOUNT_LIST';
 export const ADD_ACCOUNT_TO_ACCOUNT_LIST = 'ADD_ACCOUNT_TO_ACCOUNT_LIST';
 export const SAVE_ACCOUNT_IN_ACCOUNT_LIST = 'SAVE_ACCOUNT_IN_ACCOUNT_LIST';

src/store/token.js

@@ -0,0 +1,118 @@
+import userState from '../lib/userstate.js';
+import services from '../lib/services.js';
+import logger from '../lib/logger.js';
+import utils from '../lib/utils.js';
+
+import {
+    STORE_USER_INFO
+} from './mutations.js';
+
+function getAllTokens() {
+    return new Promise((resolve, reject) => {
+        services.getTokens().then(response => {
+            const data = response.data;
+
+            if (!data || !data.success || !data.result) {
+                reject({ message: 'Unable to get session list' });
+                return;
+            }
+
+            resolve(data.result);
+        }).catch(error => {
+            logger.error('failed to load token list', error);
+
+            if (error.response && error.response.data && error.response.data.errorMessage) {
+                reject({ error: error.response.data });
+            } else if (!error.processed) {
+                reject({ message: 'Unable to get session list' });
+            } else {
+                reject(error);
+            }
+        });
+    });
+}
+
+function refreshTokenAndRevokeOldToken(context) {
+    return new Promise((resolve) => {
+        services.refreshToken().then(response => {
+            const data = response.data;
+
+            if (data && data.success && data.result && data.result.newToken) {
+                userState.updateToken(data.result.newToken);
+
+                if (data.result.user && utils.isObject(data.result.user)) {
+                    context.commit(STORE_USER_INFO, data.result.user);
+                }
+
+                if (data.result.oldTokenId) {
+                    revokeToken(context, {
+                        tokenId: data.result.oldTokenId,
+                        ignoreError: true
+                    });
+                }
+            }
+
+            resolve(data.result);
+        });
+    });
+}
+
+function revokeToken(context, { tokenId, ignoreError }) {
+    return new Promise((resolve, reject) => {
+        services.revokeToken({
+            tokenId: tokenId,
+            ignoreError: !!ignoreError
+        }).then(response => {
+            const data = response.data;
+
+            if (!data || !data.success || !data.result) {
+                reject({ message: 'Unable to logout from this session' });
+                return;
+            }
+
+            resolve(data.result);
+        }).catch(error => {
+            logger.error('failed to revoke token', error);
+
+            if (error.response && error.response.data && error.response.data.errorMessage) {
+                reject({ error: error.response.data });
+            } else if (!error.processed) {
+                reject({ message: 'Unable to logout from this session' });
+            } else {
+                reject(error);
+            }
+        });
+    });
+}
+
+function revokeAllTokens() {
+    return new Promise((resolve, reject) => {
+        services.revokeAllTokens().then(response => {
+            const data = response.data;
+
+            if (!data || !data.success || !data.result) {
+                reject({ message: 'Unable to logout all other sessions' });
+                return;
+            }
+
+            resolve(data.result);
+        }).catch(error => {
+            logger.error('failed to revoke all tokens', error);
+
+            if (error.response && error.response.data && error.response.data.errorMessage) {
+                reject({ error: error.response.data });
+            } else if (!error.processed) {
+                reject({ message: 'Unable to logout all other sessions' });
+            } else {
+                reject(error);
+            }
+        });
+    });
+}
+
+export default {
+    getAllTokens,
+    refreshTokenAndRevokeOldToken,
+    revokeToken,
+    revokeAllTokens
+}

src/store/user.js

@@ -0,0 +1,287 @@
+import userState from '../lib/userstate.js';
+import services from '../lib/services.js';
+import settings from '../lib/settings.js';
+import logger from '../lib/logger.js';
+import utils from '../lib/utils.js';
+
+import {
+    RESET_STATE,
+
+    STORE_USER_INFO,
+    CLEAR_USER_INFO
+} from './mutations.js';
+
+function authorize(context, { loginName, password }) {
+    return new Promise((resolve, reject) => {
+        services.authorize({
+            loginName: loginName,
+            password: password
+        }).then(response => {
+            const data = response.data;
+
+            if (!data || !data.success || !data.result || !data.result.token) {
+                reject({ message: 'Unable to login' });
+                return;
+            }
+
+            if (data.result.need2FA) {
+                resolve(data.result);
+                return;
+            }
+
+            if (settings.isEnableApplicationLock() || userState.getUserAppLockState()) {
+                const appLockState = userState.getUserAppLockState();
+
+                if (!appLockState || appLockState.username !== data.result.user.username) {
+                    userState.clearTokenAndUserInfo(true);
+                    settings.setEnableApplicationLock(false);
+                    settings.setEnableApplicationLockWebAuthn(false);
+                    userState.clearWebAuthnConfig();
+                }
+            }
+
+            userState.updateToken(data.result.token);
+
+            if (data.result.user && utils.isObject(data.result.user)) {
+                context.commit(STORE_USER_INFO, data.result.user);
+            }
+
+            resolve(data.result);
+        }).catch(error => {
+            logger.error('failed to login', error);
+
+            if (error && error.processed) {
+                reject(error);
+            } else if (error.response && error.response.data && error.response.data.errorMessage) {
+                reject({ error: error.response.data });
+            } else {
+                reject({ message: 'Unable to login' });
+            }
+        });
+    });
+}
+
+function authorize2FA(context, { token, passcode, recoveryCode }) {
+    return new Promise((resolve, reject) => {
+        let promise = null;
+
+        if (passcode) {
+            promise = services.authorize2FA({
+                passcode: passcode,
+                token: token
+            });
+        } else if (recoveryCode) {
+            promise = services.authorize2FAByBackupCode({
+                recoveryCode: recoveryCode,
+                token: token
+            });
+        } else {
+            reject({ message: 'An error has occurred' });
+            return;
+        }
+
+        promise.then(response => {
+            const data = response.data;
+
+            if (!data || !data.success || !data.result || !data.result.token) {
+                reject({ message: 'Unable to verify' });
+                return;
+            }
+
+            if (settings.isEnableApplicationLock() || userState.getUserAppLockState()) {
+                const appLockState = userState.getUserAppLockState();
+
+                if (!appLockState || appLockState.username !== data.result.user.username) {
+                    userState.clearTokenAndUserInfo(true);
+                    settings.setEnableApplicationLock(false);
+                    settings.setEnableApplicationLockWebAuthn(false);
+                    userState.clearWebAuthnConfig();
+                }
+            }
+
+            userState.updateToken(data.result.token);
+
+            if (data.result.user && utils.isObject(data.result.user)) {
+                context.commit(STORE_USER_INFO, data.result.user);
+            }
+
+            resolve(data.result);
+        }).catch(error => {
+            logger.error('failed to verify 2fa', error);
+
+            if (error && error.processed) {
+                reject(error);
+            } else if (error.response && error.response.data && error.response.data.errorMessage) {
+                reject({ error: error.response.data });
+            } else {
+                reject({ message: 'Unable to verify' });
+            }
+        });
+    });
+}
+
+function register(context, { user }) {
+    return new Promise((resolve, reject) => {
+        services.register({
+            username: user.username,
+            password: user.password,
+            email: user.email,
+            nickname: user.nickname,
+            defaultCurrency: user.defaultCurrency
+        }).then(response => {
+            const data = response.data;
+
+            if (!data || !data.success || !data.result) {
+                reject({ message: 'Unable to sign up' });
+                return;
+            }
+
+            if (settings.isEnableApplicationLock()) {
+                settings.setEnableApplicationLock(false);
+                settings.setEnableApplicationLockWebAuthn(false);
+                userState.clearWebAuthnConfig();
+            }
+
+            if (data.result.token && utils.isString(data.result.token)) {
+                userState.updateToken(data.result.token);
+            }
+
+            if (data.result.user && utils.isObject(data.result.user)) {
+                context.commit(STORE_USER_INFO, data.result.user);
+            }
+
+            resolve(data.result);
+        }).catch(error => {
+            logger.error('failed to sign up', error);
+
+            if (error.response && error.response.data && error.response.data.errorMessage) {
+                reject({ error: error.response.data });
+            } else if (!error.processed) {
+                reject({ message: 'Unable to sign up' });
+            } else {
+                reject(error);
+            }
+        });
+    });
+}
+
+function logout(context) {
+    return new Promise((resolve, reject) => {
+        services.logout().then(response => {
+            const data = response.data;
+
+            if (!data || !data.success || !data.result) {
+                reject({ message: 'Unable to logout' });
+                return;
+            }
+
+            context.commit(CLEAR_USER_INFO);
+            userState.clearTokenAndUserInfo(true);
+            userState.clearWebAuthnConfig();
+
+            context.commit(RESET_STATE);
+
+            resolve(data.result);
+        }).catch(error => {
+            logger.error('failed to log out', error);
+
+            if (error && error.processed) {
+                reject(error);
+            } else if (error.response && error.response.data && error.response.data.errorMessage) {
+                reject({ error: error.response.data });
+            } else {
+                reject({ message: 'Unable to logout' });
+            }
+        });
+    });
+}
+
+function getCurrentUserProfile() {
+    return new Promise((resolve, reject) => {
+        services.getProfile().then(response => {
+            const data = response.data;
+
+            if (!data || !data.success || !data.result) {
+                reject({ message: 'Unable to get user profile' });
+                return;
+            }
+
+            resolve(data.result);
+        }).catch(error => {
+            logger.error('failed to get user profile', error);
+
+            if (error.response && error.response.data && error.response.data.errorMessage) {
+                reject({ error: error.response.data });
+            } else if (!error.processed) {
+                reject({ message: 'Unable to get user profile' });
+            } else {
+                reject(error);
+            }
+        });
+    });
+}
+
+function updateUserProfile(context, { profile, currentPassword }) {
+    return new Promise((resolve, reject) => {
+        services.updateProfile({
+            password: profile.password,
+            oldPassword: currentPassword,
+            email: profile.email,
+            nickname: profile.nickname,
+            defaultCurrency: profile.defaultCurrency
+        }).then(response => {
+            const data = response.data;
+
+            if (!data || !data.success || !data.result) {
+                reject({ message: 'Unable to update user profile' });
+                return;
+            }
+
+            if (data.result.newToken && utils.isString(data.result.newToken)) {
+                userState.updateToken(data.result.newToken);
+            }
+
+            if (data.result.user && utils.isObject(data.result.user)) {
+                context.commit(STORE_USER_INFO, data.result.user);
+            }
+
+            resolve(data.result);
+        }).catch(error => {
+            logger.error('failed to save user profile', error);
+
+            if (error.response && error.response.data && error.response.data.errorMessage) {
+                reject({ error: error.response.data });
+            } else if (!error.processed) {
+                reject({ message: 'Unable to update user profile' });
+            } else {
+                reject(error);
+            }
+        });
+    });
+}
+
+function clearUserInfoState(context) {
+    context.commit(CLEAR_USER_INFO);
+}
+
+function currentUserNickname(state) {
+    const userInfo = state.currentUserInfo || {};
+    return userInfo.nickname || userInfo.username || null;
+}
+
+function currentUserDefaultCurrency(state) {
+    const userInfo = state.currentUserInfo || {};
+    return userInfo.defaultCurrency || null;
+}
+
+export default {
+    authorize,
+    authorize2FA,
+    register,
+    logout,
+    getCurrentUserProfile,
+    updateUserProfile,
+    clearUserInfoState,
+    currentUserNickname,
+    currentUserDefaultCurrency
+}

src/views/mobile/ApplicationLock.vue

@@ -65,7 +65,7 @@ export default {
 
                 self.$webauthn.registerCredential(
                     self.$user.getUserAppLockState(),
-                    self.$user.getUserInfo(),
+                    self.$store.state.currentUserInfo,
                 ).then(({ id }) => {
                     self.$hideLoading();
 
@@ -120,7 +120,7 @@ export default {
                 return;
             }
 
-            const user = this.$user.getUserInfo();
+            const user = this.$store.state.currentUserInfo;
 
             if (!user || !user.username) {
                 this.$alert('An error has occurred');

src/views/mobile/ExchangeRates.vue

@@ -55,7 +55,7 @@ export default {
         const self = this;
 
         return {
-            baseCurrency: self.$user.getUserInfo() ? self.$user.getUserInfo().defaultCurrency : self.$t('default.currency'),
+            baseCurrency: self.$store.getters.currentUserDefaultCurrency || self.$t('default.currency'),
             exchangeRatesData: self.$exchangeRates.getExchangeRates(),
             updating: false
         };

src/views/mobile/Login.vue

@@ -174,57 +174,30 @@ export default {
             self.logining = true;
             self.$showLoading(() => self.logining);
 
-            self.$services.authorize({
+            self.$store.dispatch('authorize', {
                 loginName: self.username,
                 password: self.password
-            }).then(response => {
+            }).then(authResponse => {
                 self.logining = false;
                 self.$hideLoading();
-                const data = response.data;
 
-                if (!data || !data.success || !data.result || !data.result.token) {
+                if (authResponse.need2FA) {
-                    self.$toast('Unable to login');
+                    self.tempToken = authResponse.token;
-                    return;
-                }
-
-                if (data.result.need2FA) {
-                    self.tempToken = data.result.token;
                     self.show2faSheet = true;
                     return;
                 }
 
-                if (self.$settings.isEnableApplicationLock() || self.$user.getUserAppLockState()) {
-                    const appLockState = self.$user.getUserAppLockState();
-
-                    if (!appLockState || appLockState.username !== data.result.user.username) {
-                        self.$user.clearTokenAndUserInfo(true);
-                        self.$settings.setEnableApplicationLock(false);
-                        self.$settings.setEnableApplicationLockWebAuthn(false);
-                        self.$user.clearWebAuthnConfig();
-                    }
-                }
-
-                self.$user.updateTokenAndUserInfo(data.result);
-
                 if (self.$settings.isAutoUpdateExchangeRatesData()) {
                     self.$services.autoRefreshLatestExchangeRates();
                 }
 
                 router.refreshPage();
             }).catch(error => {
-                self.$logger.error('failed to login', error);
-
                 self.logining = false;
                 self.$hideLoading();
 
-                if (error && error.processed) {
+                if (!error.processed) {
-                    return;
+                    self.$toast(error.message || error);
-                }
-
-                if (error.response && error.response.data && error.response.data.errorMessage) {
-                    self.$toast({ error: error.response.data });
-                } else if (!error.processed) {
-                    self.$toast('Unable to login');
                 }
             });
         },
@@ -257,42 +230,13 @@ export default {
             self.verifying = true;
             self.$showLoading(() => self.verifying);
 
-            let promise = null;
+            self.$store.dispatch('authorize2FA', {
-
+                token: self.tempToken,
-            if (self.twoFAVerifyType === 'backupcode') {
+                passcode: self.twoFAVerifyType === 'passcode' ? self.passcode : null,
-                promise = self.$services.authorize2FAByBackupCode({
+                recoveryCode: self.twoFAVerifyType === 'backupcode' ? self.backupCode : null
-                    recoveryCode: self.backupCode,
+            }).then(() => {
-                    token: self.tempToken
-                });
-            } else {
-                promise = self.$services.authorize2FA({
-                    passcode: self.passcode,
-                    token: self.tempToken
-                });
-            }
-
-            promise.then(response => {
                 self.verifying = false;
                 self.$hideLoading();
-                const data = response.data;
-
-                if (!data || !data.success || !data.result || !data.result.token) {
-                    self.$toast('Unable to verify');
-                    return;
-                }
-
-                if (self.$settings.isEnableApplicationLock() || self.$user.getUserAppLockState()) {
-                    const appLockState = self.$user.getUserAppLockState();
-
-                    if (!appLockState || appLockState.username !== data.result.user.username) {
-                        self.$user.clearTokenAndUserInfo(true);
-                        self.$settings.setEnableApplicationLock(false);
-                        self.$settings.setEnableApplicationLockWebAuthn(false);
-                        self.$user.clearWebAuthnConfig();
-                    }
-                }
-
-                self.$user.updateTokenAndUserInfo(data.result);
 
                 if (self.$settings.isAutoUpdateExchangeRatesData()) {
                     self.$services.autoRefreshLatestExchangeRates();
@@ -301,17 +245,13 @@ export default {
                 self.show2faSheet = false;
                 router.refreshPage();
             }).catch(error => {
-                self.$logger.error('failed to verify 2fa', error);
-
                 self.verifying = false;
                 self.$hideLoading();
 
-                if (error.response && error.response.data && error.response.data.errorMessage) {
+                if (!error.processed) {
-                    self.$toast({ error: error.response.data });
+                    self.$toast(error.message || error);
-                } else if (!error.processed) {
-                    self.$toast('Unable to verify');
                 }
-            })
+            });
         },
         switch2FAVerifyType() {
             if (this.twoFAVerifyType === 'passcode') {

src/views/mobile/Settings.vue

@@ -86,7 +86,6 @@ export default {
         const self = this;
 
         return {
-            currentNickName: self.getCurrentUserNickName(),
             isEnableApplicationLock: this.$settings.isEnableApplicationLock(),
             exchangeRatesLastUpdateDate: self.getExchangeRatesLastUpdateDate(),
             logouting: false
@@ -108,6 +107,9 @@ export default {
                 this.exchangeRatesLastUpdateDate = this.getExchangeRatesLastUpdateDate();
             }
         },
+        currentNickName() {
+            return this.$store.getters.currentUserNickname || this.$t('User');
+        },
         isDataExportingEnabled() {
             return this.$settings.isDataExportingEnabled();
         },
@@ -168,14 +170,9 @@ export default {
     },
     methods: {
         onPageAfterIn() {
-            this.currentNickName = this.getCurrentUserNickName();
             this.isEnableApplicationLock = this.$settings.isEnableApplicationLock();
             this.exchangeRatesLastUpdateDate = this.getExchangeRatesLastUpdateDate();
         },
-        getCurrentUserNickName() {
-            const userInfo = this.$user.getUserInfo() || {};
-            return userInfo.nickname || userInfo.username || this.$t('User');
-        },
         getExchangeRatesLastUpdateDate() {
             const exchangeRates = this.$exchangeRates.getExchangeRates();
             return exchangeRates && exchangeRates.date ? this.$moment(exchangeRates.date).format(this.$t('format.date.long')) : '';
@@ -188,37 +185,21 @@ export default {
                 self.logouting = true;
                 self.$showLoading(() => self.logouting);
 
-                self.$services.logout().then(response => {
+                self.$store.dispatch('logout').then(() => {
                     self.logouting = false;
                     self.$hideLoading();
-                    const data = response.data;
 
-                    if (!data || !data.success || !data.result) {
-                        self.$toast('Unable to logout');
-                        return;
-                    }
-
-                    self.$user.clearTokenAndUserInfo(true);
-                    self.$user.clearWebAuthnConfig();
                     self.$exchangeRates.clearExchangeRates();
                     self.$settings.clearSettings();
                     self.$locale.init();
 
                     router.navigate('/');
                 }).catch(error => {
-                    self.$logger.error('failed to log out', error);
-
                     self.logouting = false;
                     self.$hideLoading();
 
-                    if (error && error.processed) {
+                    if (!error.processed) {
-                        return;
+                        self.$toast(error.message || error);
-                    }
-
-                    if (error.response && error.response.data && error.response.data.errorMessage) {
-                        self.$toast({ error: error.response.data });
-                    } else if (!error.processed) {
-                        self.$toast('Unable to logout');
                     }
                 });
             });

src/views/mobile/Signup.vue

@@ -152,31 +152,13 @@ export default {
             self.submitting = true;
             self.$showLoading(() => self.submitting);
 
-            self.$services.register({
+            self.$store.dispatch('register', {
-                username: self.user.username,
+                user: self.user
-                password: self.user.password,
+            }).then(() => {
-                email: self.user.email,
-                nickname: self.user.nickname,
-                defaultCurrency: self.user.defaultCurrency
-            }).then(response => {
                 self.submitting = false;
                 self.$hideLoading();
-                const data = response.data;
-
-                if (!data || !data.success || !data.result) {
-                    self.$toast('Unable to sign up');
-                    return;
-                }
-
-                if (self.$settings.isEnableApplicationLock()) {
-                    self.$settings.setEnableApplicationLock(false);
-                    self.$settings.setEnableApplicationLockWebAuthn(false);
-                    self.$user.clearWebAuthnConfig();
-                }
-
-                if (self.$utilities.isString(data.result.token)) {
-                    self.$user.updateTokenAndUserInfo(data.result);
 
+                if (self.$user.isUserLogined()) {
                     if (self.$settings.isAutoUpdateExchangeRatesData()) {
                         self.$services.autoRefreshLatestExchangeRates();
                     }
@@ -189,15 +171,11 @@ export default {
                     router.navigate('/category/default?type=0');
                 });
             }).catch(error => {
-                self.$logger.error('failed to sign up', error);
-
                 self.submitting = false;
                 self.$hideLoading();
 
-                if (error.response && error.response.data && error.response.data.errorMessage) {
+                if (!error.processed) {
-                    self.$toast({ error: error.response.data });
+                    self.$toast(error.message || error);
-                } else if (!error.processed) {
-                    self.$toast('Unable to sign up');
                 }
             });
         }

src/views/mobile/Unlock.vue

@@ -51,13 +51,13 @@ export default {
             self.$showLoading();
 
             self.$webauthn.verifyCredential(
-                self.$user.getUserInfo(),
+                self.$store.state.currentUserInfo,
                 self.$user.getWebAuthnCredentialId()
             ).then(({ id, userName, userSecret }) => {
                 self.$hideLoading();
 
                 self.$user.unlockTokenByWebAuthn(id, userName, userSecret);
-                self.$services.refreshToken();
+                self.$store.dispatch('refreshTokenAndRevokeOldToken');
 
                 if (self.$settings.isAutoUpdateExchangeRatesData()) {
                     self.$services.autoRefreshLatestExchangeRates();
@@ -92,7 +92,7 @@ export default {
             }
 
             const router = this.$f7router;
-            const user = this.$user.getUserInfo();
+            const user = this.$store.state.currentUserInfo;
 
             if (!user || !user.username) {
                 this.$alert('An error has occurred');
@@ -101,7 +101,7 @@ export default {
 
             try {
                 this.$user.unlockTokenByPinCode(user.username, this.pinCode);
-                this.$services.refreshToken();
+                this.$store.dispatch('refreshTokenAndRevokeOldToken');
 
                 if (this.$settings.isAutoUpdateExchangeRatesData()) {
                     this.$services.autoRefreshLatestExchangeRates();
@@ -120,6 +120,7 @@ export default {
             self.$confirm('Are you sure you want to re-login?', () => {
                 self.$user.clearTokenAndUserInfo(true);
                 self.$user.clearWebAuthnConfig();
+                self.$store.dispatch('clearUserInfoState');
                 self.$exchangeRates.clearExchangeRates();
                 self.$settings.clearSettings();
                 self.$locale.init();

src/views/mobile/accounts/Edit.vue

@@ -320,7 +320,7 @@ export default {
                 name: '',
                 icon: self.$constants.icons.defaultAccountIconId,
                 color: self.$constants.colors.defaultAccountColor,
-                currency: self.$user.getUserInfo() ? self.$user.getUserInfo().defaultCurrency : self.$t('default.currency'),
+                currency: self.$store.getters.currentUserDefaultCurrency || self.$t('default.currency'),
                 balance: 0,
                 comment: '',
                 visible: true,
@@ -447,9 +447,9 @@ export default {
                 category: null,
                 type: null,
                 name: '',
-                icon: this.account.icon,
+                icon: self.account.icon,
-                color: this.account.color,
+                color: self.account.color,
-                currency: self.$user.getUserInfo() ? self.$user.getUserInfo().defaultCurrency : self.$t('default.currency'),
+                currency: self.$store.getters.currentUserDefaultCurrency || self.$t('default.currency'),
                 balance: 0,
                 comment: '',
                 visible: true,

src/views/mobile/accounts/List.vue

@@ -214,7 +214,7 @@ export default {
     },
     computed: {
         defaultCurrency() {
-            return this.$user.getUserInfo() ? this.$user.getUserInfo().defaultCurrency : this.$t('default.currency');
+            return this.$store.getters.currentUserDefaultCurrency || this.$t('default.currency');
         },
         allAccountCategories() {
             return this.$constants.account.allCategories;

src/views/mobile/transactions/Edit.vue

@@ -308,7 +308,7 @@ export default {
             }
         },
         defaultCurrency() {
-            return this.$user.getUserInfo() ? this.$user.getUserInfo().defaultCurrency : this.$t('default.currency');
+            return this.$store.getters.currentUserDefaultCurrency || this.$t('default.currency');
         },
         hasAvailableExpenseCategories() {
             if (!this.allCategories || !this.allCategories[this.$constants.category.allCategoryTypes.Expense] || !this.allCategories[this.$constants.category.allCategoryTypes.Expense].length) {

src/views/mobile/transactions/List.vue

@@ -394,7 +394,7 @@ export default {
     },
     computed: {
         defaultCurrency() {
-            return this.$user.getUserInfo() ? this.$user.getUserInfo().defaultCurrency : this.$t('default.currency');
+            return this.$store.getters.currentUserDefaultCurrency || this.$t('default.currency');
         },
         noTransaction() {
             for (let i = 0; i < this.transactions.length; i++) {

src/views/mobile/users/SessionList.vue

@@ -56,25 +56,14 @@ export default {
 
         self.loading = true;
 
-        self.$services.getTokens().then(response => {
+        self.$store.dispatch('getAllTokens').then(tokens => {
-            const data = response.data;
+            self.tokens = tokens;
-
-            if (!data || !data.success || !data.result) {
-                self.$toast('Unable to get session list');
-                router.back();
-                return;
-            }
-
-            self.tokens = data.result;
             self.loading = false;
         }).catch(error => {
-            self.$logger.error('failed to load token list', error);
+            self.loading = false;
 
-            if (error.response && error.response.data && error.response.data.errorMessage) {
+            if (!error.processed) {
-                self.$toast({ error: error.response.data });
+                self.$toast(error.message || error);
-                router.back();
-            } else if (!error.processed) {
-                self.$toast('Unable to get session list');
                 router.back();
             }
         });
@@ -83,26 +72,19 @@ export default {
         reload(done) {
             const self = this;
 
-            self.$services.getTokens().then(response => {
+            self.$store.dispatch('getAllTokens').then(tokens => {
-                done();
+                if (done) {
-
+                    done();
-                const data = response.data;
-
-                if (!data || !data.success || !data.result) {
-                    self.$toast('Unable to get session list');
-                    return;
                 }
 
-                self.tokens = data.result;
+                self.tokens = tokens;
             }).catch(error => {
-                self.$logger.error('failed to reload token list', error);
+                if (done) {
+                    done();
+                }
 
-                done();
+                if (!error.processed) {
-
+                    self.$toast(error.message || error);
-                if (error.response && error.response.data && error.response.data.errorMessage) {
-                    self.$toast({ error: error.response.data });
-                } else if (!error.processed) {
-                    self.$toast('Unable to get session list');
                 }
             });
         },
@@ -114,16 +96,10 @@ export default {
             self.$confirm('Are you sure you want to logout from this session?', () => {
                 self.$showLoading();
 
-                self.$services.revokeToken({
+                self.$store.dispatch('revokeToken', {
                     tokenId: token.tokenId
-                }).then(response => {
+                }).then(() => {
                     self.$hideLoading();
-                    const data = response.data;
-
-                    if (!data || !data.success || !data.result) {
-                        self.$toast('Unable to logout from this session');
-                        return;
-                    }
 
                     app.swipeout.delete($$(`#${self.$options.filters.tokenDomId(token)}`), () => {
                         for (let i = 0; i < self.tokens.length; i++) {
@@ -133,14 +109,10 @@ export default {
                         }
                     });
                 }).catch(error => {
-                    self.$logger.error('failed to revoke token', error);
-
                     self.$hideLoading();
 
-                    if (error.response && error.response.data && error.response.data.errorMessage) {
+                    if (!error.processed) {
-                        self.$toast({error: error.response.data});
+                        self.$toast(error.message || error);
-                    } else if (!error.processed) {
-                        self.$toast('Unable to logout from this session');
                     }
                 });
             });
@@ -155,14 +127,8 @@ export default {
             self.$confirm('Are you sure you want to logout all other sessions?', () => {
                 self.$showLoading();
 
-                self.$services.revokeAllTokens().then(response => {
+                self.$store.dispatch('revokeAllTokens').then(() => {
                     self.$hideLoading();
-                    const data = response.data;
-
-                    if (!data || !data.success || !data.result) {
-                        self.$toast('Unable to logout all other sessions');
-                        return;
-                    }
 
                     for (let i = self.tokens.length - 1; i >= 0; i--) {
                         if (!self.tokens[i].isCurrent) {
@@ -172,14 +138,10 @@ export default {
 
                     self.$toast('You have logged out all other sessions');
                 }).catch(error => {
-                    self.$logger.error('failed to revoke all tokens', error);
-
                     self.$hideLoading();
 
-                    if (error.response && error.response.data && error.response.data.errorMessage) {
+                    if (!error.processed) {
-                        self.$toast({error: error.response.data});
+                        self.$toast(error.message || error);
-                    } else if (!error.processed) {
-                        self.$toast('Unable to logout all other sessions');
                     }
                 });
             });

src/views/mobile/users/UserProfile.vue

@@ -158,31 +158,21 @@ export default {
 
         self.loading = true;
 
-        self.$services.getProfile().then(response => {
+        self.$store.dispatch('getCurrentUserProfile').then(profile => {
-            const data = response.data;
+            self.oldProfile.email = profile.email;
-
+            self.oldProfile.nickname = profile.nickname;
-            if (!data || !data.success || !data.result) {
+            self.oldProfile.defaultCurrency = profile.defaultCurrency;
-                self.$toast('Unable to get user profile');
-                router.back();
-                return;
-            }
-
-            self.oldProfile.email = data.result.email;
-            self.oldProfile.nickname = data.result.nickname;
-            self.oldProfile.defaultCurrency = data.result.defaultCurrency;
 
             self.newProfile.email = self.oldProfile.email
             self.newProfile.nickname = self.oldProfile.nickname;
             self.newProfile.defaultCurrency = self.oldProfile.defaultCurrency;
+
             self.loading = false;
         }).catch(error => {
-            self.$logger.error('failed to get user profile', error);
+            self.loading = false;
 
-            if (error.response && error.response.data && error.response.data.errorMessage) {
+            if (!error.processed) {
-                self.$toast({ error: error.response.data });
+                self.$toast(error.message || error);
-                router.back();
-            } else if (!error.processed) {
-                self.$toast('Unable to get user profile');
                 router.back();
             }
         });
@@ -209,45 +199,23 @@ export default {
             self.saving = true;
             self.$showLoading(() => self.saving);
 
-            self.$services.updateProfile({
+            self.$store.dispatch('updateUserProfile', {
-                password: self.newProfile.password,
+                profile: self.newProfile,
-                oldPassword: self.currentPassword,
+                currentPassword: self.currentPassword
-                email: self.newProfile.email,
+            }).then(() => {
-                nickname: self.newProfile.nickname,
-                defaultCurrency: self.newProfile.defaultCurrency
-            }).then(response => {
                 self.saving = false;
                 self.$hideLoading();
                 self.currentPassword = '';
 
-                const data = response.data;
-
-                if (!data || !data.success || !data.result) {
-                    self.$toast('Unable to update user profile');
-                    return;
-                }
-
-                if (self.$utilities.isString(data.result.newToken)) {
-                    self.$user.updateToken(data.result.newToken);
-                }
-
-                if (self.$utilities.isObject(data.result.user)) {
-                    self.$user.updateUserInfo(data.result.user);
-                }
-
                 self.$toast('Your profile has been successfully updated');
                 router.back();
             }).catch(error => {
-                self.$logger.error('failed to save user profile', error);
-
                 self.saving = false;
                 self.$hideLoading();
                 self.currentPassword = '';
 
-                if (error.response && error.response.data && error.response.data.errorMessage) {
+                if (!error.processed) {
-                    self.$toast({ error: error.response.data });
+                    self.$toast(error.message || error);
-                } else if (!error.processed) {
-                    self.$toast('Unable to update user profile');
                 }
             });
         }