@esfaenza/extensions 15.2.45 → 16.2.0

package/esm2022/lib/services/extensions.embedding.service.mjs

@@ -0,0 +1,213 @@
+// Angular
+import { Injectable } from "@angular/core";
+// Libraries
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "./extensions.messages.service";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/common";
+/* Classe che contiene tutte le informazioni sull'embedding in un unico contenitore per semplicità */
+export class AppEmbeddingExtensions {
+    msgService;
+    router;
+    location;
+    sidebarWidth = 230;
+    Embedded = false;
+    EmbeddingLevel = 0;
+    MainWindow;
+    MessageObserver = new Subject();
+    _reloadAllowed = true;
+    EmbeddedModule;
+    constructor(msgService, router, location) {
+        this.msgService = msgService;
+        this.router = router;
+        this.location = location;
+        this.MainWindow = window;
+        while (this.MainWindow.parent != this.MainWindow) {
+            this.MainWindow = this.MainWindow.parent;
+            this.EmbeddingLevel++;
+            this.Embedded = true;
+            // Fallback per farlo funzionare forzatamente mentre lo testo
+            this.EmbeddedModule = this.location.path().match(/module=([a-zA-Z_]+)/)?.[1];
+            if (!this.EmbeddedModule)
+                this.waitForMyConfigAndForceEmbeddedModule();
+        }
+        this.configureEmbeddability();
+        if (this.Embedded)
+            this.msgService.configureEmbeddability(this.MainWindow, this.MessageObserver);
+    }
+    waitForMyConfigAndForceEmbeddedModule() {
+        // Aspetto di ricevere il myconfig e setto con lui l'embeddedmodule. Questo viene eseguito solo se this.location.path() per qualche motivo non contiene il module
+        let interval = setInterval(() => {
+            if (myconfig?.AppData?.ModuleId) {
+                this.EmbeddedModule = myconfig.AppData.ModuleId;
+                clearInterval(interval);
+            }
+        }, 250);
+    }
+    IsReloadAllowed() {
+        let ret = this._reloadAllowed;
+        this._reloadAllowed = true;
+        return ret;
+    }
+    configureEmbeddability() {
+        window.onmessage = (event) => {
+            // Ignoro i miei messaggi dato che mi interessano solo quelli degli altri iframe
+            if (event.source == window && event?.data?.type != "modal-open")
+                return;
+            this.MessageObserver.next({ event: "window-message", data: event?.data });
+            if (event?.data?.type == "alert") {
+                console.log(`Window message - alert -> Level: ${event?.data?.level}, Message: ${event?.data?.msg}`);
+                switch (event?.data?.level) {
+                    case "success":
+                        this.msgService.simpleSuccess(event?.data?.msg);
+                        break;
+                    case "warning":
+                        this.msgService.simpleWarning(event?.data?.msg);
+                        break;
+                    case "error":
+                        this.msgService.simpleError(event?.data?.msg);
+                        break;
+                    case "info":
+                        this.msgService.simpleInfo(event?.data?.msg);
+                        break;
+                }
+            }
+            else if (event?.data?.type == "replace-state") {
+                console.log(`Window message - replace-state -> Url: ${event?.data?.url}`);
+                this.location.replaceState(event?.data?.url);
+            }
+            else if (event?.data?.type == "confirm") {
+                console.log(`Window message - confirm -> Level: ${event?.data?.level}, Message: ${event?.data?.text}, Title: ${event?.data?.title}, ID: ${event?.data?.guid}`);
+                var sourceWindow = event.source;
+                var baseResponse = { type: "confirm-response", guid: event?.data?.guid };
+                switch (event?.data?.level) {
+                    case "success":
+                        this.msgService.simpleSuccessWithChoice(event?.data?.title, event?.data?.text, () => {
+                            sourceWindow.postMessage({ result: true, ...baseResponse }, "*");
+                        }, () => {
+                            sourceWindow.postMessage({ result: false, ...baseResponse }, "*");
+                        });
+                        break;
+                    case "warning":
+                        this.msgService.simpleWarningWithChoice(event?.data?.title, event?.data?.text, () => {
+                            sourceWindow.postMessage({ result: true, ...baseResponse }, "*");
+                        }, () => {
+                            sourceWindow.postMessage({ result: false, ...baseResponse }, "*");
+                        });
+                        break;
+                }
+            }
+            else if (event?.data?.type == "navigate") {
+                console.log(`Window message - navigate -> ${event?.data?.url}`);
+                var newTab = event?.data?.newTab;
+                var replaceState = event?.data?.replaceState;
+                // Controllo se il router sta seguendo la chiamata attuale. Escludo i query params che sono gli unici che possono essere seccati dai replaceState
+                // e che potrebbero fare del casino
+                if (!window.location.href.includes(this.router.url.split("?")[0])) {
+                    console.warn("Doppia chiamata di navigazione, ignoro il secondo evento scoordinato dal router");
+                    return;
+                }
+                let newRelativeUrl = this.router.createUrlTree([event?.data?.url]);
+                let baseUrl = window.location.href.replace(this.router.url.replace("?ignoreStorage=true", ''), '');
+                let newUrl = baseUrl + decodeURIComponent(newRelativeUrl.toString());
+                if (replaceState)
+                    history.pushState({ _pushed: true }, "", newUrl);
+                else if (newTab)
+                    window.open(newUrl, '_blank');
+            }
+            else if (event?.data?.type == "navigate-back") {
+                console.log(`Window message - navigate-back -> ${event?.data?.url}`);
+                if (history.state._pushed) {
+                    this._reloadAllowed = false;
+                    history.back();
+                }
+            }
+            else if (event?.data?.type == "redirect") {
+                console.log(`Window message - redirect -> ${event?.data?.url}`);
+                window.location.href = event?.data?.url;
+            }
+            else if (event?.data?.type == "navigation") {
+                console.log(`Window message - Navigation -> ${event?.data?.internalNavigation ? "[internal]" : ""} ${event?.data?.title}`);
+                this.MessageObserver.next({ event: "navigation", data: event?.data });
+            }
+            else if (event?.data?.type == "modal-open") {
+                const wrapper = document.body.getElementsByClassName("main-wrapper")[0];
+                let wrapperStyles = window.getComputedStyle(wrapper);
+                const wrapperPaddingLeft = parseInt(wrapperStyles.getPropertyValue("padding-left"));
+                const wrapperPaddingRight = parseInt(wrapperStyles.getPropertyValue("padding-right"));
+                console.log(`Window message - Modal Open -> Backdrop Height: ${event?.data?.backdropHeight}`);
+                var topHeight = 80; // valore fisso, distanza fra il top e l'inizio dell'iframe, non sarà mai diverso
+                var rightSpace = wrapperPaddingRight; // valore fisso, distanza fra la fine dell'iframe e il lato sinistro dello schermo, non sarà mai diverso
+                var leftSpace = this.sidebarWidth + wrapperPaddingLeft;
+                let commonStyles = "position: absolute; z-index: 9999; background-color: #000; opacity: 0.5; ";
+                wrapper.style.setProperty("overflow", "hidden", "important");
+                const top = document.createElement("div");
+                top.className = "embedded-modal-top";
+                top.style.cssText = commonStyles + `height: ${topHeight}px; top: 0; width: calc(100% - ${leftSpace}px); left: ${leftSpace}px`;
+                top.id = "top";
+                const left = document.createElement("div");
+                left.className = "embedded-modal-left";
+                left.style.cssText = commonStyles + `height: 100%; top: 0; width: ${leftSpace}px;`;
+                left.id = "left";
+                const right = document.createElement("div");
+                right.className = "embedded-modal-right";
+                right.style.cssText = commonStyles + `height: calc(100% - ${topHeight}px); top: ${topHeight}px; right: 0; width: ${rightSpace}px;`;
+                right.id = "right";
+                // const bottom = document.createElement("div");
+                // bottom.className = "embedded-modal-bottom";
+                // bottom.style.cssText = commonStyles + `height: ${topHeight}px; bottom: 0; width: calc(100% - ${leftSpace}px); left: ${leftSpace}px`;
+                // bottom.id = "bottom";
+                document.body.appendChild(top);
+                document.body.appendChild(left);
+                document.body.appendChild(right);
+            }
+            else if (event?.data?.type == "modal-close") {
+                console.log(`Window message - Modal Close`);
+                let wrapper = document.body.getElementsByClassName("main-wrapper")[0];
+                wrapper.style.removeProperty("overflow");
+                const top = document.getElementById("top");
+                const left = document.getElementById("left");
+                const right = document.getElementById("right");
+                if (top)
+                    document.body.removeChild(top);
+                if (left)
+                    document.body.removeChild(left);
+                if (right)
+                    document.body.removeChild(right);
+            }
+        };
+        if (this.Embedded)
+            document.body.style.setProperty("overflow-y", "auto", "important");
+    }
+    replaceState(basePath, url) {
+        // Esempio basePath: pages
+        // Esempio url: parties/leads_search
+        // Normalizzazione senza slash prima o dopo
+        basePath = basePath.endsWith("/") ? basePath.substring(0, basePath.length - 2) : basePath;
+        url = url.startsWith("/") ? url.substring(1) : url;
+        this.location.replaceState(`${basePath}/${url}`);
+        this.MainWindow.postMessage({ type: "replace-state", url: `pages/embed/${this.EmbeddedModule}/${url}` }, "*");
+    }
+    refreshBoundariesOnMenuCollapse() {
+        const wrapper = document.body.getElementsByClassName("main-wrapper")[0];
+        let wrapperStyles = window.getComputedStyle(wrapper);
+        const wrapperPaddingLeft = parseInt(wrapperStyles.getPropertyValue("padding-left"));
+        var leftSpace = 230 + wrapperPaddingLeft;
+        const left = document.getElementById("left");
+        const top = document.getElementById("top");
+        if (top) {
+            top.style.setProperty("left", (leftSpace) + "px");
+            top.style.setProperty("width", `calc(100% - ${leftSpace}px)`);
+        }
+        if (left)
+            left.style.setProperty("width", leftSpace + "px");
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AppEmbeddingExtensions, deps: [{ token: i1.MessageService }, { token: i2.Router }, { token: i3.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AppEmbeddingExtensions, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AppEmbeddingExtensions, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i1.MessageService }, { type: i2.Router }, { type: i3.Location }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extensions.embedding.service.js","sourceRoot":"","sources":["../../../../../projects/extensions/src/lib/services/extensions.embedding.service.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { Injectable } from \"@angular/core\";\r\nimport { Location } from \"@angular/common\";\r\nimport { Router } from \"@angular/router\";\r\n\r\n// Services\r\nimport { MessageService } from \"./extensions.messages.service\";\r\n\r\n// Libraries\r\nimport { Subject } from \"rxjs\";\r\n\r\ndeclare var myconfig: { AppData: { ModuleId: string }; };\r\n\r\n/* Classe che contiene tutte le informazioni sull'embedding in un unico contenitore per semplicità */\r\n@Injectable({ providedIn: \"root\" })\r\nexport class AppEmbeddingExtensions {\r\n\r\n    public sidebarWidth: number = 230;\r\n\r\n    public Embedded: boolean = false;\r\n    public EmbeddingLevel: number = 0;\r\n    public MainWindow: any;\r\n\r\n    public MessageObserver: Subject<{ event: any, data: any }> = new Subject<{ event: any, data: any }>();\r\n\r\n    private _reloadAllowed: boolean = true;\r\n\r\n    public EmbeddedModule: string;\r\n\r\n    constructor(private msgService: MessageService, private router: Router, private location: Location) {\r\n        this.MainWindow = <{ parent: any, postMessage: Function }>window;\r\n        while (this.MainWindow.parent != this.MainWindow) {\r\n            this.MainWindow = this.MainWindow.parent;\r\n            this.EmbeddingLevel++;\r\n            this.Embedded = true;\r\n\r\n            // Fallback per farlo funzionare forzatamente mentre lo testo\r\n            this.EmbeddedModule = this.location.path().match(/module=([a-zA-Z_]+)/)?.[1];\r\n\r\n            if(!this.EmbeddedModule)\r\n                this.waitForMyConfigAndForceEmbeddedModule();\r\n        }\r\n\r\n        this.configureEmbeddability();\r\n\r\n        if (this.Embedded)\r\n            this.msgService.configureEmbeddability(this.MainWindow, this.MessageObserver)\r\n    }\r\n\r\n    private waitForMyConfigAndForceEmbeddedModule() {\r\n\r\n        // Aspetto di ricevere il myconfig e setto con lui l'embeddedmodule. Questo viene eseguito solo se this.location.path() per qualche motivo non contiene il module\r\n        let interval = setInterval(() => {\r\n            if (myconfig?.AppData?.ModuleId) {\r\n                this.EmbeddedModule = myconfig.AppData.ModuleId;\r\n                clearInterval(interval);\r\n            }\r\n        }, 250);\r\n    }\r\n\r\n    public IsReloadAllowed() {\r\n        let ret = this._reloadAllowed;\r\n        this._reloadAllowed = true;\r\n        return ret;\r\n    }\r\n\r\n    configureEmbeddability() {\r\n        window.onmessage = (event: MessageEvent) => {\r\n            // Ignoro i miei messaggi dato che mi interessano solo quelli degli altri iframe\r\n            if (event.source == window && event?.data?.type != \"modal-open\")\r\n                return;\r\n\r\n            this.MessageObserver.next({ event: \"window-message\", data: event?.data });\r\n\r\n            if (event?.data?.type == \"alert\") {\r\n                console.log(`Window message - alert -> Level: ${event?.data?.level}, Message: ${event?.data?.msg}`);\r\n\r\n                switch (event?.data?.level) {\r\n                    case \"success\": this.msgService.simpleSuccess(event?.data?.msg); break;\r\n                    case \"warning\": this.msgService.simpleWarning(event?.data?.msg); break;\r\n                    case \"error\": this.msgService.simpleError(event?.data?.msg); break;\r\n                    case \"info\": this.msgService.simpleInfo(event?.data?.msg); break;\r\n                }\r\n            }\r\n            else if (event?.data?.type == \"replace-state\") {\r\n                console.log(`Window message - replace-state -> Url: ${event?.data?.url}`);\r\n\r\n                this.location.replaceState(event?.data?.url);\r\n            }\r\n            else if (event?.data?.type == \"confirm\") {\r\n                console.log(`Window message - confirm -> Level: ${event?.data?.level}, Message: ${event?.data?.text}, Title: ${event?.data?.title}, ID: ${event?.data?.guid}`);\r\n\r\n                var sourceWindow = (event.source as Window);\r\n                var baseResponse = { type: \"confirm-response\", guid: event?.data?.guid };\r\n\r\n                switch (event?.data?.level) {\r\n                    case \"success\":\r\n                        this.msgService.simpleSuccessWithChoice(event?.data?.title, event?.data?.text, () => {\r\n                            sourceWindow.postMessage({ result: true, ...baseResponse }, \"*\")\r\n                        }, () => {\r\n                            sourceWindow.postMessage({ result: false, ...baseResponse }, \"*\")\r\n                        });\r\n                        break;\r\n                    case \"warning\":\r\n                        this.msgService.simpleWarningWithChoice(event?.data?.title, event?.data?.text, () => {\r\n                            sourceWindow.postMessage({ result: true, ...baseResponse }, \"*\")\r\n                        }, () => {\r\n                            sourceWindow.postMessage({ result: false, ...baseResponse }, \"*\")\r\n                        });\r\n                        break;\r\n                }\r\n\r\n            }\r\n            else if (event?.data?.type == \"navigate\") {\r\n                console.log(`Window message - navigate -> ${event?.data?.url}`);\r\n                var newTab = event?.data?.newTab;\r\n                var replaceState = event?.data?.replaceState\r\n\r\n                // Controllo se il router sta seguendo la chiamata attuale. Escludo i query params che sono gli unici che possono essere seccati dai replaceState\r\n                // e che potrebbero fare del casino\r\n                if (!window.location.href.includes(this.router.url.split(\"?\")[0])) {\r\n                    console.warn(\"Doppia chiamata di navigazione, ignoro il secondo evento scoordinato dal router\");\r\n                    return;\r\n                }\r\n\r\n                let newRelativeUrl = this.router.createUrlTree([event?.data?.url]);\r\n                let baseUrl = window.location.href.replace(this.router.url.replace(\"?ignoreStorage=true\" , ''), '');\r\n                let newUrl = baseUrl + decodeURIComponent(newRelativeUrl.toString());\r\n\r\n                if (replaceState)\r\n                    history.pushState({ _pushed: true }, \"\", newUrl);\r\n                else if (newTab)\r\n                    window.open(newUrl, '_blank');\r\n            }\r\n            else if (event?.data?.type == \"navigate-back\") {\r\n                console.log(`Window message - navigate-back -> ${event?.data?.url}`);\r\n                if (history.state._pushed) {\r\n                    this._reloadAllowed = false;\r\n                    history.back();\r\n                }\r\n            }\r\n            else if (event?.data?.type == \"redirect\") {\r\n                console.log(`Window message - redirect -> ${event?.data?.url}`);\r\n\r\n                window.location.href = event?.data?.url;\r\n            }\r\n            else if (event?.data?.type == \"navigation\") {\r\n                console.log(`Window message - Navigation -> ${event?.data?.internalNavigation ? \"[internal]\" : \"\"} ${event?.data?.title}`);\r\n\r\n                this.MessageObserver.next({ event: \"navigation\", data: event?.data });\r\n            }\r\n            else if (event?.data?.type == \"modal-open\") {\r\n                const wrapper = document.body.getElementsByClassName(\"main-wrapper\")[0] as HTMLElement;\r\n                let wrapperStyles = window.getComputedStyle(wrapper);\r\n                const wrapperPaddingLeft = parseInt(wrapperStyles.getPropertyValue(\"padding-left\"));\r\n                const wrapperPaddingRight = parseInt(wrapperStyles.getPropertyValue(\"padding-right\"));\r\n\r\n                console.log(`Window message - Modal Open -> Backdrop Height: ${event?.data?.backdropHeight}`);\r\n\r\n                var topHeight: number = 80; // valore fisso, distanza fra il top e l'inizio dell'iframe, non sarà mai diverso\r\n                var rightSpace: number = wrapperPaddingRight; // valore fisso, distanza fra la fine dell'iframe e il lato sinistro dello schermo, non sarà mai diverso\r\n                var leftSpace: number = this.sidebarWidth + wrapperPaddingLeft;\r\n\r\n                let commonStyles = \"position: absolute; z-index: 9999; background-color: #000; opacity: 0.5; \";\r\n\r\n                wrapper.style.setProperty(\"overflow\", \"hidden\", \"important\");\r\n\r\n                const top = document.createElement(\"div\");\r\n                top.className = \"embedded-modal-top\";\r\n                top.style.cssText = commonStyles + `height: ${topHeight}px; top: 0; width: calc(100% - ${leftSpace}px); left: ${leftSpace}px`;\r\n                top.id = \"top\";\r\n\r\n                const left = document.createElement(\"div\");\r\n                left.className = \"embedded-modal-left\";\r\n                left.style.cssText = commonStyles + `height: 100%; top: 0; width: ${leftSpace}px;`;\r\n                left.id = \"left\";\r\n\r\n                const right = document.createElement(\"div\");\r\n                right.className = \"embedded-modal-right\";\r\n                right.style.cssText = commonStyles + `height: calc(100% - ${topHeight}px); top: ${topHeight}px; right: 0; width: ${rightSpace}px;`;\r\n                right.id = \"right\";\r\n\r\n                // const bottom = document.createElement(\"div\");\r\n                // bottom.className = \"embedded-modal-bottom\";\r\n                // bottom.style.cssText = commonStyles + `height: ${topHeight}px; bottom: 0; width: calc(100% - ${leftSpace}px); left: ${leftSpace}px`;\r\n                // bottom.id = \"bottom\";\r\n\r\n                document.body.appendChild(top);\r\n                document.body.appendChild(left);\r\n                document.body.appendChild(right);\r\n            }\r\n            else if (event?.data?.type == \"modal-close\") {\r\n                console.log(`Window message - Modal Close`);\r\n\r\n                let wrapper = document.body.getElementsByClassName(\"main-wrapper\")[0] as HTMLElement;\r\n                wrapper.style.removeProperty(\"overflow\");\r\n\r\n                const top = document.getElementById(\"top\");\r\n                const left = document.getElementById(\"left\");\r\n                const right = document.getElementById(\"right\");\r\n\r\n                if (top)\r\n                    document.body.removeChild(top);\r\n                if (left)\r\n                    document.body.removeChild(left);\r\n                if (right)\r\n                    document.body.removeChild(right);\r\n            }\r\n        };\r\n\r\n        if (this.Embedded)\r\n            document.body.style.setProperty(\"overflow-y\", \"auto\", \"important\");\r\n    }\r\n\r\n    public replaceState(basePath: string, url: string) {\r\n        // Esempio basePath: pages\r\n        // Esempio url: parties/leads_search\r\n\r\n        // Normalizzazione senza slash prima o dopo\r\n        basePath = basePath.endsWith(\"/\") ? basePath.substring(0, basePath.length -2) : basePath;\r\n        url = url.startsWith(\"/\") ? url.substring(1) : url;\r\n\r\n        this.location.replaceState(`${basePath}/${url}`);\r\n        this.MainWindow.postMessage({ type: \"replace-state\", url: `pages/embed/${this.EmbeddedModule}/${url}` }, \"*\");\r\n    }\r\n\r\n    public refreshBoundariesOnMenuCollapse() {\r\n        const wrapper = document.body.getElementsByClassName(\"main-wrapper\")[0] as HTMLElement;\r\n        let wrapperStyles = window.getComputedStyle(wrapper);\r\n        const wrapperPaddingLeft = parseInt(wrapperStyles.getPropertyValue(\"padding-left\"));\r\n        var leftSpace: number = 230 + wrapperPaddingLeft;\r\n\r\n        const left = document.getElementById(\"left\");\r\n        const top = document.getElementById(\"top\");\r\n\r\n        if (top) {\r\n            top.style.setProperty(\"left\", (leftSpace) + \"px\");\r\n            top.style.setProperty(\"width\", `calc(100% - ${leftSpace}px)`);\r\n        }\r\n\r\n        if (left)\r\n            left.style.setProperty(\"width\", leftSpace + \"px\");\r\n    }\r\n}"]}