@tapni/auth 0.0.2 → 0.0.4

package/src/routes.js

@@ -0,0 +1,55 @@
+const Welcome = () =>
+    import("./views/Welcome.vue");
+const Login = () => import("./views/Login.vue");
+const Register = () =>
+    import("./views/Register.vue");
+const Reset = () => import("./views/Reset.vue");
+const Verify = () =>
+    import("./views/Verify.vue");
+const Callback = () =>
+    import("./views/Callback.vue");
+const QR = () =>
+    import("./views/QR.vue");
+
+export default [
+  {
+    path: "/welcome",
+    name: "AuthWelcome",
+    component: Welcome,
+  },
+  {
+    path: "/login",
+    name: "AuthLogin",
+    component: Login,
+  },
+  {
+    path: "/callback/*",
+    name: "Callback",
+    component: Callback,
+  },
+  {
+    path: "/qr",
+    name: "AuthQR",
+    component: QR,
+  },
+  {
+    path: "/reset",
+    name: "AuthReset",
+    component: Reset,
+  },
+  {
+    path: "/register",
+    name: "AuthRegister",
+    component: Register,
+  },
+  {
+    path: "/verify",
+    name: "AuthVerify",
+    component: Verify,
+  },
+  {
+    path: "/",
+    name: "404",
+    component: Welcome
+  },
+];

package/src/services/Api.js

@@ -0,0 +1,55 @@
+import axios from 'axios'
+import { jwtDecode } from "jwt-decode";
+import { version } from "../../package.json"
+import AuthMixin from "../mixins/auth.mixin"
+
+export default (storage, refreshTokenAction = false) => {
+  const appInfo = version
+  let apiInstance = axios.create({
+    baseURL: import.meta.env.VITE_APP_API_ROOT + '/v1/',
+    headers: {
+      Authorization: `Bearer ${storage.token}`,
+      "X-Client-Name": "sso-" + appInfo.platform,
+      "X-Client-Version": appInfo.version
+    }
+  })
+
+  // Add a request interceptor
+  apiInstance.interceptors.request.use(async function (config) {
+
+    if (['post', 'put', 'delete'].includes(config.method.toLowerCase())) {
+      config.data = {
+        ...config.data,
+        lang: storage.appLang,
+        realm: storage.realm || 'app'
+      }
+    } else if (config.method.toLowerCase() === 'get') {
+      config.params = {
+        ...config.params,
+        lang: storage.appLang,
+        realm: storage.realm || 'app'
+      }
+    }
+
+    // Check refresh token expiration before request is sent
+    if (storage.token && !refreshTokenAction) {
+      const decoded = jwtDecode(storage.token)
+
+      // Check if access token expired
+      if (decoded.exp - 30 < Math.floor(Date.now() / 1000)) {
+
+        return AuthMixin.methods.refreshTokenAction(decoded)
+            .then(() => {
+              config.headers = {
+                ...config.headers,
+                Authorization: `Bearer ${storage.token}`
+              }
+              return config;
+            })
+      }
+    }
+    return config;
+  });
+
+  return apiInstance;
+}

package/src/services/AuthService.js

@@ -0,0 +1,71 @@
+import Api from './Api'
+import { Device } from '@capacitor/device';
+import axios from "axios";
+let deviceID;
+Device.getId().then((DeviceId)=> deviceID = DeviceId.uuid)
+export default {
+  register (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/register', data)
+  },
+  login (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/login', data)
+  },
+  logout (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/logout', data)
+  },
+  refreshToken (data, storage) {
+    return Api(storage, true).get(`/users/refresh-token?UserId=${data.id}&token=${data.refreshToken}`)
+  },
+  getLoggedInAccounts(data, storage) {
+    return Api(storage).post(`/users/tokens`, data);
+  },
+  sendResetEmail (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/reset', data)
+  },
+  changePassword (data, storage) {
+    return Api(storage).put('/users/password', data, {
+      headers: { Authorization: 'Bearer ' + data.token }
+    })
+  },
+  verify (data, storage) {
+    return Api(storage).get('/users/verify?c=' + data.code + '&e=' + data.email + '&captchatoken=' + data.captchaToken)
+  },
+  googleUrl (storage) {
+    return Api(storage).get('/users/google/url')
+  },
+  google (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/google', data)
+  },
+  facebook (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/facebook', data)
+  },
+  googleSDK (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/google/sdk', data)
+  },
+  facebookSDK (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/facebook/sdk', data)
+  },
+  appleSDK (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/apple/sdk', data)
+  },
+  microsoftSDK (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/microsoft/sdk', data)
+  },
+  oktaSDK (data, storage) {
+    data.device_id = deviceID
+    return Api(storage).post('/users/okta/sdk', data)
+  },
+  samlLoginUrl (data, storage) {
+    return Api(storage).post('/saml/url', data)
+  }
+}

package/src/services/CompanyService.js

@@ -0,0 +1,13 @@
+import Api from './Api'
+
+export default {
+  getBySSOEmail (email, storage) {
+    return Api(storage).get(`/company/sso/${email}`)
+  },
+  acceptCompanyInvitation (code, storage) {
+    return Api(storage).get(`/users/invitation?ic=${code}`)
+  },
+  qrCodePooling(payload, storage) {
+    return Api(storage).post("/company/login/qr", payload);
+  },
+}

package/src/services/DeviceService.js

@@ -0,0 +1,10 @@
+import Api from './Api'
+
+export default {
+	registerDevice(data, storage) {
+		return Api(storage).post(`/devices/add`, data)
+	},
+	addFcmToken(data, storage) {
+		return Api(storage).post(`/devices/fcm/add`, data)
+	}
+}

package/src/services/UserService.js

@@ -0,0 +1,49 @@
+import Api from "./Api";
+
+export default {
+  getMe() {
+    return Api(storage).get(`/users/me`);
+  },
+  getByUsername(data, storage) {
+    let referrer = document.referrer || "";
+    let params = data.utmParams || {};
+    if (data.dontTap) params.dontTap = true;
+    return Api(storage).get(`/users/${data.username}`, {
+      params,
+      headers: { "X-Referer": referrer },
+    });
+  },
+  getByNumber(data, storage) {
+    let referrer = document.referrer || "";
+    let params = data.utmParams || {};
+    if (data.dontTap) params.dontTap = true;
+    return Api(storage).get(`/users/tag/${data.serial}`, {
+      params,
+      headers: { "X-Referer": referrer },
+    });
+  },
+  save(data, storage) {
+    return Api(storage).put(`/users`, data);
+  },
+  newPassword(data, storage) {
+    return Api(storage).put(`/users/new-password`, data);
+  },
+  connect(data, storage) {
+    return Api(storage).post(`/users/connect`, data);
+  },
+  eventLog(data, storage) {
+    return Api(storage).post(`/users/log`, data);
+  },
+  deleteAccount(data, storage) {
+    return Api(storage).post(`/users/profile/delete`, data);
+  },
+  registerDevice(data, storage) {
+    return Api(storage).post(`/users/device/register`, data);
+  },
+  addFcmToken(data, storage) {
+    return Api(storage).post(`/users/device/fcm`, data);
+  },
+  loginUsingQR(data, storage) {
+    return Api(storage).post("/users/qr/login", data);
+  }
+};

package/src/services/UtilService.js

@@ -0,0 +1,221 @@
+export default {
+    getFirstBrowserLanguage() {
+        let nav = window.navigator
+        let browserLanguagePropertyKeys = ['language', 'browserLanguage', 'systemLanguage', 'userLanguage']
+        let i
+        let language
+
+        // support for HTML 5.1 "navigator.languages"
+        if (Array.isArray(nav.languages)) {
+            for (i = 0; i < nav.languages.length; i++) {
+                language = nav.languages[i]
+                if (language && language.length) {
+                    return language.slice(0, 2)
+                }
+            }
+        }
+
+        // support for other well known properties in browsers
+        for (i = 0; i < browserLanguagePropertyKeys.length; i++) {
+            language = nav[browserLanguagePropertyKeys[i]]
+            if (language && language.length) {
+                return language.slice(0, 2)
+            }
+        }
+
+        return null
+    },
+    compareLangKeys() {
+        const en = Object.keys(require('../store/locales/en').default.state);
+        const de = Object.keys(require('../store/locales/de').default.state);
+        const es = Object.keys(require('../store/locales/es').default.state);
+        const kr = Object.keys(require('../store/locales/kr').default.state);
+        const it = Object.keys(require('../store/locales/it').default.state);
+        const fr = Object.keys(require('../store/locales/fr').default.state);
+        const sr = Object.keys(require('../store/locales/sr').default.state);
+        const tr = Object.keys(require('../store/locales/tr').default.state);
+
+        // Compare en and de
+        console.log('In en but not in de', en.filter(x => !de.includes(x)));
+        console.log('In de but not in en', de.filter(x => !en.includes(x)));
+        console.log();
+
+        // Compare en and es
+        console.log('In en but not in es', en.filter(x => !es.includes(x)));
+        console.log('In es but not in en', es.filter(x => !en.includes(x)));
+        console.log();
+
+        // Compare en and kr
+        console.log('In en but not in kr', en.filter(x => !kr.includes(x)));
+        console.log('In kr but not in en', kr.filter(x => !en.includes(x)));
+        console.log();
+
+        // Compare en and it
+        console.log('In en but not in it', en.filter(x => !it.includes(x)));
+        console.log('In it but not in en', it.filter(x => !en.includes(x)));
+        console.log();
+
+        // Compare en and fr
+        console.log('In en but not in fr', en.filter(x => !fr.includes(x)));
+        console.log('In fr but not in en', fr.filter(x => !en.includes(x)));
+        console.log();
+
+        // Compare en and sr
+        console.log('In en but not in sr', en.filter(x => !sr.includes(x)));
+        console.log('In sr but not in en', sr.filter(x => !en.includes(x)));
+        console.log();
+
+        // Compare en and tr
+        console.log('In en but not in tr', en.filter(x => !tr.includes(x)));
+        console.log('In tr but not in en', tr.filter(x => !en.includes(x)));
+        console.log();
+    },
+    base64ImageToBlob(base64Image) {
+        // Split into two parts
+        const parts = base64Image.split(';base64,');
+
+        // Hold the content type
+        const imageType = parts[0].split(':')[1];
+
+        // Decode Base64 string
+        const decodedData = window.atob(parts[1]);
+
+        // Create UNIT8ARRAY of size same as row data length
+        const uInt8Array = new Uint8Array(decodedData.length);
+
+        // Insert all character code into uInt8Array
+        for (let i = 0; i < decodedData.length; ++i) {
+            uInt8Array[i] = decodedData.charCodeAt(i);
+        }
+
+        // Return BLOB image after conversion
+        return new Blob([uInt8Array], {type: imageType});
+    },
+    blobToBase64(blob) {
+        const reader = new FileReader();
+        reader.readAsDataURL(blob);
+        return new Promise(resolve => {
+            reader.onloadend = () => {
+                resolve(reader.result);
+            };
+        });
+    },
+    base64toFile(base64, filename) {
+
+        var arr = base64.split(','),
+          mime = arr[0].match(/:(.*?);/)[1],
+          bstr = atob(arr[1]),
+          n = bstr.length,
+          u8arr = new Uint8Array(n);
+
+        while (n--) {
+            u8arr[n] = bstr.charCodeAt(n);
+        }
+
+        return new File([u8arr], filename, {type: mime});
+    },
+    fileToBase64(file) {
+        new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.readAsDataURL(file);
+            reader.onload = () => resolve(reader.result);
+            reader.onerror = error => reject(error);
+        });
+    },
+    getUTMParams(data, storage) {
+        let utm = {}
+        if (data.utm_source) utm.utm_source = data.utm_source;
+        if (data.utm_medium) utm.utm_medium = data.utm_medium;
+        if (data.utm_campaign) utm.utm_campaign = data.utm_campaign;
+        if (data.utm_term) utm.utm_term = data.utm_term;
+        if (data.utm_content) utm.utm_content = data.utm_content;
+        return utm;
+    },
+
+    cropCardScan(base64PictureData, callback) {
+
+        // image will contain ORIGINAL image
+        const image = new window.Image();
+
+        // image will contain CROPPED image
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+
+        // Load original image into image element
+        image.src = 'data:image/jpeg;base64,' + base64PictureData;
+        image.onload = () => {
+            const sw = image.width;
+            const sh = image.width / 1.65;
+            const sx = 0;
+            const sy = (image.height / 2) - (sh / 2)
+            const dw = sw;
+            const dh = sh;
+            canvas.width = dw;
+            canvas.height = dh
+            // https://i.stack.imgur.com/USDAX.png
+            ctx.drawImage(image, sx, sy, sw, sh, 0, 0, dw, dh); // Crop interpolated rectangle
+            const croppedBase64Image = canvas.toDataURL();
+
+            callback(croppedBase64Image);
+
+            return croppedBase64Image;
+        };
+    },
+    generateRandomString(length) {
+        let array = new Uint32Array(length);
+        window.crypto.getRandomValues(array);
+        return Array.from(array, dec => ('0' + dec.toString(16)).substr(-2)).join('');
+    },
+    async pkceChallengeFromVerifier(v) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(v);
+        const hashed =  await window.crypto.subtle.digest('SHA-256', data);
+        // base64 url encode
+        return btoa(String.fromCharCode.apply(null, new Uint8Array(hashed))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    },
+    encryptAES(key, iv, data) {
+        let encoder = new TextEncoder();
+        let encoded = encoder.encode(data, storage);
+        return window.crypto.subtle.encrypt(
+          {
+              name: "AES-CBC",
+              iv: iv,
+          },
+          key,
+          encoded,
+        );
+    },
+    async decryptAES(key, iv, data) {
+        try {
+            const fromBase64 = base64String => Uint8Array.from(atob(base64String), c => c.charCodeAt(0));
+
+            //console.log("key: " + key);
+            //console.log("iv: " + iv);
+
+            data = data.replace(/ /g, '+');
+
+            const encoder = new TextEncoder();
+            const decoder = new TextDecoder();
+
+            key = encoder.encode(key);
+            iv = encoder.encode(iv);
+            data = fromBase64(data, storage);
+
+
+            const secretKey = await window.crypto.subtle.importKey('raw', key, 'AES-CBC', true, ['encrypt', 'decrypt']);
+
+
+            let decoded = await window.crypto.subtle.decrypt({name: "AES-CBC", iv}, secretKey, data);
+
+            decoded = decoder.decode(decoded);
+            decoded = decoded.replace(/ /g, '+');
+            decoded = atob(decoded);
+
+            return decoded;
+
+
+        } catch (err) {
+            console.log(err)
+        }
+    }
+}

package/src/store/constants.js

@@ -0,0 +1,8 @@
+export default {
+	ANDROID_VERSION: '5.6',
+	IOS_VERSION: '5.6',
+	WEB_VERSION: '5.6.0',
+	SUPPORTED_LANGUAGES: ['en', 'de', 'es', 'kr', 'it', 'fr'],
+	METAPIXEL_ID: '1203678696914368',
+	GOOGLE_ANALYTICS_ID: ''
+}

package/src/store/event-bus.js

@@ -0,0 +1,30 @@
+import { reactive, readonly } from 'vue';
+
+const listeners = reactive(new Map());
+
+export const EventBus = {
+    $on(event, listener) {
+        let eventListeners = listeners.get(event);
+        if (!eventListeners) {
+            eventListeners = new Set();
+            listeners.set(event, eventListeners);
+        }
+        eventListeners.add(listener);
+    },
+    $emit(event, ...args) {
+        const eventListeners = listeners.get(event);
+        if (eventListeners) {
+            for (const listener of eventListeners) {
+                listener(...args);
+            }
+        }
+    },
+    $off(event, listener) {
+        const eventListeners = listeners.get(event);
+        if (eventListeners) {
+            eventListeners.delete(listener);
+        }
+    }
+};
+
+export default readonly(EventBus);