@gandalan/weblibs 0.0.41 → 1.0.1

package/README.md

@@ -4,27 +4,28 @@ WebLibs for Gandalan JS/TS/Svelte projects
 
 
 ```js
-import { IDAS } from '@gandalan/weblibs/api/IDAS';
-let idas = new IDAS();
-
-// bei Bedarf wird der Client zur Anmeldung umgeleitet, danach wird die aktuelle Seite wieder aufgerufen
-idas.authenticateWithSSO(); 
+import { IDASFactory } from '@gandalan/weblibs';
+let idas = IDASFactory.create();
 ```
 
+IDAS ab Version 1.0.0 verwendet JWT-Token für die Authentifizierung mit WebAPI. 
+
 Danach z.B. Zugriff auf die Mandant-Guid:
 
 ```js
-let mandantGuid = idas.mandantGuid;
+let mandantGuid = await idas.then(i => i.mandantGuid);
 ```
 
 Datenzugriffe erfolgen über die Objekte innerhalb der IDAS-Klasse
 
 ```js
 let loader = Promise.all([
-	idas.mandanten.getAll()
+	idas.
+		.then(i => i.mandanten.getAll())
 		.then(d => mandanten = d.sort((a,b) => a.Name.localeCompare(b.Name)))
 		.catch(e => error = e),
-	idas.rollen.getAll()
+	idas
+		.then(i => i.rollen.getAll())
 		.then(d => rollen = d.sort((a,b) => a.Name.localeCompare(b.Name)))
 		.catch(e => error = e)
 ])

package/api/IDAS.js

@@ -2,142 +2,155 @@ import { RESTClient } from './RESTClient';
 
 let appToken = localStorage.getItem('IDAS_AppToken') || '66B70E0B-F7C4-4829-B12A-18AD309E3970';
 let authToken = localStorage.getItem('IDAS_AuthToken');
-let authJwtToken = localStorage.getItem('IDAS_AuthJwtToken');
 let apiBaseUrl = localStorage.getItem('IDAS_ApiBaseUrl') || 'https://api.dev.idas-cloudservices.net/api/';
-
-let restClient = new RESTClient(apiBaseUrl, authToken);
-restClient.onError = (error, message) => {
-    if (message.indexOf("401") != -1 || message.indexOf("403") != -1) {
-        localStorage.removeItem('IDAS_AuthToken');
-        localStorage.removeItem('IDAS_AuthJwtToken');
-        new IDAS().authenticateWithSSO(true);
-    }
-}
-
-export class IDAS {
-    async authenticate(authDTO) {
-        authDTO.AppToken = appToken;
-        let { data } = await restClient.post('/Login/Authenticate', authDTO);
-        if (data?.Token) {
-            authToken = data.Token;
-            localStorage.setItem('IDAS_AuthToken', authToken);
-            restClient = new RESTClient(apiBaseUrl, authToken);
+let authJwtCallbackPath = localStorage.getItem('IDAS_AuthJwtCallbackPath') || '';
+let authJwtToken;
+
+export let IDASFactory = {
+    async create() {
+        return new Promise((resolve, reject) => {
+            let idas = new IDAS();
+            resolve(idas.authenticateWithJwt(authJwtCallbackPath));
+        });
+    },
+
+    authorize() {
+        var urlParams = new URLSearchParams(location.search);
+        if (urlParams.has('t')) {
+            let idas = new IDAS();
+            idas.authorizeWithJwt(urlParams.get('t'));
         }
-        return data;
-    }
-
-    authorizeWithJwt(jwtToken) {
-        localStorage.setItem('IDAS_AuthJwtToken', jwtToken);
-        restClient = new RESTClient(apiBaseUrl, jwtToken, true);
+        if (urlParams.has("m")) {
+            localStorage.setItem("IDAS_MandantGuid", urlParams.get("m"));
+        }
+        if (urlParams.has("a")) {
+            localStorage.setItem("IDAS_ApiBaseUrl", urlParams.get("a"));
+        }
+        window.location.search = "";
     }
+}
 
-    async authenticateWithSSO(forceRenew = false) { 
-        if (!authToken)
-        {
-            const url = new URL(apiBaseUrl);
-            url.pathname = "/SSO";
-            url.search = "?a=" + appToken;
-            if (forceRenew)
-                url.search = url.search + "&forceRenew=true";
-            url.search = url.search + "&r=%target%%3Ft=%token%%26m=%mandant%";
-            let ssoAuthUrl = url.toString();
+class IDAS {
+    restClient = undefined;
 
-            var ssoURL = ssoAuthUrl.replace("%target%", encodeURIComponent(window.location.href));
-            window.location = ssoURL;
-        }
+    authorizeWithJwt(jwtToken, mandant = '') {
+        authJwtToken = jwtToken;
+        mandant && localStorage.setItem('IDAS_MandantGuid', mandant);
+        this.restClient = new RESTClient(apiBaseUrl, jwtToken, true);
     }
 
     async authenticateWithJwt(authPath) {
-        if (!authJwtToken) {
-            const authEndpoint = (new URL(window.location.href).origin) + authPath;
-            let authUrlCallback = `${authEndpoint}?r=%target%&t=%jwt%`;
-            authUrlCallback = authUrlCallback.replace('%target%', encodeURIComponent(window.location.href));
-
-            const url = new URL(apiBaseUrl);
-            url.pathname = "/Session";
-            url.search = `?a=${appToken}&r=${encodeURIComponent(authUrlCallback)}`;
-            let jwtUrl = url.toString();
-
-            window.location = jwtUrl;
-        } else {
-            restClient = new RESTClient(apiBaseUrl, authJwtToken, true);
-        }
+        return new Promise(async (resolve, reject) => {
+            // no valid JWT, but try to use "refresh token" first to retrive new JWT
+            var refreshClient = new RESTClient(apiBaseUrl, '');
+            await refreshClient.checkRefreshToken(authJwtToken, () => {
+                authJwtToken = undefined;
+                // ... so repeat authenticate (should lead to /Session login page)
+                new IDAS().authenticateWithJwt(authPath);
+            });
+
+            // still not valid JWT -> authenticate
+            if (!refreshClient.token) {
+                localStorage.setItem('IDAS_AuthJwtCallbackPath', authPath);
+                const authEndpoint = (new URL(window.location.href).origin) + authPath;
+                let authUrlCallback = `${authEndpoint}?r=%target%&t=%jwt%&m=%mandant%`;
+                authUrlCallback = authUrlCallback.replace('%target%', encodeURIComponent(window.location.href));
+    
+                const url = new URL(apiBaseUrl);
+                url.pathname = "/Session";
+                url.search = `?a=${appToken}&r=${encodeURIComponent(authUrlCallback)}`;
+                let jwtUrl = url.toString();
+    
+                window.location = jwtUrl;
+                reject('not authenticated yet');
+            } else {
+                this.authorizeWithJwt(refreshClient.token);
+                resolve(this);
+            }    
+        });
     }
 
     mandantGuid = localStorage.getItem('IDAS_MandantGuid');
 
     auth = {
+        _self: this,
         async getCurrentAuthToken() {
-            return await restClient.put('/Login/Update/', { Token: authToken })
+            return await this._self.restClient.put('/Login/Update/', { Token: authToken })
         },
     };
 
     mandanten = {
+        _self: this,
         async getAll() {
-            return await restClient.get('/Mandanten');
+            return await this._self.restClient.get('/Mandanten');
         },
         async get(guid) {
-            return await restClient.get(`/Mandanten/${guid}`);
+            return await this._self.restClient.get(`/Mandanten/${guid}`);
         },
         async save(m) {
-            await restClient.put('/Mandanten', m);
+            await this._self.restClient.put('/Mandanten', m);
         },
     };
 
     benutzer = {
+        _self: this,
         async getAll(mandantGuid) {
-            return await restClient.get(`/BenutzerListe/${mandantGuid }/?mitRollenUndRechten=true`);
+            return await this._self.restClient.get(`/BenutzerListe/${mandantGuid }/?mitRollenUndRechten=true`);
         },
         async get(guid) {
-            return await restClient.get(`/Benutzer/${guid}`);
+            return await this._self.restClient.get(`/Benutzer/${guid}`);
         },
         async save(m) {
-            await restClient.put('/Benutzer', m);
+            await this._self.restClient.put('/Benutzer', m);
         },
     };
 
     feedback = {
+        _self: this,
         async getAll() {
-            return await restClient.get('/Feedback/');
+            return await this._self.restClient.get('/Feedback/');
         },
         async get(guid) {
-            return await restClient.get(`/Feedback/${guid}`);
+            return await this._self.restClient.get(`/Feedback/${guid}`);
         },
         async save(m) {
-            await restClient.put('/Feedback', m);
+            await this._self.restClient.put('/Feedback', m);
         },
         async comment(guid, commentData) {
-            await restClient.put(`/FeedbackKommentar/${guid}`, commentData);
+            await this._self.restClient.put(`/FeedbackKommentar/${guid}`, commentData);
         },
         async attachFile(guid, filename, data) {
-            await restClient.put(`/FeedbackAttachment/?feedbackGuid=${guid}&filename=${filename}`, data);
+            await this._self.restClient.put(`/FeedbackAttachment/?feedbackGuid=${guid}&filename=${filename}`, data);
         },
         async deleteFile(guid) {
-            await restClient.delete(`/FeedbackAttachment/${guid}`);
+            await this._self.restClient.delete(`/FeedbackAttachment/${guid}`);
         },
     };
 
     rollen = {
+        _self: this,
         async getAll() {
-            return await restClient.get('/Rollen');
+            return await this._self.restClient.get('/Rollen');
         },
         async save(m) {
-            await restClient.put('/Rollen', m);
+            await this._self.restClient.put('/Rollen', m);
         },
     };
 
     vorgaenge = {
+        _self: this,
         async getByVorgangsnummer(vorgangsNummer, jahr) {
-            return await restClient.get(`/Vorgang/${vorgangsNummer}/${jahr}`);
+            return await this._self.restClient.get(`/Vorgang/${vorgangsNummer}/${jahr}`);
         },
     };
 
     positionen = {
+        _self: this,
         async getByPcode(pcode) {
-            return await restClient.get(`/BelegPositionen/GetByPcode/${pcode}`);
+            return await this._self.restClient.get(`/BelegPositionen/GetByPcode/${pcode}`);
         },
         async get(guid) {
-            return await restClient.get(`/BelegPositionen/Get/${guid}`);
+            return await this._self.restClient.get(`/BelegPositionen/Get/${guid}`);
         },
     };
 }

package/api/RESTClient.js

@@ -1,4 +1,5 @@
 import axios from 'axios';
+import jwt_decode from 'jwt-decode';
 
 /*export let AppToken = "66B70E0B-F7C4-4829-B12A-18AD309E3970";
 export let AuthToken = localStorage.getItem("AuthToken");
@@ -7,6 +8,8 @@ export let ApiBaseUrl = localStorage.getItem("ApiBaseUrl") || "https://api.dev.i
 export let SiteBaseUrl = window.location.origin;
 export let SSOAuthUrl = ApiBaseUrl.replace("/api", '') + "/SSO?a=" + AppToken + "&r=%target%?t=%token%%26m=%mandant%";*/
 
+let authJwtRefreshToken = localStorage.getItem('IDAS_AuthJwtRefreshToken');
+
 export class RESTClient {
     lastError = '';
     token = '';
@@ -22,11 +25,85 @@ export class RESTClient {
             axios.defaults.headers.common['X-Gdl-AuthToken'] = this.token;
         }
 
-        axios.interceptors.request.use(req => {
-            return req;
+        if (this.token && isJWT) {
+            this.updateJwtToken(token);
+        }
+
+        axios.interceptors.request.use(async (config) => {
+            await this.checkAuthorizationHeader(config);
+            return config;
         });
     }
 
+    async checkAuthorizationHeader(config) {
+        let authHeader = config.headers['Authorization'];
+        if (authHeader && authHeader.toString().startsWith('Bearer ')) {
+            let parts = authHeader.toString().split(' ');
+            let jwt = parts[1];
+            if (!this.isJwtTokenExpired(jwt)) {
+                // JWT token is not expired
+                return;
+            }
+
+            // expired token - refresh
+            await this.checkRefreshToken(jwt);
+        }
+    }
+
+    async checkRefreshToken(jwt, authCallback) {
+        if (!jwt && authJwtRefreshToken) {
+            this.onError = (error, message) => {
+                // LoginJwt/Refresh failed, which means "refresh token" is expired/invalid...
+                if (message.indexOf("401") != -1 || message.indexOf("403") != -1) {
+                    authJwtRefreshToken = undefined;
+                    localStorage.removeItem('IDAS_AuthJwtRefreshToken');
+                    // ... so repeat authenticate
+                    authCallback && authCallback();
+                }
+            };
+            // fetch fresh JWT
+            await this.refreshToken();
+            return;
+        }
+        this.token = jwt;
+        this.isJWT = true;
+    }
+
+    isJwtTokenExpired(jwt) {
+        if (!jwt) {
+            return true;
+        }
+
+        let decoded = jwt_decode(jwt);
+        const utcNow = Date.parse(new Date().toUTCString()) / 1000;
+
+        if (decoded && decoded.exp >= utcNow) {
+            return false;
+        }
+
+        return true;
+    }
+
+    updateJwtToken(jwt) {
+        let decoded = jwt_decode(jwt);
+        let refreshToken = decoded['refreshToken'];
+        localStorage.setItem('IDAS_AuthJwtRefreshToken', refreshToken);
+        authJwtRefreshToken = refreshToken;
+        this.token = jwt;
+        this.isJWT = true;
+    }
+
+    async refreshToken() {
+        try {
+            await axios.put(this.baseurl + '/LoginJwt/Refresh', { token: localStorage.getItem('IDAS_AuthJwtRefreshToken') })
+                .then(resp => {
+                    this.updateJwtToken(resp.data);
+                });
+        } catch (error) {
+            this.handleError(error);
+        }
+    }
+
     updateToken(token) {
         this.token = token;
     }

package/index.js

@@ -12,7 +12,7 @@ export {
     AddButton, RemoveButton, SaveButton,
 }
 
-import { IDAS } from './api/IDAS';
+import { IDASFactory } from './api/IDAS';
 import { RESTClient } from './api/RESTClient';
 
-export { IDAS, RESTClient };
+export { IDASFactory, RESTClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gandalan/weblibs",
-  "version": "0.0.41",
+  "version": "1.0.1",
   "description": "WebLibs for Gandalan JS/TS/Svelte projects",
   "author": "Philipp Reif",
   "license": "ISC",
@@ -23,6 +23,7 @@
   "dependencies": {
     "@mdi/js": "^7.0.96",
     "axios": "^0.27.2",
+    "jwt-decode": "^3.1.2",
     "svelte-table": "^0.5.1"
   },
   "peerDependencies": {