authscape 1.0.122 → 1.0.123

package/components/Datatable.js

@@ -1,3 +1,4 @@
+"use client"
 import React, { Component } from 'react';
 //import {apiService} from 'authscape';
 import DataTable, {createTheme} from "react-data-table-component";

package/components/FileUploader.js

@@ -1,3 +1,5 @@
+"use client"
+
 import React, { useState, useRef, useEffect } from "react";
 import { apiService } from "../services/authService";
 import LinearProgress from "@mui/material/LinearProgress";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "authscape",
-  "version": "1.0.122",
+  "version": "1.0.123",
   "scripts": {
     "dev": "next dev",
     "build": "next build",
@@ -8,6 +8,11 @@
     "lint": "next lint"
   },
   "dependencies": {
+    "@emotion/react": "^11.11.0",
+    "@emotion/styled": "^11.11.0",
+    "@mui/icons-material": "^5.11.16",
+    "@mui/material": "^5.13.2",
+    "@mui/styled-engine-sc": "^5.12.0",
     "@stripe/react-stripe-js": "^2.1.0",
     "@stripe/stripe-js": "^1.53.0",
     "axios": "^1.4.0",
@@ -17,6 +22,7 @@
     "query-string": "^8.1.0",
     "react": "18.2.0",
     "react-data-table-component": "^7.5.3",
-    "react-dom": "18.2.0"
+    "react-dom": "18.2.0",
+    "styled-components": "^5.3.11"
   }
 }

package/services/apiService.js

@@ -0,0 +1,253 @@
+import axios from 'axios'
+import querystring from 'query-string';
+import fileDownload from 'js-file-download';
+import { parseCookies, setCookie, destroyCookie } from 'nookies';
+
+const setupDefaultOptions = async (ctx = null) => {
+
+    let defaultOptions = {};
+    if (ctx == null)
+    {
+        let accessToken = parseCookies().access_token || '';
+
+        if (accessToken !== null && accessToken !== undefined && accessToken != "") {
+            defaultOptions = {
+                headers: {
+                    Authorization: "Bearer " + accessToken
+                }
+            };
+        }
+        else {
+            defaultOptions = {
+                headers: {
+                },
+            };
+        }
+    }
+    else
+    {
+        defaultOptions = {
+            headers: {
+            },
+        };
+    }
+
+    return defaultOptions;
+}
+
+const RefreshToken = async (originalRequest, instance) => {
+
+    let accessToken = parseCookies().access_token || '';
+    let refreshToken = parseCookies().refresh_token || '';
+
+    let response = await instance.post(process.env.AUTHORITYURI + "/connect/token",
+        querystring.stringify({
+            grant_type: 'refresh_token',
+            client_id: process.env.client_id,
+            client_secret: process.env.client_secret,
+            refresh_token: refreshToken
+        }), {
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Authorization": "Bearer " + accessToken
+        }
+    });
+
+    if (response != null && response.status == 200)
+    {
+        originalRequest.headers['Authorization'] = 'Bearer ' + response.data.access_token;
+
+        await setCookie(null, "access_token", response.data.access_token,
+        {
+            maxAge: 2147483647,
+            path: '/',
+            domain: process.env.cookieDomain,
+            secure: true
+        });
+    
+        await setCookie(null, "expires_in", response.data.expires_in,
+        {
+            maxAge: 2147483647,
+            path: '/',
+            domain: process.env.cookieDomain,
+            secure: true
+        });
+    
+        await setCookie(null, "refresh_token", response.data.refresh_token,
+        {
+            maxAge: 2147483647,
+            path: '/',
+            domain: process.env.cookieDomain,
+            secure: true
+        });
+    }
+}
+
+export const apiService = (ctx = null) => {
+
+    let env = process.env.STAGE;
+    if (env == "development")
+    {
+        process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+    }
+
+    let baseUri = process.env.APIURI + "/api";
+
+    const instance = axios.create({
+        baseURL: baseUri,
+        //timeout: 10000,
+        params: {} // do not remove this, its added to add params later in the config
+    });
+
+    instance.interceptors.response.use(
+        (response) => {
+        
+        return response;
+        },
+        async (error) => {
+            const originalConfig = error.config;
+            if (error.response) {
+
+                if (error.response.status === 401 && !originalConfig._retry) {
+                    originalConfig._retry = true;
+
+                    // Do something, call refreshToken() request for example;
+                    await RefreshToken(originalConfig, instance);
+
+                    // return a request
+                    return instance.request(originalConfig);
+                }
+
+                if (error.response.status === 400) {
+                    // Do something 
+
+                    if (error.response.config.url.includes("/connect/token")) // remove the access and refresh if invalid
+                    {
+                        destroyCookie(null, "access_token", {
+                            maxAge: 2147483647,
+                            path: '/',
+                            domain: process.env.cookieDomain
+                        });
+
+                        destroyCookie(null, "refresh_token", {
+                            maxAge: 2147483647,
+                            path: '/',
+                            domain: process.env.cookieDomain
+                        });
+
+                        destroyCookie(null, "expires_in", {
+                            maxAge: 2147483647,
+                            path: '/',
+                            domain: process.env.cookieDomain
+                        });
+                    }
+
+                    return Promise.reject(error);
+                }
+            }
+        
+            return Promise.reject(error);
+        }
+    );
+
+    return {
+
+        get: async (url, options= {}) => {
+            
+            try
+            {
+                let defaultOptions = await setupDefaultOptions(ctx);
+                return await instance.get(url, { ...defaultOptions, ...options });
+            }
+            catch(error)
+            {
+                return error.response;
+            }
+        },
+        post: async (url, data, options = {}) => {
+
+            try
+            {
+                let defaultOptions = await setupDefaultOptions(ctx);
+                return await instance.post(url, data, { ...defaultOptions, ...options });
+            }
+            catch(error)
+            {
+                return error.response;
+            }
+        },
+        put: async (url, data, options = {}) => {
+
+            try
+            {
+                let defaultOptions = await setupDefaultOptions(ctx);
+                return await instance.put(url, data, { ...defaultOptions, ...options });
+            }
+            catch(error)
+            {
+                return error.response;
+            }
+        },
+        delete: async (url, options = {}) => {
+
+            try
+            {
+                let defaultOptions = await setupDefaultOptions(ctx);
+                return await instance.delete(url, { ...defaultOptions, ...options });
+            }
+            catch(error)
+            {
+                return error.response;
+            }
+        },
+        GetCurrentUser: async () => {
+
+            try
+            {
+                let accessToken = parseCookies().access_token || null;
+
+                if (accessToken)
+                {
+                    let defaultOptions = await setupDefaultOptions(null);
+                    const response = await instance.get('/UserManagement', defaultOptions);
+                    if (response != null && response.status == 200)
+                    {
+                        return response.data;
+                    }
+                    // else if (response != null && response.status == 401)
+                    // {
+                    //     // call the login window maybe?
+                    // }
+                }
+
+            } catch(exp) {
+                //return -1;
+                console.log(exp.message);
+            }
+            return null;    
+        },
+        DownloadFile: async (url, fileName, completed) => {
+         
+            try
+            {
+                //let defaultOptions = await setupDefaultOptions();
+                let defaultOptions = {};
+                let options = { responseType: "blob" };
+                let response = await instance.get(url, { ...defaultOptions, ...options });
+                if (response.status === 200) {
+                    fileDownload(response.data, fileName);
+                    if (completed !== undefined) {
+                        completed();
+                    }
+                }
+            }
+            catch(error)
+            {
+                console.error(error);
+                if (completed !== undefined) {
+                    completed();
+                }
+            }
+        }
+    }
+}

package/services/authService.js

@@ -0,0 +1,115 @@
+import React from 'react';
+import { destroyCookie } from 'nookies';
+
+export const authService = () => {
+
+    return {
+
+        dec2hex: (dec) => {
+            return ('0' + dec.toString(16)).substr(-2)
+        },
+        generateRandomString: () => {
+            var array = new Uint32Array(56/2);
+            window.crypto.getRandomValues(array);
+            return Array.from(array, authService().dec2hex).join('');
+        },
+        sha256: (plain) => {
+            const encoder = new TextEncoder();
+            const data = encoder.encode(plain);
+            return window.crypto.subtle.digest('SHA-256', data);
+        },
+        base64urlencode: (a) => {
+            var str = "";
+            var bytes = new Uint8Array(a);
+            var len = bytes.byteLength;
+            for (var i = 0; i < len; i++) {
+            str += String.fromCharCode(bytes[i]);
+            }
+            return btoa(str)
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=+$/, "");
+        },
+        challenge_from_verifier: async (v) => {
+            let hashed = await authService().sha256(v);
+            let base64encoded = authService().base64urlencode(hashed);
+            return base64encoded;
+        },
+        login: async (redirectUserUri = null, dnsRecord = null, deviceId = null) => {
+
+            let state = "1234";
+            if (redirectUserUri != null)
+            {
+                localStorage.setItem("redirectUri", redirectUserUri);
+            }
+
+            let verifier = authService().generateRandomString();
+            var challenge = await authService().challenge_from_verifier(verifier);
+
+            window.localStorage.setItem("verifier", verifier);
+
+            let redirectUri = window.location.origin + "/signin-oidc";
+            let loginUri = process.env.AUTHORITYURI + "/connect/authorize?response_type=code&state=" + state + "&client_id=" + process.env.client_id + "&scope=email%20openid%20offline_access%20profile%20api1&redirect_uri=" + redirectUri + "&code_challenge=" + challenge + "&code_challenge_method=S256";
+            
+            if (deviceId)
+            {
+                loginUri += "&deviceId=" + deviceId; // will be for chrome extention and mobile apps later
+            }
+            
+            window.location.href = loginUri;
+        },
+        signUp: (redirectUrl = null) => {
+
+            let AuthUri = process.env.AUTHORITYURI;
+
+            let url = "";
+            if (redirectUrl == null)
+            {
+                url = AuthUri + "/Account/Register?returnUrl=" + window.location.href;
+                localStorage.setItem("redirectUri", window.location.href);
+            }
+            else
+            {
+                url = AuthUri + "/Account/Register?returnUrl=" + redirectUrl;
+                localStorage.setItem("redirectUri", redirectUrl);
+            }
+
+            window.location.href = url;
+        },
+        logout: async (redirectUri = null) => {
+
+            let AuthUri = process.env.AUTHORITYURI;
+            let cookieDomain = process.env.cookieDomain;
+
+            destroyCookie({}, "access_token", {
+                maxAge: 2147483647,
+                path: '/',
+                domain: cookieDomain
+            });
+
+            destroyCookie({}, "refresh_token", {
+                maxAge: 2147483647,
+                path: '/',
+                domain: cookieDomain
+            });
+
+            destroyCookie({}, "expires_in", {
+                maxAge: 2147483647,
+                path: '/',
+                domain: cookieDomain
+            });
+
+            setTimeout(() => {
+                if (redirectUri == null)
+                {
+                    window.location.href = AuthUri + "/connect/logout?redirect=" + window.location.href;
+                }
+                else
+                {
+                    window.location.href = AuthUri + "/connect/logout?redirect=" + redirectUri;
+                }
+            }, 500);
+
+        },
+    }
+}

package/services/authorizationComponent.js

@@ -0,0 +1,34 @@
+import React, { useEffect, useState, useRef } from 'react';
+//import apiService from './apiService';
+
+export function AuthorizationComponent({children, setCurrentUser, userLoaded, isLoading}) {
+
+    const [loaded, setLoaded] = useState(false);
+    const validateUserSignedIn = async () => {
+
+      setLoaded(true);
+
+      let usr = await apiService().GetCurrentUser();
+      if (usr != null)
+      {
+        setCurrentUser(usr);
+      }
+      else
+      {
+        setCurrentUser(null);
+      }
+
+      userLoaded();
+    }
+
+    useEffect(() => {
+
+        if (!loaded)
+        {
+            validateUserSignedIn();
+        }
+
+    }, [loaded]);
+
+    return (children)
+}

package/services/signInValidator.js

@@ -0,0 +1,66 @@
+import React, { useEffect, useState } from 'react';
+import axios from 'axios';
+import querystring from "query-string";
+import { setCookie } from 'nookies';
+
+export const signInValidator = async (queryCode) => {
+ 
+  let codeVerifier = window.localStorage.getItem("verifier");
+      if (queryCode != null && codeVerifier != null)
+      {
+        const headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+
+        let queryString = querystring.stringify({
+          code: queryCode,
+          grant_type: "authorization_code",
+          redirect_uri: window.location.origin + "/signin-oidc",
+          client_id: process.env.client_id,
+          client_secret: process.env.client_secret,
+          code_verifier: codeVerifier
+        });
+
+        let response = await axios.post(process.env.AUTHORITYURI + '/connect/token', queryString, {
+          headers: headers
+        });
+
+        window.localStorage.removeItem("verifier");
+
+        let domain = process.env.cookieDomain;
+
+        await setCookie(null, "access_token", response.data.access_token,
+        {
+            maxAge: 2147483647,
+            path: '/',
+            domain: domain,
+            secure: true
+        });
+    
+        await setCookie(null, "expires_in", response.data.expires_in,
+        {
+            maxAge: 2147483647,
+            path: '/',
+            domain: domain,
+            secure: true
+        });
+    
+        await setCookie(null, "refresh_token", response.data.refresh_token,
+        {
+            maxAge: 2147483647,
+            path: '/',
+            domain: domain,
+            secure: true
+        });
+
+
+        let redirectUri = localStorage.getItem("redirectUri")
+        localStorage.clear();
+        if (redirectUri != null)
+        {
+          window.location.href = redirectUri;
+        }
+        else
+        {
+          window.location.href = "/";
+        }
+    }
+}

package/services/slug.js

@@ -0,0 +1,11 @@
+export const Slug = (slug) => {
+
+    let index = slug.lastIndexOf("-") + 1;
+    if (slug.length > index)
+    {
+        slug = slug.substr(index);
+        return slug;
+    }
+
+    return null;
+};

package/services/storeWithExpiry.js

@@ -0,0 +1,28 @@
+export const storeWithExpiry = () => {
+
+    return {
+        set: (key, value, ttl) => {
+
+            const now = new Date()
+            const item = {
+                value: value,
+                expiry: now.getTime() + ttl,
+            }
+            localStorage.setItem(key, JSON.stringify(item))
+        },
+        get: (key) => {
+
+            const itemStr = localStorage.getItem(key)
+            if (!itemStr) {
+                return null
+            }
+            const item = JSON.parse(itemStr)
+            const now = new Date()
+            if (now.getTime() > item.expiry) {
+                localStorage.removeItem(key)
+                return null
+            }
+            return item.value
+        }
+    }
+}