@tapni/auth 1.0.23 → 1.0.25

package/src/store/auth.js

@@ -14,7 +14,7 @@ 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 { EventBus } from "@/store/event-bus.js";
 import router from '../router/index.js';
 export default {
   namespaced: true,
@@ -96,7 +96,7 @@ export default {
       state.$storex.refreshTokens = refreshTokens;
     },
     setRefreshToken(state, token) {
-      if(!token) return;
+      if (!token) return;
       let refreshTokens = state.$storex.refreshTokens ? state.$storex.refreshTokens.split(",") : [];
       refreshTokens = [token, ...refreshTokens.filter(t => t !== token)];
       state.$storex.refreshTokens = refreshTokens.join(",");
@@ -130,425 +130,425 @@ export default {
     },
   },
   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);
+    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');
         }
-      },
-      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);
-          }
+        // 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);
         }
-        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;
-          }
+        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);
+      }
+    },
+    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,
+      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,
-            localUser: response.data.data
+            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] });
-
-            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');
-          }
+      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] });
 
-          dispatch('loginSuccess', { ...response, isModal: data.isModal });
+        setTimeout(() => {
+          return location.reload();
+        }, 1500)
+      }
 
-          return true;
+      // 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');
         }
-      },
-      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");
-          }
 
-          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,
+        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,
           },
-        };
-        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 (state.$storex) {
-          state.$storex.username = '';
-          state.$storex.UserId = '';
-          state.$storex.localUser = '';
-          commit('setToken', '');
+        if (response.isModal) {
+          dispatch('successSnack', state.ssoLang[getters.appLanguage].success_login);
+          setTimeout(() => {
+            location.reload();
+          }, 1500);
         }
-        commit('setLoggedInUserId', '');
 
-        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);
+      if (state.$storex) {
+        state.$storex.username = '';
+        state.$storex.UserId = '';
+        state.$storex.localUser = '';
+        commit('setToken', '');
+      }
+      commit('setLoggedInUserId', '');
+
+      const remainingRefreshTokens = await dispatch('unsetRefreshToken', 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 loginUsingQR({ commit, dispatch }, data) {
+      }
+    },
+    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(
-          UserService.loginUsingQR(data)
+          AuthService.getLoggedInAccounts({ refreshTokens: getters.refreshTokens })
         );
         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 (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;
 
-          // Remove the specified refresh token from the list
-          refreshTokens = refreshTokens?.filter((t) => t !== refreshToken);
+      // 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(","));
+      // 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);
-      },
+      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 => {
@@ -556,7 +556,7 @@ export default {
     },
     renderView: (state, getters, rootState) => {
       if (state.display !== "npm") {
-          return rootState.route?.name;
+        return rootState.route?.name;
       } else return state.view;
     },
     appRealm: state => {
@@ -572,7 +572,7 @@ export default {
       return state.$storex.refreshTokens.split(',')
     },
     apiRoot: state => {
-        return state.apiRoot;
+      return state.apiRoot;
     }
   }
 };