@tapni/auth 0.0.108 → 0.0.118

package/src/store/store.js

@@ -0,0 +1,563 @@
+import { createStore } from 'vuex'
+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 router from '../router/index.js';
+export default createStore({
+  state: {
+    $storex: {},
+    view: "AuthWelcome",
+    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: "",
+    allowedOrigins: [
+      "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",
+    ],
+  },
+  mutations: {
+    setAccountSettings(state, account) {
+      state.account = account;
+    },
+    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;
+    },
+    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(",");
+    },
+    unsetRefreshToken(state, refreshToken) {
+      state.$storex.refreshTokens = state.$storex.refreshTokens?.filter(t => t !== refreshToken).join(",");
+    },
+    setToken(state, token) {
+      state.$storex.token = token;
+    },
+    setUserID(state, userID) {
+      state.$storex.UserId = userID;
+    },
+    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);
+        }
+      },
+      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('toggleOTPModal', 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);
+          }
+
+          if (maintenanceState.api && maintenanceState.api.maintenanceActive) {
+            location.href =
+              "https://t.link/maintenance?msg=" + maintenanceState.api.msg;
+          }
+        }
+      },
+      async loginSetup({ commit }, 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);
+
+        commit('setLoggedInUserId', response.data.data.id);
+
+        commit('setStorage', {
+            UserId: response.data.data.id,
+            username: response.data.data.username,
+            localUser: response.data.data
+        })
+
+        if (response.isModal === true) {
+          commit('setLoggedInAccounts', [
+            {
+              id: response.data.data.id,
+              username: response.data.data.username,
+              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({ 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") {
+            commit('logout', { refreshToken: data.refreshToken, sendRequest: false });
+            return location.reload();
+          }
+
+          // Set new access token
+          if (response && response.data) {
+            commit('setToken', response.data.token);
+          }
+          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 === 'npm' || true) {
+            dispatch('loginSetup', { ...response, isModal: data.isModal });
+            await dispatch('getLoggedInAccounts');
+          }
+
+          dispatch('loginSuccess', { ...response, isModal: data.isModal });
+
+          return true;
+        }
+      },
+      loginSuccess({ commit, state, dispatch, getters }, response) {
+        if (state.display === "redirect") {
+          if (state.redirect_uri &&
+            !state.allowedOrigins.some((domain) =>
+              state.redirect_uri.startsWith(domain)
+            )
+          ) {
+            return console.error("Redirect URI not allowed");
+          }
+
+          return router.push('/account');
+
+          location.href = state.redirect_uri +
+            "?code=" +
+            response.data.auth_code +
+            "&state=" +
+            state.state;
+        } else if (state.display === "popup") {
+          state.allowedOrigins.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} });
+
+          commit('setLoggedInAccounts', [
+            {
+              id: response.data.data.id,
+              username: response.data.data.username,
+              refreshToken: response.data.refreshToken,
+              photo: response.data.data.photo,
+            },
+          ]);
+
+          if (response.isModal) {
+            dispatch('successSnack', state.ssoLang[getters.appLanguage].success_login);
+            setTimeout(() => {
+              location.reload();
+            }, 1500);
+          }
+        }
+      },
+      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 commit('loginSetup', response);
+        await commit('getLoggedInAccounts');
+        commit('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 (state.$storex) {
+          state.$storex.username = '';
+          state.$storex.UserId = '';
+          state.$storex.localUser = '';
+          commit('setToken', '');
+        }
+        commit('setLoggedInUserId', '');
+
+        const remainingRefreshTokens = commit('unsetRefreshToken', refreshToken);
+
+        if (remainingRefreshTokens.length >= 1) {
+          Object.keys(state.loggedInAccounts).forEach((username) => {
+            if (state.loggedInAccounts[username].refreshToken === remainingRefreshTokens[0]) {
+
+              dispatch('refreshTokenAction', state.loggedInAccounts[username]).then(() => {
+                commit('setLoggedInUserId', state.loggedInAccounts[username].id);
+                if (state.$storex) {
+                  state.$storex.username = username;
+                  state.$storex.UserId = state.loggedInAccounts[username].id;
+                }
+                dispatch('getLoggedInAccounts');
+              });
+            }
+          });
+        }
+      },
+      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({ commit, state, dispatch }, refreshTokens) {
+        if (!refreshTokens) refreshTokens = dispatch('getRefreshTokens');
+        if (refreshTokens && refreshTokens.length >= 1) {
+          const [err, response] = await to(
+              AuthService.getLoggedInAccounts({ refreshTokens })
+          );
+          if (err) return dispatch('errorHandler', err);
+          if (response && response.data && response.data.success) {
+            commit('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) {
+        let loggedInAccounts = {};
+        accounts.forEach((account) => {
+          loggedInAccounts[account.username] = account;
+        });
+        commit('setLoggedInAccounts', loggedInAccounts);
+      },
+      setLoggedInUserId({ commit }, id) {
+        commit('setLoggedInUserId', id);
+      },
+      getRefreshTokens({ state }) {
+        if (state.$storex && state.$storex.refreshTokens) return state.$storex.refreshTokens.split(',')
+        else return [];
+      },
+      setRefreshToken({ commit }, token) {
+        commit('setRefreshToken', token);
+      },
+      unsetRefreshToken({ commit, state, dispatch }, refreshToken) {
+          let refreshTokens = dispatch('getRefreshTokens');
+
+          // Remove the specified refresh token from the list
+          refreshTokens = refreshTokens?.filter((t) => t !== refreshToken);
+
+          // Update the refresh tokens in the state
+          commit('setRefreshToken', refreshTokens.join(","));
+      },
+      setToken({ commit }, token) {
+          commit('setToken', token);
+      },
+      setUserID({ commit }, userID) {
+          commit('setUserID', userID);
+      },
+      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 => {
+      if (state.display === "redirect") {
+        return false;
+      } 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 || process.env.VUE_APP_API_ROOT;
+    }
+  }
+})