@tapni/auth 1.0.56 → 1.0.59

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. package/dist/.vite/manifest.json +10 -10
  2. package/dist/{Apps-NKrqklKY.js → Apps-BgB6SKS2.js} +1 -1
  3. package/dist/{Billing-BUzKx9xh.js → Billing-CTH6Rjus.js} +1 -1
  4. package/dist/{CustomApp-BsHMfNck.js → CustomApp-CkmOXQEr.js} +1 -1
  5. package/dist/{QR-BrzkfUU3.js → QR-bIeEDwMm.js} +1 -1
  6. package/dist/TapniAuth.es.js +1 -1
  7. package/dist/TapniAuth.umd.js +3 -3
  8. package/dist/{install-DvMvXfuA.js → install-zR08RvXn.js} +35 -91
  9. package/dist/style.css +1 -1
  10. package/package.json +1 -1
  11. package/src/services/AuthService.js +7 -1
  12. package/src/store/auth.js +463 -538
  13. package/src/views/General.vue +1 -3
  14. package/src/views/Security.vue +2 -5
  15. package/src/views/Verify.vue +4 -4
package/src/store/auth.js CHANGED
@@ -17,565 +17,490 @@ import kr from "../store/locales/kr.js";
17
17
  import { EventBus } from "@/store/event-bus.js";
18
18
  import router from '../router/index.js';
19
19
  export default {
20
- namespaced: true,
21
- state: {
22
- $storex: {},
23
- view: "",
24
- lang: "en",
25
- realm: "app",
26
- refreshing: false,
27
- loggedInUserId: "",
28
- apiRoot: "",
29
- account: {},
30
- device: {},
31
- loggedInAccounts: {},
32
- ssoLang: {
33
- en: en.state,
34
- de: de.state,
35
- es: es.state,
36
- fr: fr.state,
37
- it: it.state,
38
- sr: sr.state,
39
- tr: tr.state,
40
- cn: cn.state,
41
- kr: kr.state,
42
- },
43
- display: import.meta.env.VITE_APP_MODE,
44
- redirect_uri: import.meta.env.VITE_APP_APP_ROOT + "/app/callback/auth",
45
- response_type: "token",
46
- state: "",
47
- allowedOriginsAuth: [
48
- "https://business.tapni.com",
49
- "https://business-dev.tapni.com",
50
- "https://tapni.com",
51
- "https://tapni.co",
52
- "https://t.link",
53
- "https://my.tapni.com",
54
- "https://my.tapni.co",
55
- "https://dev.tapni.co",
56
- "https://dev.tapni.com",
57
- "https://auth.tapni.com",
58
- "https://auth.tapni.co",
59
- "https://mailsign.link",
60
- "https://sign.tapni.com",
61
- "https://qrcodetoolkit.com",
62
- "https://qr.tapni.com",
63
- "https://designer.tapni.com",
64
- "https://designer-dev.tapni.com",
65
- "http://localhost:8082",
66
- "http://localhost:7777",
67
- "https://localhost:7777",
68
- "http://localhost:8086",
69
- "https://localhost:8085",
70
- "http://localhost:8085",
71
- "capacitor://localhost",
72
- "http://localhost",
73
- "https://localhost",
74
- ],
75
- },
76
- mutations: {
77
- setAccountSettings(state, account) {
78
- state.account = account;
79
- },
80
- setStorageItem(state, item) {
81
- state.$storex[item.name] = item.data;
82
- },
83
- setStorage(state, storage) {
84
- state.$storex = {
85
- ...state.$storex,
86
- ...storage
87
- };
88
- },
89
- setLoggedInAccounts(state, accounts) {
90
- state.loggedInAccounts = {};
91
- accounts.forEach((account) => {
92
- state.loggedInAccounts[account.username] = account;
93
- });
94
- },
95
- setLoggedInUserId(state, id) {
96
- state.loggedInUserId = id;
97
- },
98
- setRefreshTokens(state, refreshTokens) {
99
- state.$storex.refreshTokens = refreshTokens;
100
- },
101
- setRefreshToken(state, token) {
102
- if (!token) return;
103
- let refreshTokens = state.$storex.refreshTokens ? state.$storex.refreshTokens.split(",") : [];
104
- refreshTokens = [token, ...refreshTokens.filter(t => t !== token)];
105
- state.$storex.refreshTokens = refreshTokens.join(",");
106
- },
107
- setToken(state, token) {
108
- state.$storex.token = token;
109
- },
110
- updateLang(state, lang) {
111
- state.lang = lang;
112
- },
113
- setView(state, view) {
114
- state.view = view;
115
- },
116
- setRedirectUri(state, uri) {
117
- state.redirect_uri = uri;
118
- },
119
- setDisplay(state, display) {
120
- state.display = display;
121
- },
122
- setState(state, stateValue) {
123
- state.state = stateValue;
124
- },
125
- setResponseType(state, responseType) {
126
- state.response_type = responseType;
127
- },
128
- setRealm(state, realm) {
129
- state.realm = realm;
130
- },
131
- setApiRoot(state, apiRoot) {
132
- state.apiRoot = apiRoot;
133
- },
134
- },
135
- actions: {
136
- async getAccountSettings({ state, commit, dispatch }) {
137
- const [err, response] = await to(
138
- AuthService.getAccountSettings()
139
- );
140
- if (err) return dispatch('errorHandler', err);
141
- if (response.data.success) {
142
- commit('setAccountSettings', response.data.data);
143
- }
144
- },
145
- setStorageItem({ commit }, item) {
146
- commit('setStorageItem', item);
147
- },
148
- setStorage({ commit }, storage) {
149
- commit('setStorage', storage);
150
- },
151
- errorHandler({ dispatch }, error) {
152
- if (
153
- error &&
154
- error.response &&
155
- error.response.data &&
156
- error.response.data.error
157
- ) {
158
- if (error.response.data.error === "ACCESS_DENIED") {
159
- return dispatch('logout');
160
- }
20
+ namespaced: true,
21
+ state: {
22
+ $storex: {},
23
+ view: '',
24
+ lang: 'en',
25
+ realm: 'app',
26
+ refreshing: false,
27
+ loggedInUserId: '',
28
+ apiRoot: '',
29
+ account: {},
30
+ device: {},
31
+ loggedInAccounts: {},
32
+ ssoLang: {
33
+ en: en.state,
34
+ de: de.state,
35
+ es: es.state,
36
+ fr: fr.state,
37
+ it: it.state,
38
+ sr: sr.state,
39
+ tr: tr.state,
40
+ cn: cn.state,
41
+ kr: kr.state
42
+ },
43
+ display: import.meta.env.VITE_APP_MODE,
44
+ redirect_uri: import.meta.env.VITE_APP_APP_ROOT + '/app/callback/auth',
45
+ response_type: 'token',
46
+ state: '',
47
+ 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']
48
+ },
49
+ mutations: {
50
+ setAccountSettings(state, account) {
51
+ state.account = account;
52
+ },
53
+ setStorageItem(state, item) {
54
+ state.$storex[item.name] = item.data;
55
+ },
56
+ setStorage(state, storage) {
57
+ state.$storex = {
58
+ ...state.$storex,
59
+ ...storage
60
+ };
61
+ },
62
+ setLoggedInAccounts(state, accounts) {
63
+ state.loggedInAccounts = {};
64
+ accounts.forEach((account) => {
65
+ state.loggedInAccounts[account.username] = account;
66
+ });
67
+ },
68
+ setLoggedInUserId(state, id) {
69
+ state.loggedInUserId = id;
70
+ },
71
+ setRefreshTokens(state, refreshTokens) {
72
+ state.$storex.refreshTokens = refreshTokens;
73
+ },
74
+ setRefreshToken(state, token) {
75
+ if (!token) return;
76
+ let refreshTokens = state.$storex.refreshTokens ? state.$storex.refreshTokens.split(',') : [];
77
+ refreshTokens = [token, ...refreshTokens.filter((t) => t !== token)];
78
+ state.$storex.refreshTokens = refreshTokens.join(',');
79
+ },
80
+ setToken(state, token) {
81
+ state.$storex.token = token;
82
+ },
83
+ updateLang(state, lang) {
84
+ state.lang = lang;
85
+ },
86
+ setView(state, view) {
87
+ state.view = view;
88
+ },
89
+ setRedirectUri(state, uri) {
90
+ state.redirect_uri = uri;
91
+ },
92
+ setDisplay(state, display) {
93
+ state.display = display;
94
+ },
95
+ setState(state, stateValue) {
96
+ state.state = stateValue;
97
+ },
98
+ setResponseType(state, responseType) {
99
+ state.response_type = responseType;
100
+ },
101
+ setRealm(state, realm) {
102
+ state.realm = realm;
103
+ },
104
+ setApiRoot(state, apiRoot) {
105
+ state.apiRoot = apiRoot;
106
+ }
107
+ },
108
+ actions: {
109
+ async getAccountSettings({ state, commit, dispatch }) {
110
+ const [err, response] = await to(AuthService.getAccountSettings());
111
+ if (err) return dispatch('errorHandler', err);
112
+ if (response.data.success) {
113
+ commit('setAccountSettings', response.data.data);
114
+ }
115
+ },
116
+ setStorageItem({ commit }, item) {
117
+ commit('setStorageItem', item);
118
+ },
119
+ setStorage({ commit }, storage) {
120
+ commit('setStorage', storage);
121
+ },
122
+ errorHandler({ dispatch }, error) {
123
+ if (error && error.response && error.response.data && error.response.data.error) {
124
+ if (error.response.data.error === 'ACCESS_DENIED') {
125
+ return dispatch('logout');
126
+ }
161
127
 
162
- if (error.response.data.error === 'OTP_REQUIRED') {
163
- return EventBus.$emit('toggleOTPField', true);
164
- }
128
+ if (error.response.data.error === 'OTP_REQUIRED') {
129
+ return EventBus.$emit('toggleOTPField', true);
130
+ }
165
131
 
166
- // Link click network error bug fix
167
- if (
168
- !error.response.data.error.includes("Network Error") &&
169
- !error.response.data.error.includes("TOKEN_EXPIRED") &&
170
- !error.response.data.error.includes("Cannot read properties")
171
- ) {
172
- dispatch('errorSnack', error.response.data.error);
173
- }
174
- }
175
- return error;
176
- },
177
- errorSnack({ commit }, message) {
178
- let snackbar = document.getElementById("snackbar");
179
- let errMessage = document.getElementById("errorMessage");
180
- let errorSnack = document.getElementById("errorSnack");
181
- errMessage.innerHTML = message;
182
- snackbar.classList.add("show-snack");
183
- errorSnack.classList.add("active-snack");
184
- setTimeout(function () {
185
- errorSnack.classList.remove("active-snack");
186
- snackbar.classList.remove("show-snack");
187
- }, 3000);
188
- },
189
- successSnack({ commit }, message) {
190
- let snackbar = document.getElementById("snackbar");
191
- let successMessage = document.getElementById("successMessage");
192
- let successSnack = document.getElementById("successSnack");
193
- successMessage.innerHTML = message;
194
- snackbar.classList.add("show-snack");
195
- successSnack.classList.add("active-snack");
196
- setTimeout(function () {
197
- successSnack.classList.remove("active-snack");
198
- snackbar.classList.remove("show-snack");
199
- }, 3000);
200
- },
201
- closeSnacks({ commit }) {
202
- document.getElementById("snackbar").classList.remove("show-snack");
203
- document.getElementById("successSnack").classList.remove("active-snack");
204
- document.getElementById("errorSnack").classList.remove("active-snack");
205
- },
206
- async eventLog({ commit, dispatch }, data) {
207
- const [err, response] = await to(
208
- UserService.eventLog(data)
209
- );
210
- if (err) return dispatch('errorHandler', err);
211
- return response;
212
- },
213
- async maintenance({ commit }) {
214
- const [err, response] = await to(
215
- axios.get("https://status.tapni.co/data/maintenance.json")
216
- );
217
- if (err) return console.error(err);
218
- if (response) {
219
- let maintenanceState = response.data;
220
- if (typeof response.data === "string") {
221
- maintenanceState = JSON.parse(response.data);
222
- }
132
+ // Link click network error bug fix
133
+ if (!error.response.data.error.includes('Network Error') && !error.response.data.error.includes('TOKEN_EXPIRED') && !error.response.data.error.includes('Cannot read properties')) {
134
+ dispatch('errorSnack', error.response.data.error);
135
+ }
136
+ }
137
+ return error;
138
+ },
139
+ errorSnack({ commit }, message) {
140
+ let snackbar = document.getElementById('snackbar');
141
+ let errMessage = document.getElementById('errorMessage');
142
+ let errorSnack = document.getElementById('errorSnack');
143
+ errMessage.innerHTML = message;
144
+ snackbar.classList.add('show-snack');
145
+ errorSnack.classList.add('active-snack');
146
+ setTimeout(function () {
147
+ errorSnack.classList.remove('active-snack');
148
+ snackbar.classList.remove('show-snack');
149
+ }, 3000);
150
+ },
151
+ successSnack({ commit }, message) {
152
+ let snackbar = document.getElementById('snackbar');
153
+ let successMessage = document.getElementById('successMessage');
154
+ let successSnack = document.getElementById('successSnack');
155
+ successMessage.innerHTML = message;
156
+ snackbar.classList.add('show-snack');
157
+ successSnack.classList.add('active-snack');
158
+ setTimeout(function () {
159
+ successSnack.classList.remove('active-snack');
160
+ snackbar.classList.remove('show-snack');
161
+ }, 3000);
162
+ },
163
+ closeSnacks({ commit }) {
164
+ document.getElementById('snackbar').classList.remove('show-snack');
165
+ document.getElementById('successSnack').classList.remove('active-snack');
166
+ document.getElementById('errorSnack').classList.remove('active-snack');
167
+ },
168
+ async eventLog({ commit, dispatch }, data) {
169
+ const [err, response] = await to(UserService.eventLog(data));
170
+ if (err) return dispatch('errorHandler', err);
171
+ return response;
172
+ },
173
+ async maintenance({ commit }) {
174
+ const [err, response] = await to(axios.get('https://status.tapni.co/data/maintenance.json'));
175
+ if (err) return console.error(err);
176
+ if (response) {
177
+ let maintenanceState = response.data;
178
+ if (typeof response.data === 'string') {
179
+ maintenanceState = JSON.parse(response.data);
180
+ }
223
181
 
224
- if (maintenanceState.api && maintenanceState.api.maintenanceActive) {
225
- location.href =
226
- "https://t.link/maintenance?msg=" + maintenanceState.api.msg;
227
- }
228
- }
229
- },
230
- async loginSetup({ commit, dispatch }, response) {
231
- // Save Refresh Token
232
- if (response.data.refreshToken) commit('setRefreshToken', response.data.refreshToken);
182
+ if (maintenanceState.api && maintenanceState.api.maintenanceActive) {
183
+ location.href = 'https://t.link/maintenance?msg=' + maintenanceState.api.msg;
184
+ }
185
+ }
186
+ },
187
+ async loginSetup({ commit, dispatch }, response) {
188
+ // Save Refresh Token
189
+ if (response.data.refreshToken) commit('setRefreshToken', response.data.refreshToken);
233
190
 
234
- // Save Access Token
235
- if (response.data.token) commit('setToken', response.data.token);
191
+ // Save Access Token
192
+ if (response.data.token) commit('setToken', response.data.token);
236
193
 
237
- commit('setLoggedInUserId', response.data.data.id);
194
+ commit('setLoggedInUserId', response.data.data.id);
238
195
 
239
- commit('setStorage', {
240
- UserId: response.data.data.id,
241
- username: response.data.data.username,
242
- localUser: response.data.data
243
- })
196
+ commit('setStorage', {
197
+ UserId: response.data.data.id,
198
+ username: response.data.data.username,
199
+ localUser: response.data.data
200
+ });
244
201
 
245
- if (response.isModal === true) {
246
- dispatch('setLoggedInAccounts', [
247
- {
248
- id: response.data.data.id,
249
- username: response.data.data.username,
250
- name: response.data.data.name,
251
- refreshToken: response.data.refreshToken,
252
- photo: response.data.data.photo,
253
- },
254
- ]);
255
- }
256
- },
257
- async switchAccount({ commit, dispatch, state }, username) {
258
- if (state.loggedInAccounts[username]) {
259
- commit('setStorage', {
260
- username: username,
261
- UserId: state.loggedInAccounts[username].id,
262
- localUser: state.loggedInAccounts[username]
263
- })
264
- commit('setLoggedInUserId', state.loggedInAccounts[username].id);
265
- commit('setRefreshToken', state.loggedInAccounts[username].refreshToken);
266
- await dispatch('refreshTokenAction', state.loggedInAccounts[username]);
267
- }
268
- EventBus.$emit("ssoEvent", { name: "switchAccount", data: { username }, });
269
- },
270
- async refreshTokenAction({ dispatch, commit, state, getters }, data) {
271
- if (state.refreshing) {
272
- return null;
273
- }
202
+ if (response.isModal === true) {
203
+ dispatch('setLoggedInAccounts', [
204
+ {
205
+ id: response.data.data.id,
206
+ username: response.data.data.username,
207
+ name: response.data.data.name,
208
+ refreshToken: response.data.refreshToken,
209
+ photo: response.data.data.photo
210
+ }
211
+ ]);
212
+ }
213
+ },
214
+ async switchAccount({ commit, dispatch, state }, username) {
215
+ if (state.loggedInAccounts[username]) {
216
+ commit('setStorage', {
217
+ username: username,
218
+ UserId: state.loggedInAccounts[username].id,
219
+ localUser: state.loggedInAccounts[username]
220
+ });
221
+ commit('setLoggedInUserId', state.loggedInAccounts[username].id);
222
+ commit('setRefreshToken', state.loggedInAccounts[username].refreshToken);
223
+ await dispatch('refreshTokenAction', state.loggedInAccounts[username]);
224
+ }
225
+ EventBus.$emit('ssoEvent', { name: 'switchAccount', data: { username } });
226
+ },
227
+ async refreshTokenAction({ dispatch, commit, state, getters }, data) {
228
+ if (state.refreshing) {
229
+ return null;
230
+ }
274
231
 
275
- state.refreshing = true;
276
- const [err, response] = await to(
277
- AuthService.refreshToken({
278
- id: data.id,
279
- refreshToken: getters.refreshTokens[0],
280
- refreshTokenAction: true
281
- })
282
- );
283
- if (err && err.response && err.response.data.error === "ACCESS_DENIED") {
284
- dispatch('logout', { refreshToken: getters.refreshTokens[0] });
232
+ state.refreshing = true;
233
+ const [err, response] = await to(
234
+ AuthService.refreshToken({
235
+ id: data.id,
236
+ refreshToken: getters.refreshTokens[0],
237
+ refreshTokenAction: true
238
+ })
239
+ );
240
+ if (err && err.response && err.response.data.error === 'ACCESS_DENIED') {
241
+ dispatch('logout', { refreshToken: getters.refreshTokens[0] });
285
242
 
286
- setTimeout(() => {
287
- return location.reload();
288
- }, 1500)
289
- }
243
+ setTimeout(() => {
244
+ return location.reload();
245
+ }, 1500);
246
+ }
290
247
 
291
- // Set new access token
292
- if (response && response.data) {
293
- commit('setToken', response.data.token);
294
- EventBus.$emit("ssoEvent", { name: "setStorage", data: state.$storex });
295
- }
296
- state.refreshing = false;
297
- },
298
- async login({ commit, state, dispatch }, data) {
299
- const [err, response] = await to(AuthService.login(data));
300
- if (err) return dispatch('errorHandler', err);
301
- if (response.data.success) {
302
- if (state.display !== 'popup') {
303
- dispatch('loginSetup', { ...response, isModal: data.isModal });
304
- await dispatch('getLoggedInAccounts');
305
- }
248
+ // Set new access token
249
+ if (response && response.data) {
250
+ commit('setToken', response.data.token);
251
+ EventBus.$emit('ssoEvent', { name: 'setStorage', data: state.$storex });
252
+ }
253
+ state.refreshing = false;
254
+ },
255
+ async login({ commit, state, dispatch }, data) {
256
+ const [err, response] = await to(AuthService.login(data));
306
257
 
307
- dispatch('loginSuccess', { ...response, isModal: data.isModal });
258
+ if (err) return dispatch('errorHandler', err);
259
+ if (response.data.success) {
260
+ if (state.display !== 'popup') {
261
+ dispatch('loginSetup', { ...response, isModal: data.isModal });
262
+ await dispatch('getLoggedInAccounts');
263
+ }
308
264
 
309
- return true;
310
- }
311
- },
312
- loginSuccess({ commit, state, dispatch, getters }, response) {
313
- if (state.display === "redirect") {
314
- if (state.redirect_uri &&
315
- !state.allowedOriginsAuth.some((domain) =>
316
- state.redirect_uri.startsWith(domain)
317
- )
318
- ) {
319
- return console.error("Redirect URI not allowed");
320
- }
265
+ dispatch('loginSuccess', { ...response, isModal: data.isModal });
321
266
 
322
- return router.push('/account');
267
+ return true;
268
+ }
269
+ },
270
+ loginSuccess({ commit, state, dispatch, getters }, response) {
271
+ if (state.display === 'redirect') {
272
+ if (state.redirect_uri && !state.allowedOriginsAuth.some((domain) => state.redirect_uri.startsWith(domain))) {
273
+ return console.error('Redirect URI not allowed');
274
+ }
323
275
 
324
- location.href = state.redirect_uri +
325
- "?code=" +
326
- response.data.auth_code +
327
- "&state=" +
328
- state.state;
329
- } else if (state.display === "popup") {
330
- state.allowedOriginsAuth.forEach((domain) => {
331
- window.parent?.postMessage(
332
- { code: response.data.auth_code, state: state.state },
333
- domain
334
- );
335
- });
336
- } else if (state.display === 'npm') {
337
- EventBus.$emit('ssoEvent', { name: 'setLoading', data: true })
338
- EventBus.$emit("ssoEvent", { name: "setStorage", data: state.$storex });
339
- EventBus.$emit("ssoEvent", { name: "getUser", data: { username: response.data.data.username } });
276
+ return router.push('/account');
340
277
 
341
- dispatch('setLoggedInAccounts', [
342
- {
343
- id: response.data.data.id,
344
- username: response.data.data.username,
345
- name: response.data.data.name,
346
- refreshToken: response.data.refreshToken,
347
- photo: response.data.data.photo,
348
- },
349
- ]);
278
+ location.href = state.redirect_uri + '?code=' + response.data.auth_code + '&state=' + state.state;
279
+ } else if (state.display === 'popup') {
280
+ state.allowedOriginsAuth.forEach((domain) => {
281
+ window.parent?.postMessage({ code: response.data.auth_code, state: state.state }, domain);
282
+ });
283
+ } else if (state.display === 'npm') {
284
+ EventBus.$emit('ssoEvent', { name: 'setLoading', data: true });
285
+ EventBus.$emit('ssoEvent', { name: 'setStorage', data: state.$storex });
286
+ EventBus.$emit('ssoEvent', { name: 'getUser', data: { username: response.data.data.username } });
350
287
 
351
- if (response.isModal) {
352
- dispatch('successSnack', state.ssoLang[getters.appLanguage].success_login);
353
- setTimeout(() => {
354
- location.reload();
355
- }, 1500);
356
- }
288
+ dispatch('setLoggedInAccounts', [
289
+ {
290
+ id: response.data.data.id,
291
+ username: response.data.data.username,
292
+ name: response.data.data.name,
293
+ refreshToken: response.data.refreshToken,
294
+ photo: response.data.data.photo
295
+ }
296
+ ]);
357
297
 
358
- EventBus.$emit("ssoEvent", { name: "redirect", data: "/" + response.data.data.username + "#edit" });
359
- }
360
- },
361
- async register({ commit, dispatch }, data) {
362
- const [err, response] = await to(
363
- AuthService.register(data)
364
- );
365
- if (err) return dispatch('errorHandler', err);
366
- return response;
367
- },
368
- async verify({ commit, dispatch }, data) {
369
- const [err, response] = await to(AuthService.verify(data));
370
- if (err) return dispatch('errorHandler', err);
371
- return response;
372
- },
373
- async reset({ commit, state, getters, dispatch }, data) {
374
- const [err, response] = await to(
375
- AuthService.sendResetEmail(data)
376
- );
377
- if (err) return dispatch('errorHandler', err);
378
- if (response.data.success) {
379
- dispatch('successSnack', state.ssoLang[getters.appLanguage].password_reset_success);
380
- }
381
- },
382
- async exchangeAuthCode({ commit, dispatch }, data) {
383
- const [err, response] = await to(AuthService.exchangeAuthCode(data));
384
- if (err) return dispatch('errorHandler', err);
385
- await dispatch('loginSetup', response);
386
- await dispatch('getLoggedInAccounts');
387
- dispatch('loginSuccess', response);
388
- },
389
- async changePassword({ commit, dispatch }, data) {
390
- const [err, response] = await to(
391
- AuthService.changePassword(data)
392
- );
393
- if (err) return dispatch('errorHandler', err);
394
- return response.data.success;
395
- },
396
- async newPassword({ commit, dispatch }, data) {
397
- const [err, response] = await to(
398
- UserService.newPassword(data)
399
- );
400
- if (err) return dispatch('errorHandler', err);
401
- return response.data.success;
402
- },
403
- async deleteAccount({ commit, dispatch }, data) {
404
- const [err, response] = await to(
405
- UserService.deleteAccount(data)
406
- );
407
- if (err) return dispatch('errorHandler', err);
408
- return response.data.success;
409
- },
410
- async registerDevice({ commit, dispatch }) {
411
- const deviceID = await Device.getId();
412
- const deviceInfo = await Device.getInfo();
413
- let deviceData = {
414
- device_id: deviceID.uuid,
415
- platform: deviceInfo.platform,
416
- device_info: {
417
- model: deviceInfo.model,
418
- manufacturer: deviceInfo.manufacturer,
419
- operatingSystem: deviceInfo.operatingSystem,
420
- osVersion: deviceInfo.osVersion,
421
- isVirtual: deviceInfo.isVirtual,
422
- webViewVersion: deviceInfo.webViewVersion,
423
- },
424
- };
425
- const [err, response] = await to(
426
- DeviceService.registerDevice(deviceData)
427
- );
428
- if (err) return dispatch('errorHandler', err);
429
- return response;
430
- },
431
- async addFcmToken({ commit, dispatch }, data) {
432
- const [err, response] = await to(
433
- DeviceService.addFcmToken(data)
434
- );
435
- if (err) return dispatch('errorHandler', err);
436
- return response;
437
- },
438
- async acceptCompanyInvitation({ commit, dispatch }, code) {
439
- const [err, response] = await to(
440
- CompanyService.acceptCompanyInvitation(code)
441
- );
442
- if (err) return dispatch('errorHandler', err);
443
- return response;
444
- },
445
- async logout({ commit, dispatch, state }, { refreshToken, sendRequest = true }) {
446
- if (sendRequest && refreshToken) {
447
- AuthService.logout({ token: refreshToken });
448
- }
298
+ if (response.isModal) {
299
+ dispatch('successSnack', state.ssoLang[getters.appLanguage].success_login);
300
+ setTimeout(() => {
301
+ location.reload();
302
+ }, 1500);
303
+ }
449
304
 
450
- if (state.$storex) {
451
- state.$storex.username = '';
452
- state.$storex.UserId = '';
453
- state.$storex.localUser = '';
454
- commit('setToken', '');
455
- }
456
- commit('setLoggedInUserId', '');
305
+ EventBus.$emit('ssoEvent', { name: 'redirect', data: '/' + response.data.data.username + '#edit' });
306
+ }
307
+ },
308
+ async register({ commit, dispatch }, data) {
309
+ const [err, response] = await to(AuthService.register(data));
310
+ if (err) return dispatch('errorHandler', err);
311
+ return response;
312
+ },
313
+ async verify({ commit, dispatch }, data) {
314
+ const [err, response] = await to(AuthService.verify(data));
315
+ if (err) return dispatch('errorHandler', err);
316
+ return response;
317
+ },
318
+ async reset({ commit, state, getters, dispatch }, data) {
319
+ const [err, response] = await to(AuthService.sendResetEmail(data));
320
+ if (err) return dispatch('errorHandler', err);
321
+ if (response.data.success) {
322
+ dispatch('successSnack', state.ssoLang[getters.appLanguage].password_reset_success);
323
+ }
324
+ },
325
+ async exchangeAuthCode({ commit, dispatch }, data) {
326
+ const [err, response] = await to(AuthService.exchangeAuthCode(data));
327
+ if (err) return dispatch('errorHandler', err);
328
+ await dispatch('loginSetup', response);
329
+ await dispatch('getLoggedInAccounts');
330
+ dispatch('loginSuccess', response);
331
+ },
332
+ async changePassword({ commit, dispatch }, data) {
333
+ const [err, response] = await to(AuthService.changePassword(data));
334
+ if (err) return dispatch('errorHandler', err);
335
+ return response.data.success;
336
+ },
337
+ async newPassword({ commit, dispatch }, data) {
338
+ const [err, response] = await to(UserService.newPassword(data));
339
+ if (err) return dispatch('errorHandler', err);
340
+ return response.data.success;
341
+ },
342
+ async deleteAccount({ commit, dispatch }, data) {
343
+ const [err, response] = await to(UserService.deleteAccount(data));
344
+ if (err) return dispatch('errorHandler', err);
345
+ return response.data.success;
346
+ },
347
+ async registerDevice({ commit, dispatch }) {
348
+ const deviceID = await Device.getId();
349
+ const deviceInfo = await Device.getInfo();
350
+ let deviceData = {
351
+ device_id: deviceID.uuid,
352
+ platform: deviceInfo.platform,
353
+ device_info: {
354
+ model: deviceInfo.model,
355
+ manufacturer: deviceInfo.manufacturer,
356
+ operatingSystem: deviceInfo.operatingSystem,
357
+ osVersion: deviceInfo.osVersion,
358
+ isVirtual: deviceInfo.isVirtual,
359
+ webViewVersion: deviceInfo.webViewVersion
360
+ }
361
+ };
362
+ const [err, response] = await to(DeviceService.registerDevice(deviceData));
363
+ if (err) return dispatch('errorHandler', err);
364
+ return response;
365
+ },
366
+ async addFcmToken({ commit, dispatch }, data) {
367
+ const [err, response] = await to(DeviceService.addFcmToken(data));
368
+ if (err) return dispatch('errorHandler', err);
369
+ return response;
370
+ },
371
+ async acceptCompanyInvitation({ commit, dispatch }, code) {
372
+ const [err, response] = await to(CompanyService.acceptCompanyInvitation(code));
373
+ if (err) return dispatch('errorHandler', err);
374
+ return response;
375
+ },
376
+ async logout({ commit, dispatch, state }, { refreshToken, sendRequest = true }) {
377
+ if (sendRequest && refreshToken) {
378
+ AuthService.logout({ token: refreshToken });
379
+ }
457
380
 
458
- const remainingRefreshTokens = await dispatch('unsetRefreshToken', refreshToken);
381
+ if (state.$storex) {
382
+ state.$storex.username = '';
383
+ state.$storex.UserId = '';
384
+ state.$storex.localUser = '';
385
+ commit('setToken', '');
386
+ }
387
+ commit('setLoggedInUserId', '');
459
388
 
460
- if (remainingRefreshTokens.length >= 1) {
461
- Object.keys(state.loggedInAccounts).forEach((username) => {
462
- if (state.loggedInAccounts[username].refreshToken === remainingRefreshTokens[0]) {
463
- commit('setStorage', {
464
- username: username,
465
- UserId: state.loggedInAccounts[username].id,
466
- localUser: state.loggedInAccounts[username]
467
- })
468
- commit('setRefreshToken', remainingRefreshTokens[0]);
469
- commit('setLoggedInUserId', state.loggedInAccounts[username].id);
470
- dispatch('refreshTokenAction', state.loggedInAccounts[username]).then(() => {
471
- EventBus.$emit("ssoEvent", { name: "switchAccount", data: { username }, });
472
- });
473
- }
474
- });
475
- } else {
476
- if (state.display === "redirect") {
477
- return router.push('/welcome');
478
- } else if (state.display === "npm") {
479
- EventBus.$emit("ssoEvent", { name: "redirect", data: "/welcome" });
480
- }
481
- }
482
- },
483
- async getCompanyBySSOEmail({ commit, dispatch }, data) {
484
- const [err, response] = await to(
485
- CompanyService.getBySSOEmail(data.email)
486
- );
487
- if (err) return dispatch('errorHandler', err);
488
- if (response.data.success) {
489
- return response.data;
490
- }
491
- },
492
- async getLoggedInAccounts({ getters, dispatch }) {
493
- if (getters.refreshTokens && getters.refreshTokens.length >= 1) {
494
- const [err, response] = await to(
495
- AuthService.getLoggedInAccounts({ refreshTokens: getters.refreshTokens })
496
- );
497
- if (err) return dispatch('errorHandler', err);
498
- if (response && response.data && response.data.success) {
499
- dispatch('setLoggedInAccounts', response.data.accounts);
500
- }
501
- }
502
- },
503
- async loginUsingQR({ commit, dispatch }, data) {
504
- const [err, response] = await to(
505
- UserService.loginUsingQR(data)
506
- );
507
- if (err) return dispatch('errorHandler', err);
508
- return response.data.success;
509
- },
510
- setLoggedInAccounts({ commit }, accounts) {
511
- commit('setLoggedInAccounts', accounts);
512
- EventBus.$emit("ssoEvent", { name: "setLoggedInAccounts", data: accounts });
513
- },
514
- setLoggedInUserId({ commit }, id) {
515
- commit('setLoggedInUserId', id);
516
- },
517
- setRefreshToken({ commit }, token) {
518
- commit('setRefreshToken', token);
519
- },
520
- async unsetRefreshToken({ commit, state, dispatch, getters }, refreshToken) {
521
- let refreshTokens = getters.refreshTokens;
389
+ const remainingRefreshTokens = await dispatch('unsetRefreshToken', refreshToken);
522
390
 
523
- // Remove the specified refresh token from the list
524
- refreshTokens = refreshTokens?.filter((t) => t !== refreshToken);
391
+ if (remainingRefreshTokens.length >= 1) {
392
+ Object.keys(state.loggedInAccounts).forEach((username) => {
393
+ if (state.loggedInAccounts[username].refreshToken === remainingRefreshTokens[0]) {
394
+ commit('setStorage', {
395
+ username: username,
396
+ UserId: state.loggedInAccounts[username].id,
397
+ localUser: state.loggedInAccounts[username]
398
+ });
399
+ commit('setRefreshToken', remainingRefreshTokens[0]);
400
+ commit('setLoggedInUserId', state.loggedInAccounts[username].id);
401
+ dispatch('refreshTokenAction', state.loggedInAccounts[username]).then(() => {
402
+ EventBus.$emit('ssoEvent', { name: 'switchAccount', data: { username } });
403
+ });
404
+ }
405
+ });
406
+ } else {
407
+ if (state.display === 'redirect') {
408
+ return router.push('/welcome');
409
+ } else if (state.display === 'npm') {
410
+ EventBus.$emit('ssoEvent', { name: 'redirect', data: '/welcome' });
411
+ }
412
+ }
413
+ },
414
+ async getCompanyBySSOEmail({ commit, dispatch }, data) {
415
+ const [err, response] = await to(CompanyService.getBySSOEmail(data.email));
416
+ if (err) return dispatch('errorHandler', err);
417
+ if (response.data.success) {
418
+ return response.data;
419
+ }
420
+ },
421
+ async getLoggedInAccounts({ getters, dispatch }) {
422
+ if (getters.refreshTokens && getters.refreshTokens.length >= 1) {
423
+ const [err, response] = await to(AuthService.getLoggedInAccounts({ refreshTokens: getters.refreshTokens }));
424
+ if (err) return dispatch('errorHandler', err);
425
+ if (response && response.data && response.data.success) {
426
+ dispatch('setLoggedInAccounts', response.data.accounts);
427
+ }
428
+ }
429
+ },
430
+ async loginUsingQR({ commit, dispatch }, data) {
431
+ const [err, response] = await to(UserService.loginUsingQR(data));
432
+ if (err) return dispatch('errorHandler', err);
433
+ return response.data.success;
434
+ },
435
+ setLoggedInAccounts({ commit }, accounts) {
436
+ commit('setLoggedInAccounts', accounts);
437
+ EventBus.$emit('ssoEvent', { name: 'setLoggedInAccounts', data: accounts });
438
+ },
439
+ setLoggedInUserId({ commit }, id) {
440
+ commit('setLoggedInUserId', id);
441
+ },
442
+ setRefreshToken({ commit }, token) {
443
+ commit('setRefreshToken', token);
444
+ },
445
+ async unsetRefreshToken({ commit, state, dispatch, getters }, refreshToken) {
446
+ let refreshTokens = getters.refreshTokens;
525
447
 
526
- // Update the refresh tokens in the state
527
- commit('setRefreshTokens', refreshTokens.join(","));
448
+ // Remove the specified refresh token from the list
449
+ refreshTokens = refreshTokens?.filter((t) => t !== refreshToken);
528
450
 
529
- return refreshTokens;
530
- },
531
- setToken({ commit }, token) {
532
- commit('setToken', token);
533
- },
534
- updateLang({ commit }, lang) {
535
- commit('updateLang', lang);
536
- },
537
- setView({ commit }, view) {
538
- commit('setView', view);
539
- },
540
- setRedirectUri({ commit }, uri) {
541
- commit('setRedirectUri', uri);
542
- },
543
- setDisplay({ commit }, display) {
544
- commit('setDisplay', display);
545
- },
546
- setState({ commit }, stateValue) {
547
- commit('setState', stateValue);
548
- },
549
- setResponseType({ commit }, responseType) {
550
- commit('setResponseType', responseType);
551
- },
552
- setRealm({ commit }, realm) {
553
- commit('setRealm', realm);
554
- },
555
- },
556
- getters: {
557
- isLoggedIn: state => {
558
- return !!state.$storex.token && state.$storex.token !== "" && state.$storex.token !== "null";
559
- },
560
- renderView: (state, getters, rootState) => {
561
- if (state.display !== "npm") {
562
- return rootState.route?.name;
563
- } else return state.view;
564
- },
565
- appRealm: state => {
566
- return state.realm;
567
- },
568
- appLanguage: state => {
569
- return state.lang;
570
- },
571
- accessToken: state => {
572
- return state.$storex.token;
573
- },
574
- refreshTokens: state => {
575
- return state.$storex.refreshTokens.split(',')
576
- },
577
- apiRoot: state => {
578
- return state.apiRoot;
579
- }
580
- }
451
+ // Update the refresh tokens in the state
452
+ commit('setRefreshTokens', refreshTokens.join(','));
453
+
454
+ return refreshTokens;
455
+ },
456
+ setToken({ commit }, token) {
457
+ commit('setToken', token);
458
+ },
459
+ updateLang({ commit }, lang) {
460
+ commit('updateLang', lang);
461
+ },
462
+ setView({ commit }, view) {
463
+ commit('setView', view);
464
+ },
465
+ setRedirectUri({ commit }, uri) {
466
+ commit('setRedirectUri', uri);
467
+ },
468
+ setDisplay({ commit }, display) {
469
+ commit('setDisplay', display);
470
+ },
471
+ setState({ commit }, stateValue) {
472
+ commit('setState', stateValue);
473
+ },
474
+ setResponseType({ commit }, responseType) {
475
+ commit('setResponseType', responseType);
476
+ },
477
+ setRealm({ commit }, realm) {
478
+ commit('setRealm', realm);
479
+ }
480
+ },
481
+ getters: {
482
+ isLoggedIn: (state) => {
483
+ return !!state.$storex.token && state.$storex.token !== '' && state.$storex.token !== 'null';
484
+ },
485
+ renderView: (state, getters, rootState) => {
486
+ if (state.display !== 'npm') {
487
+ return rootState.route?.name;
488
+ } else return state.view;
489
+ },
490
+ appRealm: (state) => {
491
+ return state.realm;
492
+ },
493
+ appLanguage: (state) => {
494
+ return state.lang;
495
+ },
496
+ accessToken: (state) => {
497
+ return state.$storex.token;
498
+ },
499
+ refreshTokens: (state) => {
500
+ return state.$storex.refreshTokens.split(',');
501
+ },
502
+ apiRoot: (state) => {
503
+ return state.apiRoot;
504
+ }
505
+ }
581
506
  };