@tapni/auth 1.0.4 → 1.0.6-3.dev

package/src/store/auth.js

@@ -1,574 +1,510 @@
-import to from "await-to-js";
-import UserService from "../services/UserService";
-import DeviceService from "../services/DeviceService";
-import AuthService from "../services/AuthService";
-import CompanyService from "../services/CompanyService";
-import { Device } from "@capacitor/device";
-import axios from "axios";
-import en from "../store/locales/en.js";
-import de from "../store/locales/de.js";
-import es from "../store/locales/es.js";
-import fr from "../store/locales/fr.js";
-import it from "../store/locales/it.js";
-import sr from "../store/locales/sr.js";
-import tr from "../store/locales/tr.js";
-import cn from "../store/locales/cn.js";
-import kr from "../store/locales/kr.js";
-import {EventBus} from "@/store/event-bus.js";
+import to from 'await-to-js';
+import UserService from '../services/UserService';
+import DeviceService from '../services/DeviceService';
+import AuthService from '../services/AuthService';
+import CompanyService from '../services/CompanyService';
+import { Device } from '@capacitor/device';
+import axios from 'axios';
+import en from '../store/locales/en.js';
+import de from '../store/locales/de.js';
+import es from '../store/locales/es.js';
+import fr from '../store/locales/fr.js';
+import it from '../store/locales/it.js';
+import sr from '../store/locales/sr.js';
+import tr from '../store/locales/tr.js';
+import cn from '../store/locales/cn.js';
+import kr from '../store/locales/kr.js';
+import ja from '../store/locales/ja.js';
+import pt from '../store/locales/pt.js';
+import { EventBus } from '@/store/event-bus.js';
 import router from '../router/index.js';
 export default {
-  namespaced: true,
-  state: {
-    $storex: {},
-    view: "",
-    lang: "en",
-    realm: "app",
-    refreshing: false,
-    loggedInUserId: "",
-    apiRoot: "",
-    account: {},
-    device: {},
-    loggedInAccounts: {},
-    ssoLang: {
-      en: en.state,
-      de: de.state,
-      es: es.state,
-      fr: fr.state,
-      it: it.state,
-      sr: sr.state,
-      tr: tr.state,
-      cn: cn.state,
-      kr: kr.state,
-    },
-    display: import.meta.env.VITE_APP_MODE,
-    redirect_uri: import.meta.env.VITE_APP_APP_ROOT + "/callback/auth",
-    response_type: "token",
-    state: "",
-    allowedOriginsAuth: [
-      "https://business.tapni.com",
-      "https://business-dev.tapni.com",
-      "https://tapni.com",
-      "https://tapni.co",
-      "https://t.link",
-      "https://my.tapni.com",
-      "https://my.tapni.co",
-      "https://dev.tapni.co",
-      "https://dev.tapni.com",
-      "https://auth.tapni.com",
-      "https://auth.tapni.co",
-      "https://mailsign.link",
-      "https://sign.tapni.com",
-      "https://qrcodetoolkit.com",
-      "https://qr.tapni.com",
-      "https://designer.tapni.com",
-      "https://designer-dev.tapni.com",
-      "http://localhost:8082",
-      "http://localhost:7777",
-      "http://localhost:8086",
-      "https://localhost:8085",
-      "http://localhost:8085"
-    ],
-  },
-  mutations: {
-    setAccountSettings(state, account) {
-      state.account = account;
-    },
-    setStorageItem(state, item) {
-      state.$storex[item.name] = item.data;
-    },
-    setStorage(state, storage) {
-      state.$storex = {
-        ...state.$storex,
-        ...storage
-      };
-    },
-    setLoggedInAccounts(state, accounts) {
-      state.loggedInAccounts = {};
-      accounts.forEach((account) => {
-        state.loggedInAccounts[account.username] = account;
-      });
-    },
-    setLoggedInUserId(state, id) {
-      state.loggedInUserId = id;
-    },
-    setRefreshTokens(state, refreshTokens) {
-      state.$storex.refreshTokens = refreshTokens;
-    },
-    setRefreshToken(state, token) {
-      if(!token) return;
-      let refreshTokens = state.$storex.refreshTokens ? state.$storex.refreshTokens.split(",") : [];
-      refreshTokens = [token, ...refreshTokens.filter(t => t !== token)];
-      state.$storex.refreshTokens = refreshTokens.join(",");
-    },
-    setToken(state, token) {
-      state.$storex.token = token;
-    },
-    updateLang(state, lang) {
-      state.lang = lang;
-    },
-    setView(state, view) {
-      state.view = view;
-    },
-    setRedirectUri(state, uri) {
-      state.redirect_uri = uri;
-    },
-    setDisplay(state, display) {
-      state.display = display;
-    },
-    setState(state, stateValue) {
-      state.state = stateValue;
-    },
-    setResponseType(state, responseType) {
-      state.response_type = responseType;
-    },
-    setRealm(state, realm) {
-      state.realm = realm;
-    },
-    setApiRoot(state, apiRoot) {
-      state.apiRoot = apiRoot;
-    },
-  },
-  actions: {
-      async getAccountSettings({ state, commit, dispatch }) {
-        const [err, response] = await to(
-            AuthService.getAccountSettings()
-        );
-        if (err) return dispatch('errorHandler', err);
-        if (response.data.success) {
-          commit('setAccountSettings', response.data.data);
-        }
-      },
-      setStorageItem({ commit }, item) {
-        commit('setStorageItem', item);
-      },
-      setStorage({ commit }, storage) {
-        commit('setStorage', storage);
-      },
-      errorHandler({ dispatch }, error) {
-        if (
-          error &&
-          error.response &&
-          error.response.data &&
-          error.response.data.error
-        ) {
-          if (error.response.data.error === "ACCESS_DENIED") {
-            return dispatch('logout');
-          }
+	namespaced: true,
+	state: {
+		$storex: {},
+		view: '',
+		lang: 'en',
+		realm: 'app',
+		refreshing: false,
+		loggedInUserId: '',
+		apiRoot: '',
+		account: {},
+		device: {},
+		loggedInAccounts: {},
+		ssoLang: {
+			en: en.state,
+			de: de.state,
+			es: es.state,
+			fr: fr.state,
+			it: it.state,
+			sr: sr.state,
+			tr: tr.state,
+			cn: cn.state,
+			kr: kr.state,
+			pt: pt.state,
+			ja: ja.state
+		},
+		display: import.meta.env.VITE_APP_MODE,
+		redirect_uri: import.meta.env.VITE_APP_APP_ROOT + '/app/callback/auth',
+		response_type: 'token',
+		state: '',
+		allowedOriginsAuth: ['https://business.tapni.com', 'https://business-dev.tapni.com', 'https://tapni.com', 'https://tapni.co', 'https://t.link', 'https://my.tapni.com', 'https://my.tapni.co', 'https://dev.tapni.co', 'https://dev.tapni.com', 'https://auth.tapni.com', 'https://auth.tapni.co', 'https://dev.mailsign.link', 'https://mailsign.link', 'https://sign.tapni.com', 'https://qrcodetoolkit.com', 'https://qr.tapni.com', 'https://designer.tapni.com', 'https://designer-dev.tapni.com', 'http://localhost:8080', 'https://localhost:8080', 'http://localhost:8081', 'http://localhost:7777', 'https://localhost:7777', 'http://localhost:8086', 'https://localhost:8085', 'http://localhost:8085', 'http://localhost', 'https://localhost', 'https://bigeye.tapni.com', 'https://bigeye-dev.tapni.com']
+	},
+	mutations: {
+		setAccountSettings(state, account) {
+			state.account = account;
+		},
+		setStorageItem(state, item) {
+			state.$storex[item.name] = item.data;
+		},
+		setStorage(state, storage) {
+			state.$storex = {
+				...state.$storex,
+				...storage
+			};
+		},
+		setLoggedInAccounts(state, accounts) {
+			state.loggedInAccounts = {};
+			accounts.forEach((account) => {
+				state.loggedInAccounts[account.username] = account;
+			});
+		},
+		setLoggedInUserId(state, id) {
+			state.loggedInUserId = id;
+		},
+		setRefreshTokens(state, refreshTokens) {
+			state.$storex.refreshTokens = refreshTokens;
+		},
+		setRefreshToken(state, token) {
+			if (!token) return;
+			let refreshTokens = state.$storex.refreshTokens ? state.$storex.refreshTokens.split(',') : [];
+			refreshTokens = [token, ...refreshTokens.filter((t) => t !== token)];
+			state.$storex.refreshTokens = refreshTokens.join(',');
+		},
+		setToken(state, token) {
+			state.$storex.token = token;
+		},
+		updateLang(state, lang) {
+			state.lang = lang;
+		},
+		setView(state, view) {
+			state.view = view;
+		},
+		setRedirectUri(state, uri) {
+			state.redirect_uri = uri;
+		},
+		setDisplay(state, display) {
+			state.display = display;
+		},
+		setState(state, stateValue) {
+			state.state = stateValue;
+		},
+		setResponseType(state, responseType) {
+			state.response_type = responseType;
+		},
+		setRealm(state, realm) {
+			state.realm = realm;
+		},
+		setApiRoot(state, apiRoot) {
+			state.apiRoot = apiRoot;
+		}
+	},
+	actions: {
+		async getAccountSettings({ state, commit, dispatch }) {
+			const [err, response] = await to(AuthService.getAccountSettings());
+			if (err) return dispatch('errorHandler', err);
+			if (response.data.success) {
+				commit('setAccountSettings', response.data.data);
+			}
+		},
+		setStorageItem({ commit }, item) {
+			commit('setStorageItem', item);
+		},
+		setStorage({ commit }, storage) {
+			commit('setStorage', storage);
+		},
+		errorHandler({ dispatch }, error) {
+			if (error && error.response && error.response.data && error.response.data.error) {
+				if (error.response.data.error === 'ACCESS_DENIED') {
+					return dispatch('logout');
+				}
 
-          if (error.response.data.error === 'OTP_REQUIRED') {
-            return EventBus.$emit('toggleOTPField', true);
-          }
+				if (error.response.data.error === 'OTP_REQUIRED') {
+					return EventBus.$emit('toggleOTPField', true);
+				}
 
-          // Link click network error bug fix
-          if (
-            !error.response.data.error.includes("Network Error") &&
-            !error.response.data.error.includes("TOKEN_EXPIRED") &&
-            !error.response.data.error.includes("Cannot read properties")
-          ) {
-            dispatch('errorSnack', error.response.data.error);
-          }
-        }
-        return error;
-      },
-      errorSnack({ commit }, message) {
-        let snackbar = document.getElementById("snackbar");
-        let errMessage = document.getElementById("errorMessage");
-        let errorSnack = document.getElementById("errorSnack");
-        errMessage.innerHTML = message;
-        snackbar.classList.add("show-snack");
-        errorSnack.classList.add("active-snack");
-        setTimeout(function () {
-          errorSnack.classList.remove("active-snack");
-          snackbar.classList.remove("show-snack");
-        }, 3000);
-      },
-      successSnack({ commit }, message) {
-        let snackbar = document.getElementById("snackbar");
-        let successMessage = document.getElementById("successMessage");
-        let successSnack = document.getElementById("successSnack");
-        successMessage.innerHTML = message;
-        snackbar.classList.add("show-snack");
-        successSnack.classList.add("active-snack");
-        setTimeout(function () {
-          successSnack.classList.remove("active-snack");
-          snackbar.classList.remove("show-snack");
-        }, 3000);
-      },
-      closeSnacks({ commit }) {
-        document.getElementById("snackbar").classList.remove("show-snack");
-        document.getElementById("successSnack").classList.remove("active-snack");
-        document.getElementById("errorSnack").classList.remove("active-snack");
-      },
-      async eventLog({ commit, dispatch }, data) {
-        const [err, response] = await to(
-          UserService.eventLog(data)
-        );
-        if (err) return dispatch('errorHandler', err);
-        return response;
-      },
-      async maintenance({ commit }) {
-        const [err, response] = await to(
-          axios.get("https://status.tapni.co/data/maintenance.json")
-        );
-        if (err) return console.error(err);
-        if (response) {
-          let maintenanceState = response.data;
-          if (typeof response.data === "string") {
-            maintenanceState = JSON.parse(response.data);
-          }
+				// Link click network error bug fix
+				if (!error.response.data.error.includes('Network Error') && !error.response.data.error.includes('TOKEN_EXPIRED') && !error.response.data.error.includes('Cannot read properties')) {
+					dispatch('errorSnack', error.response.data.error);
+				}
+			}
+			return error;
+		},
+		errorSnack({ commit }, message) {
+			let snackbar = document.getElementById('snackbar');
+			let errMessage = document.getElementById('errorMessage');
+			let errorSnack = document.getElementById('errorSnack');
+			errMessage.innerHTML = message;
+			snackbar.classList.add('show-snack');
+			errorSnack.classList.add('active-snack');
+			setTimeout(function () {
+				errorSnack.classList.remove('active-snack');
+				snackbar.classList.remove('show-snack');
+			}, 3000);
+		},
+		successSnack({ commit }, message) {
+			let snackbar = document.getElementById('snackbar');
+			let successMessage = document.getElementById('successMessage');
+			let successSnack = document.getElementById('successSnack');
+			successMessage.innerHTML = message;
+			snackbar.classList.add('show-snack');
+			successSnack.classList.add('active-snack');
+			setTimeout(function () {
+				successSnack.classList.remove('active-snack');
+				snackbar.classList.remove('show-snack');
+			}, 3000);
+		},
+		closeSnacks({ commit }) {
+			document.getElementById('snackbar').classList.remove('show-snack');
+			document.getElementById('successSnack').classList.remove('active-snack');
+			document.getElementById('errorSnack').classList.remove('active-snack');
+		},
+		async eventLog({ commit, dispatch }, data) {
+			const [err, response] = await to(UserService.eventLog(data));
+			if (err) return dispatch('errorHandler', err);
+			return response;
+		},
+		async maintenance({ commit }) {
+			const [err, response] = await to(axios.get('https://status.tapni.co/data/maintenance.json'));
+			if (err) return console.error(err);
+			if (response) {
+				let maintenanceState = response.data;
+				if (typeof response.data === 'string') {
+					maintenanceState = JSON.parse(response.data);
+				}
 
-          if (maintenanceState.api && maintenanceState.api.maintenanceActive) {
-            location.href =
-              "https://t.link/maintenance?msg=" + maintenanceState.api.msg;
-          }
-        }
-      },
-      async loginSetup({ commit, dispatch }, response) {
-        // Save Refresh Token
-        if (response.data.refreshToken) commit('setRefreshToken', response.data.refreshToken);
+				if (maintenanceState.api && maintenanceState.api.maintenanceActive) {
+					location.href = 'https://t.link/maintenance?msg=' + maintenanceState.api.msg;
+				}
+			}
+		},
+		async loginSetup({ commit, dispatch }, response) {
+			// Save Refresh Token
+			if (response.data.refreshToken) commit('setRefreshToken', response.data.refreshToken);
 
-        // Save Access Token
-        if (response.data.token) commit('setToken', response.data.token);
+			// Save Access Token
+			if (response.data.token) commit('setToken', response.data.token);
 
-        commit('setLoggedInUserId', response.data.data.id);
+			commit('setLoggedInUserId', response.data.data.id);
 
-        commit('setStorage', {
-            UserId: response.data.data.id,
-            username: response.data.data.username,
-            localUser: response.data.data
-        })
+			commit('setStorage', {
+				UserId: response.data.data.id,
+				username: response.data.data.username,
+				localUser: response.data.data
+			});
 
-        if (response.isModal === true) {
-          dispatch('setLoggedInAccounts', [
-            {
-              id: response.data.data.id,
-              username: response.data.data.username,
-              name: response.data.data.name,
-              refreshToken: response.data.refreshToken,
-              photo: response.data.data.photo,
-            },
-          ]);
-        }
-      },
-      async switchAccount({ commit, dispatch, state }, username) {
-        if (state.loggedInAccounts[username]) {
-          commit('setStorage', {
-            username: username,
-            UserId: state.loggedInAccounts[username].id,
-            localUser: state.loggedInAccounts[username]
-          })
-          commit('setLoggedInUserId', state.loggedInAccounts[username].id);
-          commit('setRefreshToken', state.loggedInAccounts[username].refreshToken);
-          await dispatch('refreshTokenAction', state.loggedInAccounts[username]);
-        }
-        EventBus.$emit("ssoEvent", { name: "switchAccount",  data: { username }, });
-      },
-      async refreshTokenAction({ dispatch, commit, state, getters }, data) {
-          if (state.refreshing) {
-            return null;
-          }
+			if (response.isModal === true) {
+				dispatch('setLoggedInAccounts', [
+					{
+						id: response.data.data.id,
+						username: response.data.data.username,
+						name: response.data.data.name,
+						refreshToken: response.data.refreshToken,
+						photo: response.data.data.photo
+					}
+				]);
+			}
+		},
+		async switchAccount({ commit, dispatch, state }, username) {
+			if (state.loggedInAccounts[username]) {
+				commit('setStorage', {
+					username: username,
+					UserId: state.loggedInAccounts[username].id,
+					localUser: state.loggedInAccounts[username]
+				});
+				commit('setLoggedInUserId', state.loggedInAccounts[username].id);
+				commit('setRefreshToken', state.loggedInAccounts[username].refreshToken);
+				await dispatch('refreshTokenAction', state.loggedInAccounts[username]);
+			}
+			EventBus.$emit('ssoEvent', { name: 'switchAccount', data: { username } });
+		},
+		async refreshTokenAction({ dispatch, commit, state, getters }, data) {
+			if (state.refreshing) {
+				return null;
+			}
 
-          state.refreshing = true;
-          const [err, response] = await to(
-              AuthService.refreshToken({
-                id: data.id,
-                refreshToken: getters.refreshTokens[0],
-                refreshTokenAction: true
-              })
-          );
-          if (err && err.response && err.response.data.error === "ACCESS_DENIED") {
-            dispatch('logout', { refreshToken: data.refreshToken, sendRequest: false });
-            return location.reload();
-          }
+			state.refreshing = true;
+			const [err, response] = await to(
+				AuthService.refreshToken({
+					id: data.id,
+					refreshToken: getters.refreshTokens[0],
+					refreshTokenAction: true
+				})
+			);
+			if (err && err.response && err.response.data.error === 'ACCESS_DENIED') {
+				dispatch('logout', { refreshToken: getters.refreshTokens[0] });
 
-          // Set new access token
-          if (response && response.data) {
-            commit('setToken', response.data.token);
-            EventBus.$emit("ssoEvent", { name: "setStorage", data: state.$storex });
-          }
-          state.refreshing = false;
-      },
-      async login({ commit, state, dispatch }, data) {
-        const [err, response] = await to(AuthService.login(data));
-        if (err) return dispatch('errorHandler', err);
-        if (response.data.success) {
-            if (state.display !== 'popup') {
-            dispatch('loginSetup', { ...response, isModal: data.isModal });
-            await dispatch('getLoggedInAccounts');
-          }
+				setTimeout(() => {
+					return location.reload();
+				}, 1500);
+			}
 
-          dispatch('loginSuccess', { ...response, isModal: data.isModal });
+			// Set new access token
+			if (response && response.data) {
+				commit('setToken', response.data.token);
+				EventBus.$emit('ssoEvent', { name: 'setStorage', data: state.$storex });
+			}
+			state.refreshing = false;
+		},
+		async login({ commit, state, dispatch }, data) {
+			const [err, response] = await to(AuthService.login(data));
 
-          return true;
-        }
-      },
-      loginSuccess({ commit, state, dispatch, getters }, response) {
-        if (state.display === "redirect") {
-          if (state.redirect_uri &&
-            !state.allowedOriginsAuth.some((domain) =>
-              state.redirect_uri.startsWith(domain)
-            )
-          ) {
-            return console.error("Redirect URI not allowed");
-          }
+			if (err) return dispatch('errorHandler', err);
+			if (response.data.success) {
+				if (state.display !== 'popup') {
+					dispatch('loginSetup', { ...response, isModal: data.isModal });
+					await dispatch('getLoggedInAccounts');
+				}
 
-          return router.push('/account');
+				dispatch('loginSuccess', { ...response, isModal: data.isModal });
 
-          location.href = state.redirect_uri +
-            "?code=" +
-            response.data.auth_code +
-            "&state=" +
-            state.state;
-        } else if (state.display === "popup") {
-          state.allowedOriginsAuth.forEach((domain) => {
-            window.parent?.postMessage(
-              { code: response.data.auth_code, state: state.state },
-              domain
-            );
-          });
-        } else if (state.display === 'npm') {
-          EventBus.$emit('ssoEvent', {name: 'setLoading', data: true})
-          EventBus.$emit("ssoEvent", { name: "setStorage", data: state.$storex });
-          EventBus.$emit("ssoEvent", { name: "getUser", data: {username: response.data.data.username} });
+				return true;
+			}
+		},
+		loginSuccess({ commit, state, dispatch, getters }, response) {
+			if (state.display === 'redirect') {
+				if (state.redirect_uri && !state.allowedOriginsAuth.some((domain) => state.redirect_uri.startsWith(domain))) {
+					return console.error('Redirect URI not allowed');
+				}
 
-          dispatch('setLoggedInAccounts', [
-            {
-              id: response.data.data.id,
-              username: response.data.data.username,
-              name: response.data.data.name,
-              refreshToken: response.data.refreshToken,
-              photo: response.data.data.photo,
-            },
-          ]);
+				return router.push('/account');
 
-          if (response.isModal) {
-            dispatch('successSnack', state.ssoLang[getters.appLanguage].success_login);
-            setTimeout(() => {
-              location.reload();
-            }, 1500);
-          }
+				location.href = state.redirect_uri + '?code=' + response.data.auth_code + '&state=' + state.state;
+			} else if (state.display === 'popup') {
+				state.allowedOriginsAuth.forEach((domain) => {
+					window.parent?.postMessage({ code: response.data.auth_code, state: state.state }, domain);
+				});
+			} else if (state.display === 'npm') {
+				EventBus.$emit('ssoEvent', { name: 'setLoading', data: true });
+				EventBus.$emit('ssoEvent', { name: 'setStorage', data: state.$storex });
+				EventBus.$emit('ssoEvent', { name: 'getUser', data: { username: response.data.data.username } });
 
-          EventBus.$emit("ssoEvent", { name: "redirect", data: "/" + response.data.data.username + "#edit" });
-        }
-      },
-      async register({ commit, dispatch }, data) {
-        const [err, response] = await to(
-          AuthService.register(data)
-        );
-        if (err) return dispatch('errorHandler', err);
-        return response;
-      },
-      async verify({ commit, dispatch }, data) {
-        const [err, response] = await to(AuthService.verify(data));
-        if (err) return dispatch('errorHandler', err);
-        return response;
-      },
-      async reset({ commit, state, getters, dispatch }, data) {
-        const [err, response] = await to(
-          AuthService.sendResetEmail(data)
-        );
-        if (err) return dispatch('errorHandler', err);
-        if (response.data.success) {
-          dispatch('successSnack', state.ssoLang[getters.appLanguage].password_reset_success);
-        }
-      },
-      async exchangeAuthCode({ commit, dispatch }, data) {
-        const [err, response] = await to(AuthService.exchangeAuthCode(data));
-        if (err) return dispatch('errorHandler', err);
-        await dispatch('loginSetup', response);
-        await dispatch('getLoggedInAccounts');
-        dispatch('loginSuccess', response);
-      },
-      async changePassword({ commit, dispatch }, data) {
-        const [err, response] = await to(
-          AuthService.changePassword(data)
-        );
-        if (err) return dispatch('errorHandler', err);
-        return response.data.success;
-      },
-      async newPassword({ commit, dispatch }, data) {
-        const [err, response] = await to(
-          UserService.newPassword(data)
-        );
-        if (err) return dispatch('errorHandler', err);
-        return response.data.success;
-      },
-      async deleteAccount({ commit, dispatch }, data) {
-        const [err, response] = await to(
-          UserService.deleteAccount(data)
-        );
-        if (err) return dispatch('errorHandler', err);
-        return response.data.success;
-      },
-      async registerDevice({ commit, dispatch }) {
-        const deviceID = await Device.getId();
-        const deviceInfo = await Device.getInfo();
-        let deviceData = {
-          device_id: deviceID.uuid,
-          platform: deviceInfo.platform,
-          device_info: {
-            model: deviceInfo.model,
-            manufacturer: deviceInfo.manufacturer,
-            operatingSystem: deviceInfo.operatingSystem,
-            osVersion: deviceInfo.osVersion,
-            isVirtual: deviceInfo.isVirtual,
-            webViewVersion: deviceInfo.webViewVersion,
-          },
-        };
-        const [err, response] = await to(
-          DeviceService.registerDevice(deviceData)
-        );
-        if (err) return dispatch('errorHandler', err);
-        return response;
-      },
-      async addFcmToken({ commit, dispatch }, data) {
-        const [err, response] = await to(
-          DeviceService.addFcmToken(data)
-        );
-        if (err) return dispatch('errorHandler', err);
-        return response;
-      },
-      async acceptCompanyInvitation({ commit, dispatch }, code) {
-        const [err, response] = await to(
-          CompanyService.acceptCompanyInvitation(code)
-        );
-        if (err) return dispatch('errorHandler', err);
-        return response;
-      },
-      async logout({ commit, dispatch, state }, { refreshToken, sendRequest = true }) {
-        if (sendRequest && refreshToken) {
-          AuthService.logout({ token: refreshToken });
-        }
+				dispatch('setLoggedInAccounts', [
+					{
+						id: response.data.data.id,
+						username: response.data.data.username,
+						name: response.data.data.name,
+						refreshToken: response.data.refreshToken,
+						photo: response.data.data.photo
+					}
+				]);
 
-        if (state.$storex) {
-          state.$storex.username = '';
-          state.$storex.UserId = '';
-          state.$storex.localUser = '';
-          commit('setToken', '');
-        }
-        commit('setLoggedInUserId', '');
+				if (response.isModal) {
+					dispatch('successSnack', state.ssoLang[getters.appLanguage].success_login);
+					setTimeout(() => {
+						location.reload();
+					}, 1500);
+				}
 
-        const remainingRefreshTokens = await dispatch('unsetRefreshToken', refreshToken);
+				EventBus.$emit('ssoEvent', { name: 'redirect', data: '/' + response.data.data.username + '#edit' });
+			}
+		},
+		async register({ commit, dispatch }, data) {
+			const [err, response] = await to(AuthService.register(data));
+			if (err) return dispatch('errorHandler', err);
+			return response;
+		},
+		async verify({ commit, dispatch }, data) {
+			const [err, response] = await to(AuthService.verify(data));
+			if (err) return dispatch('errorHandler', err);
+			return response;
+		},
+		async reset({ commit, state, getters, dispatch }, data) {
+			const [err, response] = await to(AuthService.sendResetEmail(data));
+			if (err) return dispatch('errorHandler', err);
+			if (response.data.success) {
+				dispatch('successSnack', state.ssoLang[getters.appLanguage].password_reset_success);
+			}
+		},
+		async exchangeAuthCode({ commit, dispatch }, data) {
+			const [err, response] = await to(AuthService.exchangeAuthCode(data));
+			if (err) return dispatch('errorHandler', err);
+			await dispatch('loginSetup', response);
+			await dispatch('getLoggedInAccounts');
+			dispatch('loginSuccess', response);
+		},
+		async changePassword({ commit, dispatch }, data) {
+			const [err, response] = await to(AuthService.changePassword(data));
+			if (err) return dispatch('errorHandler', err);
+			return response.data.success;
+		},
+		async newPassword({ commit, dispatch }, data) {
+			const [err, response] = await to(UserService.newPassword(data));
+			if (err) return dispatch('errorHandler', err);
+			return response.data.success;
+		},
+		async deleteAccount({ commit, dispatch }, data) {
+			const [err, response] = await to(UserService.deleteAccount(data));
+			if (err) return dispatch('errorHandler', err);
+			return response.data.success;
+		},
+		async registerDevice({ commit, dispatch }) {
+			const deviceID = await Device.getId();
+			const deviceInfo = await Device.getInfo();
+			let deviceData = {
+				device_id: deviceID.uuid,
+				platform: deviceInfo.platform,
+				device_info: {
+					model: deviceInfo.model,
+					manufacturer: deviceInfo.manufacturer,
+					operatingSystem: deviceInfo.operatingSystem,
+					osVersion: deviceInfo.osVersion,
+					isVirtual: deviceInfo.isVirtual,
+					webViewVersion: deviceInfo.webViewVersion
+				}
+			};
+			const [err, response] = await to(DeviceService.registerDevice(deviceData));
+			if (err) return dispatch('errorHandler', err);
+			return response;
+		},
+		async addFcmToken({ commit, dispatch }, data) {
+			const [err, response] = await to(DeviceService.addFcmToken(data));
+			if (err) return dispatch('errorHandler', err);
+			return response;
+		},
+		async acceptCompanyInvitation({ commit, dispatch }, code) {
+			const [err, response] = await to(CompanyService.acceptCompanyInvitation(code));
+			if (err) return dispatch('errorHandler', err);
+			return response;
+		},
+		async logout({ commit, dispatch, state }, { refreshToken, sendRequest = true }) {
+			if (sendRequest && refreshToken) {
+				AuthService.logout({ token: refreshToken });
+			}
 
-        if (remainingRefreshTokens.length >= 1) {
-          Object.keys(state.loggedInAccounts).forEach((username) => {
-            if (state.loggedInAccounts[username].refreshToken === remainingRefreshTokens[0]) {
-              commit('setStorage', {
-                username: username,
-                UserId: state.loggedInAccounts[username].id,
-                localUser: state.loggedInAccounts[username]
-              })
-              commit('setRefreshToken', remainingRefreshTokens[0]);
-              commit('setLoggedInUserId', state.loggedInAccounts[username].id);
-              dispatch('refreshTokenAction', state.loggedInAccounts[username]).then(() => {
-                  EventBus.$emit("ssoEvent", { name: "switchAccount",  data: { username }, });
-              });
-            }
-          });
-        } else {
-            if (state.display === "redirect") {
-                return router.push('/welcome');
-            } else if (state.display === "npm") {
-                EventBus.$emit("ssoEvent", { name: "redirect", data: "/welcome" });
-            }
-        }
-      },
-      async getCompanyBySSOEmail({ commit, dispatch }, data) {
-        const [err, response] = await to(
-          CompanyService.getBySSOEmail(data.email)
-        );
-        if (err) return dispatch('errorHandler', err);
-        if (response.data.success) {
-          return response.data;
-        }
-      },
-      async getLoggedInAccounts({ getters, dispatch }) {
-        if (getters.refreshTokens && getters.refreshTokens.length >= 1) {
-          const [err, response] = await to(
-              AuthService.getLoggedInAccounts({ refreshTokens: getters.refreshTokens })
-          );
-          if (err) return dispatch('errorHandler', err);
-          if (response && response.data && response.data.success) {
-              dispatch('setLoggedInAccounts', response.data.accounts);
-          }
-        }
-      },
-      async loginUsingQR({ commit, dispatch }, data) {
-        const [err, response] = await to(
-          UserService.loginUsingQR(data)
-        );
-        if (err) return dispatch('errorHandler', err);
-        return response.data.success;
-      },
-      setLoggedInAccounts({ commit }, accounts) {
-        commit('setLoggedInAccounts', accounts);
-        EventBus.$emit("ssoEvent", { name: "setLoggedInAccounts", data: accounts });
-      },
-      setLoggedInUserId({ commit }, id) {
-        commit('setLoggedInUserId', id);
-      },
-      setRefreshToken({ commit }, token) {
-        commit('setRefreshToken', token);
-      },
-      async unsetRefreshToken({ commit, state, dispatch, getters }, refreshToken) {
-          let refreshTokens = getters.refreshTokens;
+			if (state.$storex) {
+				state.$storex.username = '';
+				state.$storex.UserId = '';
+				state.$storex.localUser = '';
+				commit('setToken', '');
+			}
+			commit('setLoggedInUserId', '');
 
-          // Remove the specified refresh token from the list
-          refreshTokens = refreshTokens?.filter((t) => t !== refreshToken);
+			const remainingRefreshTokens = await dispatch('unsetRefreshToken', refreshToken);
 
-          // Update the refresh tokens in the state
-          commit('setRefreshTokens', refreshTokens.join(","));
+			if (remainingRefreshTokens.length >= 1) {
+				Object.keys(state.loggedInAccounts).forEach((username) => {
+					if (state.loggedInAccounts[username].refreshToken === remainingRefreshTokens[0]) {
+						commit('setStorage', {
+							username: username,
+							UserId: state.loggedInAccounts[username].id,
+							localUser: state.loggedInAccounts[username]
+						});
+						commit('setRefreshToken', remainingRefreshTokens[0]);
+						commit('setLoggedInUserId', state.loggedInAccounts[username].id);
+						dispatch('refreshTokenAction', state.loggedInAccounts[username]).then(() => {
+							EventBus.$emit('ssoEvent', { name: 'switchAccount', data: { username } });
+						});
+					}
+				});
+			} else {
+				if (state.display === 'redirect') {
+					return router.push('/welcome');
+				} else if (state.display === 'npm') {
+					EventBus.$emit('ssoEvent', { name: 'redirect', data: '/welcome' });
+				}
+			}
+		},
+		async getCompanyBySSOEmail({ commit, dispatch }, data) {
+			const [err, response] = await to(CompanyService.getBySSOEmail(data.email));
+			if (err) return dispatch('errorHandler', err);
+			if (response.data.success) {
+				return response.data;
+			}
+		},
+		async getLoggedInAccounts({ getters, dispatch }) {
+			if (getters.refreshTokens && getters.refreshTokens.length >= 1) {
+				const [err, response] = await to(AuthService.getLoggedInAccounts({ refreshTokens: getters.refreshTokens }));
+				if (err) return dispatch('errorHandler', err);
+				if (response && response.data && response.data.success) {
+					dispatch('setLoggedInAccounts', response.data.accounts);
+				}
+			}
+		},
+		async loginUsingQR({ commit, dispatch }, data) {
+			const [err, response] = await to(UserService.loginUsingQR(data));
+			if (err) return dispatch('errorHandler', err);
+			return response.data.success;
+		},
+		setLoggedInAccounts({ commit }, accounts) {
+			commit('setLoggedInAccounts', accounts);
+			EventBus.$emit('ssoEvent', { name: 'setLoggedInAccounts', data: accounts });
+		},
+		setLoggedInUserId({ commit }, id) {
+			commit('setLoggedInUserId', id);
+		},
+		setRefreshToken({ commit }, token) {
+			commit('setRefreshToken', token);
+		},
+		async unsetRefreshToken({ commit, state, dispatch, getters }, refreshToken) {
+			let refreshTokens = getters.refreshTokens;
 
-          return refreshTokens;
-      },
-      setToken({ commit }, token) {
-          commit('setToken', token);
-      },
-      updateLang({ commit }, lang) {
-          commit('updateLang', lang);
-      },
-      setView({ commit }, view) {
-        commit('setView', view);
-      },
-      setRedirectUri({ commit }, uri) {
-        commit('setRedirectUri', uri);
-      },
-      setDisplay({ commit }, display) {
-        commit('setDisplay', display);
-      },
-      setState({ commit }, stateValue) {
-        commit('setState', stateValue);
-      },
-      setResponseType({ commit }, responseType) {
-        commit('setResponseType', responseType);
-      },
-      setRealm({ commit }, realm) {
-        commit('setRealm', realm);
-      },
-  },
-  getters: {
-    isLoggedIn: state => {
-      return !!state.$storex.token && state.$storex.token !== "" && state.$storex.token !== "null";
-    },
-    renderView: (state, getters, rootState) => {
-      if (state.display !== "npm") {
-          return rootState.route?.name;
-      } else return state.view;
-    },
-    appRealm: state => {
-      return state.realm;
-    },
-    appLanguage: state => {
-      return state.lang;
-    },
-    accessToken: state => {
-      return state.$storex.token;
-    },
-    refreshTokens: state => {
-      return state.$storex.refreshTokens.split(',')
-    },
-    apiRoot: state => {
-        return state.apiRoot;
-    }
-  }
+			// Remove the specified refresh token from the list
+			refreshTokens = refreshTokens?.filter((t) => t !== refreshToken);
+
+			// Update the refresh tokens in the state
+			commit('setRefreshTokens', refreshTokens.join(','));
+
+			return refreshTokens;
+		},
+		setToken({ commit }, token) {
+			commit('setToken', token);
+		},
+		updateLang({ commit }, lang) {
+			commit('updateLang', lang);
+		},
+		setView({ commit }, view) {
+			commit('setView', view);
+		},
+		setRedirectUri({ commit }, uri) {
+			commit('setRedirectUri', uri);
+		},
+		setDisplay({ commit }, display) {
+			commit('setDisplay', display);
+		},
+		setState({ commit }, stateValue) {
+			commit('setState', stateValue);
+		},
+		setResponseType({ commit }, responseType) {
+			commit('setResponseType', responseType);
+		},
+		setRealm({ commit }, realm) {
+			commit('setRealm', realm);
+		}
+	},
+	getters: {
+		isLoggedIn: (state) => {
+			return !!state.$storex.token && state.$storex.token !== '' && state.$storex.token !== 'null';
+		},
+		renderView: (state, getters, rootState) => {
+			if (state.display !== 'npm') {
+				return rootState.route?.name;
+			} else return state.view;
+		},
+		appRealm: (state) => {
+			return state.realm;
+		},
+		appLanguage: (state) => {
+			return state.lang;
+		},
+		accessToken: (state) => {
+			return state.$storex.token;
+		},
+		refreshTokens: (state) => {
+			return state.$storex.refreshTokens.split(',');
+		},
+		apiRoot: (state) => {
+			return state.apiRoot;
+		}
+	}
 };