@tapni/auth 1.0.56 → 1.0.58

package/src/store/auth.js

@@ -17,565 +17,490 @@ import kr from "../store/locales/kr.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 + "/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://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",
-      "https://localhost:7777",
-      "http://localhost:8086",
-      "https://localhost:8085",
-      "http://localhost:8085",
-      "capacitor://localhost",
-      "http://localhost",
-      "https://localhost",
-    ],
-  },
-  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
+		},
+		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://mailsign.link', 'https://sign.tapni.com', 'https://qrcodetoolkit.com', 'https://qr.tapni.com', 'https://designer.tapni.com', 'https://designer-dev.tapni.com', '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', 'capacitor://localhost']
+	},
+	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: getters.refreshTokens[0] });
+			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] });
 
-        setTimeout(() => {
-          return location.reload();
-        }, 1500)
-      }
+				setTimeout(() => {
+					return location.reload();
+				}, 1500);
+			}
 
-      // 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');
-        }
+			// 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));
 
-        dispatch('loginSuccess', { ...response, isModal: data.isModal });
+			if (err) return dispatch('errorHandler', err);
+			if (response.data.success) {
+				if (state.display !== 'popup') {
+					dispatch('loginSetup', { ...response, isModal: data.isModal });
+					await dispatch('getLoggedInAccounts');
+				}
 
-        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('loginSuccess', { ...response, isModal: data.isModal });
 
-        return router.push('/account');
+				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');
+				}
 
-        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 router.push('/account');
 
-        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,
-          },
-        ]);
+				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 } });
 
-        if (response.isModal) {
-          dispatch('successSnack', state.ssoLang[getters.appLanguage].success_login);
-          setTimeout(() => {
-            location.reload();
-          }, 1500);
-        }
+				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
+					}
+				]);
 
-        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 (response.isModal) {
+					dispatch('successSnack', state.ssoLang[getters.appLanguage].success_login);
+					setTimeout(() => {
+						location.reload();
+					}, 1500);
+				}
 
-      if (state.$storex) {
-        state.$storex.username = '';
-        state.$storex.UserId = '';
-        state.$storex.localUser = '';
-        commit('setToken', '');
-      }
-      commit('setLoggedInUserId', '');
+				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 });
+			}
 
-      const remainingRefreshTokens = await dispatch('unsetRefreshToken', refreshToken);
+			if (state.$storex) {
+				state.$storex.username = '';
+				state.$storex.UserId = '';
+				state.$storex.localUser = '';
+				commit('setToken', '');
+			}
+			commit('setLoggedInUserId', '');
 
-      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;
+			const remainingRefreshTokens = await dispatch('unsetRefreshToken', refreshToken);
 
-      // Remove the specified refresh token from the list
-      refreshTokens = refreshTokens?.filter((t) => t !== 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;
 
-      // Update the refresh tokens in the state
-      commit('setRefreshTokens', refreshTokens.join(","));
+			// Remove the specified refresh token from the list
+			refreshTokens = refreshTokens?.filter((t) => t !== refreshToken);
 
-      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;
-    }
-  }
+			// 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;
+		}
+	}
 };