@dflat-core/web 1.0.48 → 1.0.49

package/fesm2022/dflat-core-web-core-services.mjs

@@ -8,7 +8,7 @@ import * as i0 from "@angular/core";
 import { EventEmitter, Inject, Injectable, InjectionToken, NgModule, Optional, SkipSelf } from "@angular/core";
 import jwt_decode from "jwt-decode";
 import { BehaviorSubject, ReplaySubject, Subject, empty, throwError, timer } from "rxjs";
-import { catchError, filter, finalize, map } from "rxjs/operators";
+import { catchError, filter, finalize, map, shareReplay } from "rxjs/operators";
 import * as i4 from "@angular/router";
 import * as i1 from "@angular/platform-browser";
 import * as signalR from "@microsoft/signalr";
@@ -120,6 +120,12 @@ var ServerUrl = class ServerUrl {
 	static {
 		this.connectPath = "/Account/Connect";
 	}
+	static {
+		this.connectExternalPath = "/Account/ConnectExternal";
+	}
+	static {
+		this.loginProvidersPath = "/Account/GetLoginProviders";
+	}
 	static {
 		this.registerPath = "/Account/Register";
 	}
@@ -702,6 +708,27 @@ var AuthService = class AuthService {
 			}
 		}));
 	}
+	getLoginProviders() {
+		return this.httpClient.get(this.baseUrl + ServerUrl.loginProvidersPath, { headers: this.headersService.jsonHeaders() });
+	}
+	loginExternal(provider, idToken, rememberMe, firstName, lastName) {
+		let body = JSON.stringify({
+			"Provider": provider,
+			"IdToken": idToken,
+			"FirstName": firstName,
+			"LastName": lastName
+		});
+		let _url = this.baseUrl + ServerUrl.connectExternalPath;
+		return this.httpClient.post(_url, body, { headers: this.headersService.authJsonHeaders() }).pipe(map((resp) => {
+			let user = resp;
+			if (user && user.AccessToken) {
+				this.saveUserInfos(user, JSON.stringify(user), rememberMe);
+				this.busMsg.publish(new UserUpdatedMessage(user.AccessToken));
+				this.scheduleRefreshToken(true, true);
+				return user;
+			}
+		}));
+	}
 	register(captchaToken, firstName, lastName, email, password, rememberMe) {
 		let body = JSON.stringify({
 			"CaptchaToken": captchaToken,
@@ -859,7 +886,7 @@ var AuthService = class AuthService {
 	updateToken() {
 		console.log(`Entering updateToken()`);
 		const headers = new HttpHeaders({ "Content-Type": "application/json" });
-		const model = { refreshToken: this.refreshToken };
+		const model = JSON.stringify(this.refreshToken);
 		return this.httpClient.post(`${this.baseUrl}${ServerUrl.refreshPath}`, model, { headers }).pipe(map((response) => response || {}), catchError((error) => throwError(() => new Error(error.error)))).subscribe((resp) => {
 			let user = resp;
 			if (user && user.AccessToken) {
@@ -1037,6 +1064,174 @@ i0.ɵɵngDeclareClassMetadata({
 		{ type: i4.Router }
 	]
 });
+var ExternalLoginService = class ExternalLoginService {
+	static {
+		this.google = "Google";
+	}
+	static {
+		this.microsoft = "Microsoft";
+	}
+	static {
+		this.apple = "Apple";
+	}
+	static {
+		this.googleScript = "https://accounts.google.com/gsi/client";
+	}
+	static {
+		this.appleScript = "https://appleid.cdn-apple.com/appleauth/static/jsapi/appleid/1/fr_FR/appleid.auth.js";
+	}
+	constructor(zone) {
+		this.zone = zone;
+		this.scripts = {};
+	}
+	renderGoogleButton(container, provider, onToken) {
+		return this.loadScript(ExternalLoginService.googleScript).then(() => {
+			google.accounts.id.initialize({
+				client_id: provider.ClientId,
+				callback: (response) => this.zone.run(() => onToken({
+					provider: ExternalLoginService.google,
+					idToken: response.credential
+				}))
+			});
+			google.accounts.id.renderButton(container, {
+				type: "standard",
+				theme: "outline",
+				size: "large",
+				text: "continue_with",
+				shape: "rectangular",
+				logo_alignment: "center",
+				locale: "fr",
+				width: Math.min(400, Math.max(200, container.offsetWidth || 300))
+			});
+		});
+	}
+	signInWithMicrosoft(provider) {
+		const nonce = this.random();
+		const state = this.random();
+		const url = `https://login.microsoftonline.com/${encodeURIComponent(provider.TenantId || "common")}/oauth2/v2.0/authorize?client_id=${encodeURIComponent(provider.ClientId)}&response_type=id_token&response_mode=fragment&scope=${encodeURIComponent("openid profile email")}&redirect_uri=${encodeURIComponent(this.redirectUri)}&nonce=${nonce}&state=${state}&prompt=select_account`;
+		return this.openPopup(url).then((params) => {
+			if (params.get("error")) throw new Error(params.get("error_description") || params.get("error"));
+			const idToken = params.get("id_token");
+			if (!idToken || params.get("state") !== state || this.readPayload(idToken).nonce !== nonce) throw new Error("Réponse de Microsoft inattendue.");
+			return {
+				provider: ExternalLoginService.microsoft,
+				idToken
+			};
+		});
+	}
+	signInWithApple(provider) {
+		return this.loadScript(ExternalLoginService.appleScript).then(() => {
+			AppleID.auth.init({
+				clientId: provider.ClientId,
+				scope: "name email",
+				redirectURI: this.redirectUri,
+				state: this.random(),
+				usePopup: true
+			});
+			return AppleID.auth.signIn();
+		}).then((response) => {
+			const idToken = response && response.authorization && response.authorization.id_token;
+			if (!idToken) throw new Error("Réponse d'Apple inattendue.");
+			const name = response.user && response.user.name || {};
+			return {
+				provider: ExternalLoginService.apple,
+				idToken,
+				firstName: name.firstName,
+				lastName: name.lastName
+			};
+		});
+	}
+	isCancellation(error) {
+		const code = error && (error.error || error.message);
+		return code === "popup_closed" || code === "popup_closed_by_user" || code === "user_cancelled_authorize";
+	}
+	get redirectUri() {
+		return window.location.origin;
+	}
+	openPopup(url) {
+		const width = 500, height = 650;
+		const left = window.screenX + Math.max(0, (window.outerWidth - width) / 2);
+		const top = window.screenY + Math.max(0, (window.outerHeight - height) / 2);
+		const popup = window.open(url, "dflat-external-login", `width=${width},height=${height},left=${left},top=${top}`);
+		return new Promise((resolve, reject) => {
+			if (!popup) {
+				reject(/* @__PURE__ */ new Error("La fenêtre de connexion a été bloquée par le navigateur."));
+				return;
+			}
+			this.zone.runOutsideAngular(() => {
+				const timer = window.setInterval(() => {
+					if (popup.closed) {
+						window.clearInterval(timer);
+						this.zone.run(() => reject(/* @__PURE__ */ new Error("popup_closed")));
+						return;
+					}
+					let hash = null;
+					try {
+						if (popup.location.origin === window.location.origin) hash = popup.location.hash;
+					} catch {}
+					if (hash && (hash.indexOf("id_token=") >= 0 || hash.indexOf("error=") >= 0)) {
+						window.clearInterval(timer);
+						popup.close();
+						this.zone.run(() => resolve(new URLSearchParams(hash.replace(/^#\/?/, ""))));
+					}
+				}, 200);
+			});
+		});
+	}
+	loadScript(src) {
+		if (!this.scripts[src]) this.scripts[src] = new Promise((resolve, reject) => {
+			const script = document.createElement("script");
+			script.src = src;
+			script.async = true;
+			script.onload = () => resolve();
+			script.onerror = () => {
+				delete this.scripts[src];
+				reject(/* @__PURE__ */ new Error("Le service de connexion est injoignable."));
+			};
+			document.head.appendChild(script);
+		});
+		return this.scripts[src];
+	}
+	random() {
+		const bytes = /* @__PURE__ */ new Uint8Array(16);
+		window.crypto.getRandomValues(bytes);
+		return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+	}
+	readPayload(token) {
+		try {
+			const part = token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
+			return JSON.parse(decodeURIComponent(atob(part).split("").map((c) => "%" + c.charCodeAt(0).toString(16).padStart(2, "0")).join("")));
+		} catch {
+			return {};
+		}
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: ExternalLoginService,
+			deps: [{ token: i0.NgZone }],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: ExternalLoginService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: ExternalLoginService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: i0.NgZone }]
+});
 var BreadcrumbService = class BreadcrumbService {
 	constructor(title) {
 		this.title = title;
@@ -1397,6 +1592,79 @@ i0.ɵɵngDeclareClassMetadata({
 		{ type: i7.EnvironmentBase }
 	]
 });
+var InitCacheService = class InitCacheService {
+	static {
+		this.CACHE_STAMP = "cachestamp";
+	}
+	static {
+		this.USER_ACCOUNT_ID = "id";
+	}
+	constructor(busMsg, localStorage) {
+		this.entries = /* @__PURE__ */ new Map();
+		this.stamp = this.readStamp(localStorage.getDataObject(AppKeys.ACCESS_TOKEN));
+		busMsg.of(UserUpdatedMessage).subscribe((message) => this.onTokenChanged(message.userKey));
+	}
+	get(key, factory) {
+		let entry = this.entries.get(key);
+		if (!entry) {
+			entry = factory().pipe(catchError((error) => {
+				if (this.entries.get(key) === entry) this.entries.delete(key);
+				return throwError(() => error);
+			}), shareReplay(1));
+			this.entries.set(key, entry);
+		}
+		return entry.pipe(map((value) => Utilities.deepCopy(value)));
+	}
+	clear(prefix) {
+		if (Utilities.IsNil(prefix)) {
+			this.entries.clear();
+			return;
+		}
+		Array.from(this.entries.keys()).filter((key) => key.startsWith(prefix)).forEach((key) => this.entries.delete(key));
+	}
+	onTokenChanged(token) {
+		const stamp = this.readStamp(token);
+		if (stamp !== this.stamp) {
+			this.stamp = stamp;
+			this.clear();
+		}
+	}
+	readStamp(token) {
+		if (!token) return null;
+		try {
+			const decoded = jwt_decode(token);
+			return `${decoded[InitCacheService.CACHE_STAMP]}|${decoded[InitCacheService.USER_ACCOUNT_ID]}`;
+		} catch {
+			return null;
+		}
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: InitCacheService,
+			deps: [{ token: BusMessageService }, { token: LocalStoreManager }],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: InitCacheService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: InitCacheService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: BusMessageService }, { type: LocalStoreManager }]
+});
 var MessagesService = class MessagesService {
 	constructor() {
 		this.messagesList = [];
@@ -1591,12 +1859,14 @@ var CoreServicesModule = class CoreServicesModule extends EnsureModuleLoadedOnce
 				UserService,
 				AuthGuard,
 				AuthService,
+				ExternalLoginService,
 				HeadersService,
 				BusMessageService,
 				BreadcrumbService,
 				ScreenService,
 				AppConfiguration,
 				HubService,
+				InitCacheService,
 				NotificationMqService,
 				FilterService,
 				provideHttpClient(withXhr(), withInterceptorsFromDi())
@@ -1625,12 +1895,14 @@ i0.ɵɵngDeclareClassMetadata({
 				UserService,
 				AuthGuard,
 				AuthService,
+				ExternalLoginService,
 				HeadersService,
 				BusMessageService,
 				BreadcrumbService,
 				ScreenService,
 				AppConfiguration,
 				HubService,
+				InitCacheService,
 				NotificationMqService,
 				FilterService,
 				provideHttpClient(withXhr(), withInterceptorsFromDi())
@@ -1842,6 +2114,6 @@ i0.ɵɵngDeclareClassMetadata({
 		}]
 	}]
 });
-export { AppConfiguration, AppKeys, ApplicationMenuService, AuthGuard, AuthInterceptor, AuthService, AuthTokenType, BreadcrumbService, BusMessageService, CanActivateGuard, CoreServicesModule, FilterService, GeolocationService, HeadersService, HubService, LocalStoreManager, MODULE_MENU_SERVICES, MenuItem, MenuService, MessagesService, NotificationMqService, NotificationsService, PermissionService, ScreenService, ServerUrl, UserService, trimChar };
+export { AppConfiguration, AppKeys, ApplicationMenuService, AuthGuard, AuthInterceptor, AuthService, AuthTokenType, BreadcrumbService, BusMessageService, CanActivateGuard, CoreServicesModule, ExternalLoginService, FilterService, GeolocationService, HeadersService, HubService, InitCacheService, LocalStoreManager, MODULE_MENU_SERVICES, MenuItem, MenuService, MessagesService, NotificationMqService, NotificationsService, PermissionService, ScreenService, ServerUrl, UserService, trimChar };
 
 //# sourceMappingURL=dflat-core-web-core-services.mjs.map