@sinequa/atomic-angular 0.0.146

package/esm2022/lib/utils/query.mjs

@@ -0,0 +1,58 @@
+import { assertInInjectionContext, inject } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { getQueryParamsFromUrl } from '@sinequa/atomic';
+/**
+ * Retrieves the query name from the current route.
+ *
+ * @remarks
+ * This function must be used within an injection context.
+ *
+ * This function traverses the route tree recursively to find the query name.
+ * It first checks for a query parameter `t` in the route's snapshot. If the query name is not found
+ * in the route data, it attempts to find it in the child routes of the "search" route.
+ * If the query name is still not found, it falls back to the `queryName` defined in the route's data.
+ *
+ * @returns {string | undefined} The query name if found, otherwise `undefined`.
+ */
+export function getQueryNameFromRoute() {
+    assertInInjectionContext(getQueryNameFromRoute);
+    const route = inject(ActivatedRoute);
+    const routes = inject(Router);
+    const recursive = (route) => {
+        if (route?.firstChild)
+            return recursive(route.firstChild);
+        // Get query name from route data
+        const { t } = route.snapshot.queryParams;
+        // ! This is a workaround for the case where the queryName is not defined in the route data
+        // "search" is the parent route of the search results, and "t" is the query parameter for the tab
+        const { queryName } = routes.config.filter(p => p.path === "search")[0].children?.find(route => route.path === t)?.data || {};
+        if (queryName)
+            return queryName;
+        // fallback to queryName from route data
+        if (route?.snapshot.data['queryName'])
+            return route.snapshot.data['queryName'];
+        return undefined;
+    };
+    return recursive(route);
+}
+/**
+ * Builds a query object based on the provided partial query.
+ * If any properties are missing in the partial query, default values are used.
+ *
+ * @remarks
+ * This function must be used within an injection context.
+ *
+ * @param query - The partial query object.
+ * @returns The complete query object.
+ */
+export function buildQuery(query) {
+    assertInInjectionContext(buildQuery);
+    const name = query?.name || getQueryNameFromRoute();
+    const params = getQueryParamsFromUrl(window.location.toString());
+    return {
+        ...params, // default values retrieved from the URL
+        ...query, // override with query
+        name, // override with query name
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/routes.mjs

@@ -0,0 +1,28 @@
+import { assertInInjectionContext, inject } from "@angular/core";
+import { ActivatedRoute, Router } from "@angular/router";
+/**
+ * Retrieves the current path from the Angular `ActivatedRoute` service.
+ *
+ * @returns {string | undefined} The current path as a string, or `undefined` if the path cannot be determined.
+ */
+export function getCurrentPath() {
+    assertInInjectionContext(getCurrentPath);
+    const route = inject(ActivatedRoute);
+    return route?.snapshot.url.toString();
+}
+/**
+ * Retrieves the current query name based on the current path and router configuration.
+ *
+ * This function asserts that it is being called within an injection context and then
+ * uses Angular's dependency injection to get the router configuration. It matches the
+ * current path against the router's configuration to find the corresponding query name.
+ *
+ * @returns {string | undefined} The name of the current query if found, otherwise undefined.
+ */
+export function getCurrentQueryName() {
+    assertInInjectionContext(getCurrentQueryName);
+    const routes = inject(Router).config;
+    const path = getCurrentPath();
+    return routes.find(r => r.path === 'search')?.children?.find(r => r.path === path)?.data?.['queryName'];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/tailwind-utils.mjs

@@ -0,0 +1,6 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFpbHdpbmQtdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL3V0aWxzL3RhaWx3aW5kLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBbUIsSUFBSSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQzdDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUV6QyxNQUFNLFVBQVUsRUFBRSxDQUFDLEdBQUcsTUFBb0I7SUFDeEMsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7QUFDL0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgQ2xhc3NWYWx1ZSwgY2xzeCB9IGZyb20gJ2Nsc3gnO1xyXG5pbXBvcnQgeyB0d01lcmdlIH0gZnJvbSAndGFpbHdpbmQtbWVyZ2UnO1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIGNuKC4uLmlucHV0czogQ2xhc3NWYWx1ZVtdKSB7XHJcbiAgcmV0dXJuIHR3TWVyZ2UoY2xzeChpbnB1dHMpKTtcclxufVxyXG4iXX0=

package/esm2022/lib/utils/theme-body-hook.mjs

@@ -0,0 +1,18 @@
+import { effect, inject, runInInjectionContext } from "@angular/core";
+import { applyThemeToNativeElement, ThemeStore } from "../stores";
+export function withThemeBodyHook(app, params) {
+    runInInjectionContext(app.injector, () => {
+        const themeStore = inject(ThemeStore);
+        const { scope, theme } = params || { scope: 'application', theme: 'Default' };
+        themeStore.setCurrentTheme(scope, theme);
+        applyThemeToNativeElement(window.document.body, themeStore.scopes()?.[scope]?.cssVars?.light);
+        effect(() => {
+            const bodyScope = themeStore.scopes()?.[scope];
+            const vars = bodyScope.darkMode ? bodyScope.cssVars.dark : bodyScope.cssVars.light;
+            if (vars)
+                applyThemeToNativeElement(window.document.body, vars);
+        });
+    });
+    return app;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/theme-registry.mjs

@@ -0,0 +1,6 @@
+import { THEMES } from "../resources";
+export function withThemes(app, themes) {
+    themes.forEach(theme => THEMES.push(theme));
+    return app;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUtcmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL3V0aWxzL3RoZW1lLXJlZ2lzdHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBUyxNQUFNLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFN0MsTUFBTSxVQUFVLFVBQVUsQ0FBQyxHQUFtQixFQUFFLE1BQWU7SUFDN0QsTUFBTSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUU1QyxPQUFPLEdBQUcsQ0FBQztBQUNiLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBcHBsaWNhdGlvblJlZiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5cbmltcG9ydCB7IFRoZW1lLCBUSEVNRVMgfSBmcm9tIFwiLi4vcmVzb3VyY2VzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiB3aXRoVGhlbWVzKGFwcDogQXBwbGljYXRpb25SZWYsIHRoZW1lczogVGhlbWVbXSk6IEFwcGxpY2F0aW9uUmVmIHtcbiAgdGhlbWVzLmZvckVhY2godGhlbWUgPT4gVEhFTUVTLnB1c2godGhlbWUpKTtcblxuICByZXR1cm4gYXBwO1xufVxuIl19

package/esm2022/lib/web-services/aggregations.service.mjs

@@ -0,0 +1,104 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { catchError, map, tap, throwError } from 'rxjs';
+import { escapeExpr, globalConfig } from '@sinequa/atomic';
+import { AggregationsStore, AppStore } from '../stores';
+import { QueryService } from './query.service';
+import * as i0 from "@angular/core";
+export class AggregationsService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.queryService = inject(QueryService);
+        this.appStore = inject(AppStore);
+        this.aggregationsStore = inject(AggregationsStore);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    loadMore(query, aggregation, audit) {
+        const { app } = globalConfig;
+        // skip cached items for computation
+        const skip = aggregation.items?.filter(i => !(i.$cached))?.length || 0;
+        const count = 10;
+        const aggregations = { [aggregation.name]: { skip, count } };
+        const q = { ...query, action: "aggregate", aggregations };
+        // add audit record if available
+        const $auditRecord = audit ? { auditEvents: [audit] } : undefined;
+        const body = {
+            app,
+            query: q,
+            $auditRecord
+        };
+        return this.http.post(this.API_URL + "/query", body).pipe(map(result => {
+            const { aggregations } = result;
+            const agg = aggregations[0];
+            if (agg.items) {
+                agg.$hasMore = agg.items.length > count;
+                agg.items = [...aggregation.items, ...agg.items];
+            }
+            else {
+                aggregation.$hasMore = false;
+                return aggregation;
+            }
+            return agg;
+        }), catchError(error => {
+            console.log("aggregation.loadMore failure - error: ", error);
+            return throwError(() => new Error(error));
+        }), tap(response => console.log("aggregation.loadMore success - data: ", response)));
+    }
+    open(query, aggregation, item) {
+        const value = `/${item.$path}/*`;
+        const expression = `${aggregation.column}: ${escapeExpr(value)}`;
+        const q = {
+            ...query,
+            action: "open",
+            open: [{ expression, aggregation: aggregation.name }]
+        };
+        return this.queryService.search(q).pipe(map(results => {
+            // find the node in the tree and replace it with the new one
+            const items = results.aggregations[0].items;
+            const newNode = this.findNode(items, item.$path);
+            if (!newNode) {
+                return aggregation;
+            }
+            // mark the node as opened
+            newNode.$opened = true;
+            return this.replaceInTree(aggregation, item.$path, newNode);
+        }));
+    }
+    findNode(items, path = "") {
+        if (!items || items.length === 0) {
+            return undefined;
+        }
+        for (const item of items) {
+            if (item.$path === path) {
+                return item;
+            }
+            if (item.items) {
+                const found = this.findNode(item.items, path);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return undefined;
+    }
+    replaceInTree(tree, valueToFind = "", newValue) {
+        if (tree.$path === valueToFind) {
+            return newValue;
+        }
+        if (tree.hasChildren && tree.items) {
+            for (let i = 0; i < tree.items.length; i++) {
+                tree.items[i] = this.replaceInTree(tree.items[i], valueToFind, newValue);
+            }
+        }
+        return tree;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AggregationsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AggregationsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AggregationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aggregations.service.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/web-services/aggregations.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { Observable, catchError, map, tap, throwError } from 'rxjs';\r\n\r\nimport { Aggregation, AuditEvents, Query, Result, TreeAggregation, TreeAggregationNode, escapeExpr, globalConfig } from '@sinequa/atomic';\r\n\r\nimport { AggregationsStore, AppStore } from '../stores';\r\nimport { QueryService } from './query.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AggregationsService {\r\n  protected readonly http = inject(HttpClient);\r\n  protected readonly queryService = inject(QueryService);\r\n\r\n  appStore = inject(AppStore);\r\n  aggregationsStore = inject(AggregationsStore);\r\n\r\n  protected API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;\r\n\r\n  loadMore(query: Partial<Query>, aggregation: Aggregation, audit?: AuditEvents): Observable<Aggregation> {\r\n    const { app } = globalConfig;\r\n\r\n    // skip cached items for computation\r\n    const skip = aggregation.items?.filter(i => !(i.$cached))?.length || 0;\r\n    const count = 10;\r\n\r\n    const aggregations = { [aggregation.name]: { skip, count } };\r\n\r\n    const q: Partial<Query> = { ...query, action: \"aggregate\", aggregations }\r\n\r\n    // add audit record if available\r\n    const $auditRecord = audit ? { auditEvents: [audit] } : undefined;\r\n\r\n    const body = {\r\n      app,\r\n      query: q,\r\n      $auditRecord\r\n    };\r\n\r\n    return this.http.post(this.API_URL + \"/query\", body).pipe(\r\n      map(result => {\r\n        const { aggregations } = result as Result;\r\n        const agg = aggregations[0];\r\n\r\n        if (agg.items) {\r\n          agg.$hasMore = agg.items.length > count;\r\n          agg.items = [...aggregation.items, ...agg.items];\r\n        } else {\r\n          aggregation.$hasMore = false;\r\n          return aggregation;\r\n        }\r\n\r\n        return agg;\r\n      }),\r\n      catchError(error => {\r\n        console.log(\"aggregation.loadMore failure - error: \", error);\r\n        return throwError(() => new Error(error));\r\n      }),\r\n      tap(response => console.log(\"aggregation.loadMore success - data: \", response)),\r\n    );\r\n  }\r\n\r\n  open(query: Partial<Query>, aggregation: TreeAggregation, item: TreeAggregationNode): Observable<TreeAggregation> {\r\n    const value = `/${item.$path}/*`;\r\n    const expression = `${aggregation.column}: ${escapeExpr(value)}`;\r\n\r\n    const q: Partial<Query> = {\r\n      ...query,\r\n      action: \"open\",\r\n      open: [{ expression, aggregation: aggregation.name }]\r\n    };\r\n\r\n    return this.queryService.search(q).pipe(\r\n      map(results => {\r\n        // find the node in the tree and replace it with the new one\r\n        const items = results.aggregations[0].items as TreeAggregationNode[];\r\n        const newNode = this.findNode(items, item.$path);\r\n\r\n        if (!newNode) {\r\n          return aggregation;\r\n        }\r\n        // mark the node as opened\r\n        newNode.$opened = true;\r\n        return this.replaceInTree(aggregation, item.$path, newNode) as TreeAggregation;\r\n      })\r\n    )\r\n  }\r\n  private findNode(items: TreeAggregationNode[], path: string = \"\"): TreeAggregationNode | undefined {\r\n    if (!items || items.length === 0) {\r\n      return undefined;\r\n    }\r\n\r\n    for (const item of items) {\r\n      if (item.$path === path) {\r\n        return item;\r\n      }\r\n      if(item.items) {\r\n        const found = this.findNode(item.items, path);\r\n        if (found) {\r\n          return found;\r\n        }\r\n      }\r\n    }\r\n\r\n    return undefined;\r\n  }\r\n\r\n  private replaceInTree(tree: any, valueToFind: string = \"\", newValue: TreeAggregationNode) {\r\n    if (tree.$path === valueToFind) {\r\n      return newValue;\r\n    }\r\n\r\n    if (tree.hasChildren && tree.items) {\r\n      for (let i = 0; i < tree.items.length; i++) {\r\n        tree.items[i] = this.replaceInTree(tree.items[i], valueToFind, newValue);\r\n      }\r\n    }\r\n\r\n    return tree;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/web-services/app.service.mjs

@@ -0,0 +1,48 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { catchError, EMPTY } from 'rxjs';
+import { globalConfig } from '@sinequa/atomic';
+import * as i0 from "@angular/core";
+export class AppService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    /**
+     * Retrieves the application configuration from the server.
+     *
+     * @param appName - The name of the application to fetch the configuration for.
+     *
+     * @returns {Observable<CCApp>} An observable that emits the application configuration.
+     *
+     * @remarks
+     * This method constructs an HTTP GET request to fetch the application configuration
+     * using the `app` parameter from the global configuration. If the request fails,
+     * it logs the error to the console and returns an empty observable.
+     *
+     * @example
+     * ```typescript
+     * appService.getApp().subscribe(appConfig => {
+     *   console.log(appConfig);
+     * });
+     * ```
+     */
+    getApp(appName) {
+        const app = appName || globalConfig.app;
+        const params = new HttpParams().set('app', app || '');
+        return this.http.get(this.API_URL + "/app", { params })
+            .pipe(catchError(error => {
+            console.error("AppService.getApp failure - error: ", error);
+            return EMPTY;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AppService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AppService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AppService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/web-services/audit.service.mjs

@@ -0,0 +1,122 @@
+import { HttpClient } from "@angular/common/http";
+import { Injectable, computed, inject } from "@angular/core";
+import { Router } from "@angular/router";
+import { getState } from "@ngrx/signals";
+import { globalConfig } from "@sinequa/atomic";
+import { AppStore } from '../stores/app.store';
+import * as i0 from "@angular/core";
+export class AuditService {
+    constructor() {
+        this.appStore = inject(AppStore);
+        this.app = computed(() => getState(this.appStore));
+        this.http = inject(HttpClient);
+        this.router = inject(Router);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+        this.lastClickTime = 0;
+    }
+    /**
+     * Notify the Sinequa server of a set of audit events
+     *
+     * @param auditEvents The audit events
+     */
+    notify(auditEvents) {
+        this.http.post(this.API_URL + "/audit.notify", {
+            event: "None", // AuditEventType.None,
+            app: this.app().name,
+            $auditRecord: { auditEvents: [auditEvents] }
+        }).subscribe();
+    }
+    /**
+     * It sends an audit event to the Audit Service.
+     */
+    notifyLogin() {
+        this.notify({
+            type: "Login_Success_Form" // AuditEventType.Search_Login_Success
+        });
+    }
+    /**
+     * Notify logout
+     */
+    notifyLogout() {
+        this.notify({
+            type: "Search_Exit_Logout" // AuditEventType.Search_Exit_Logout
+        });
+    }
+    /**
+       * Notify the Sinequa server of a document event
+       *
+       * @param evt The audit event type
+       * @param doc The document (article) in question
+       * @param resultId The resultid that contain the document
+       * @param parameters Additional parameters
+       */
+    notifyDocument(auditEventType, doc, resultsOrId, parameters, rfmParameters) {
+        let resultId;
+        let result;
+        if (typeof resultsOrId == "string") {
+            resultId = resultsOrId;
+        }
+        else {
+            result = resultsOrId;
+            resultId = result ? result.id : null;
+        }
+        const detail = {
+            docid: doc.id,
+            rank: doc.rank,
+            title: doc.title,
+            source: doc.collection[0].split("/")[0],
+            collection: doc.collection[0],
+            resultId,
+            filename: doc.filename,
+            fileext: doc.fileext,
+            index: doc.databasealias,
+            resultcount: result?.totalRowCount
+        };
+        if (parameters) {
+            Object.keys(parameters).forEach(key => detail[key] = parameters[key]);
+        }
+        const data = {
+            type: auditEventType,
+            detail
+        };
+        if (rfmParameters) {
+            const rfmDetail = {}; // Add index signature
+            Object.keys(rfmParameters).forEach(key => rfmDetail[key] = rfmParameters[key]);
+            data.rfmDetail = rfmDetail;
+        }
+        this.lastClickTime = Date.now();
+        // Listen to the navigation event outside the app
+        document.addEventListener('visibilitychange', () => {
+            // Capture the navigation even triggered just after the click
+            if (document.visibilityState === 'hidden' && (Date.now() - this.lastClickTime) < 1000) {
+                // Second event triggered when we come back
+                document.addEventListener('visibilitychange', () => {
+                    if (document.visibilityState === 'visible') {
+                        this.notify({ type: "Navigation_Return" /* AuditEventType.Navigation_Return */ });
+                    }
+                }, { once: true });
+            }
+        }, { once: true });
+        this.notify(data);
+    }
+    /**
+     * Notify route change
+     */
+    notifyRouteChange(url) {
+        this.notify({
+            type: "Navigation_Route", // AuditEventType.Navigation_Route,
+            detail: {
+                detail: url
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AuditService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AuditService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AuditService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audit.service.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/web-services/audit.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\r\nimport { Injectable, computed, inject } from \"@angular/core\";\r\nimport { Router } from \"@angular/router\";\r\nimport { getState } from \"@ngrx/signals\";\r\nimport { Article, AuditEvent, AuditEvents, AuditEventType, AuditEventTypeValues, CCApp, globalConfig, Result } from \"@sinequa/atomic\";\r\nimport { AppStore } from '../stores/app.store';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AuditService {\r\n  appStore = inject(AppStore);\r\n  app = computed(() => getState(this.appStore) as CCApp);\r\n\r\n  protected readonly http = inject(HttpClient);\r\n  protected readonly router = inject(Router);\r\n  protected readonly API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;\r\n\r\n  protected lastClickTime = 0;\r\n\r\n  /**\r\n   * Notify the Sinequa server of a set of audit events\r\n   *\r\n   * @param auditEvents The audit events\r\n   */\r\n  notify(auditEvents: AuditEvents) {\r\n    this.http.post<void>(this.API_URL + \"/audit.notify\", {\r\n      event: \"None\", // AuditEventType.None,\r\n      app: this.app().name,\r\n      $auditRecord: {auditEvents: [auditEvents]}\r\n    }).subscribe();\r\n  }\r\n\r\n  /**\r\n   * It sends an audit event to the Audit Service.\r\n   */\r\n  notifyLogin() {\r\n    this.notify({\r\n      type: \"Login_Success_Form\" // AuditEventType.Search_Login_Success\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Notify logout\r\n   */\r\n  notifyLogout() {\r\n    this.notify({\r\n      type: \"Search_Exit_Logout\" // AuditEventType.Search_Exit_Logout\r\n    });\r\n  }\r\n\r\n  /**\r\n     * Notify the Sinequa server of a document event\r\n     *\r\n     * @param evt The audit event type\r\n     * @param doc The document (article) in question\r\n     * @param resultId The resultid that contain the document\r\n     * @param parameters Additional parameters\r\n     */\r\n  notifyDocument(\r\n    auditEventType: AuditEventType | AuditEventTypeValues | {} & Record<never, never>,\r\n    doc: Article,\r\n    resultsOrId: Result | string,\r\n    parameters?: Record<string, string | number | boolean | undefined>,\r\n    rfmParameters?: Record<string, string | number | boolean | undefined>) {\r\n    let resultId: string | null;\r\n    let result: Result | undefined;\r\n    if (typeof resultsOrId == \"string\") {\r\n      resultId = resultsOrId;\r\n    }\r\n    else {\r\n      result = resultsOrId;\r\n      resultId = result ? result.id : null;\r\n    }\r\n\r\n    const detail: any = {\r\n      docid: doc.id,\r\n      rank: doc.rank,\r\n      title: doc.title,\r\n      source: doc.collection[0].split(\"/\")[0],\r\n      collection: doc.collection[0],\r\n      resultId,\r\n      filename: doc.filename,\r\n      fileext: doc.fileext,\r\n      index: doc.databasealias,\r\n      resultcount: result?.totalRowCount\r\n    };\r\n\r\n    if (parameters) {\r\n      Object.keys(parameters).forEach(key => detail[key] = parameters[key]);\r\n    }\r\n    const data: AuditEvent = {\r\n      type: auditEventType,\r\n      detail\r\n    };\r\n\r\n    if (rfmParameters) {\r\n      const rfmDetail: Record<string, string | number | boolean | undefined> = {}; // Add index signature\r\n      Object.keys(rfmParameters).forEach(key => rfmDetail[key] = rfmParameters[key]);\r\n      data.rfmDetail = rfmDetail;\r\n    }\r\n\r\n    this.lastClickTime = Date.now();\r\n\r\n    // Listen to the navigation event outside the app\r\n    document.addEventListener('visibilitychange', () => {\r\n      // Capture the navigation even triggered just after the click\r\n      if (document.visibilityState === 'hidden' && (Date.now() - this.lastClickTime) < 1000) {\r\n        // Second event triggered when we come back\r\n        document.addEventListener('visibilitychange', () => {\r\n          if (document.visibilityState === 'visible') {\r\n            this.notify({ type: AuditEventType.Navigation_Return });\r\n          }\r\n        }, { once: true });\r\n      }\r\n    }, { once: true });\r\n\r\n    this.notify(data);\r\n  }\r\n\r\n  /**\r\n   * Notify route change\r\n   */\r\n  notifyRouteChange(url: string,) {\r\n    this.notify({\r\n      type: \"Navigation_Route\", // AuditEventType.Navigation_Route,\r\n      detail: {\r\n        detail: url\r\n      }\r\n    });\r\n\r\n  }\r\n}"]}

package/esm2022/lib/web-services/index.mjs

@@ -0,0 +1,10 @@
+export * from "./aggregations.service";
+export * from "./app.service";
+export * from "./json-method-plugin.service";
+export * from "./preview.service";
+export * from "./principal.service";
+export * from "./query.service";
+export * from "./text-chunck.service";
+export * from "./audit.service";
+export * from "./audit.service";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL3dlYi1zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcclxuZXhwb3J0ICogZnJvbSBcIi4vYWdncmVnYXRpb25zLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vYXBwLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vanNvbi1tZXRob2QtcGx1Z2luLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vcHJldmlldy5zZXJ2aWNlXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL3ByaW5jaXBhbC5zZXJ2aWNlXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL3F1ZXJ5LnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vdGV4dC1jaHVuY2suc2VydmljZVwiO1xyXG5leHBvcnQgKiBmcm9tIFwiLi9hdWRpdC5zZXJ2aWNlXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL2F1ZGl0LnNlcnZpY2VcIjsiXX0=

package/esm2022/lib/web-services/json-method-plugin.service.mjs

@@ -0,0 +1,54 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { globalConfig, isObject } from '@sinequa/atomic';
+import { throwError } from 'rxjs';
+import * as i0 from "@angular/core";
+export class JsonMethodPluginService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    /**
+     * Call a JsonMethod plugin using an HTTP POST
+     *
+     * @param method The name of the JsonMethod plugin
+     * @param query Parameters to pass to the plugin
+     * @param options HTTP options for the request
+     * @returns An observable of the plugin's return value
+     */
+    post(method, query, options) {
+        if (!isObject(query)) {
+            return throwError(() => ({ error: "invalid query object" }));
+        }
+        return this.http.post(`${this.API_URL}/plugin/${method}`, query, options);
+    }
+    /**
+     * Call a JsonMethod plugin using an HTTP GET
+     *
+     * @param method The name of the JsonMethod plugin
+     * @param query Parameters to pass to the plugin
+     * @param options HTTP options for the request
+     * @returns An observable of the plugin's return value
+     */
+    get(method, query, options) {
+        const params = new HttpParams();
+        for (const key in query) {
+            if (query[key] !== undefined) {
+                params.set(key, query[key]);
+            }
+        }
+        return this.http.get(`${this.API_URL}/plugin/${method}`, {
+            params: params,
+            ...options
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: JsonMethodPluginService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: JsonMethodPluginService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: JsonMethodPluginService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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