@liorian/sdk 0.28.0-alpha.56010ca

package/src/application/service/notifications-push.service.ts

@@ -0,0 +1,299 @@
+"use client"
+
+import {AppConfig} from "../../domain/config/app.config";
+import {ActivityTrackerService} from "../../infrastructure/utilities/activity-tracker.service";
+import {isTauri} from "../../infrastructure/utilities/tauri.util";
+import {NotificationsApiService} from "./notifications-api-service";
+import {NotificationsSocketService} from "./notifications-socket-service";
+
+export class NotificationsPushService {
+
+    protected static swPath = "/sw.js";
+    protected static trackingStarted = false;
+    protected static visibilityHandler = (): void => undefined;
+    protected static stopTracking: (() => void) | undefined;
+    protected static pollingTimer: ReturnType<typeof setInterval> | undefined;
+    protected static seenNotificationIds = new Set<string>();
+
+    public static readonly PUSH_PREFERENCE_LABEL = "notifications_push_enabled";
+    protected static readonly SEEN_IDS_STORAGE_KEY = "liorian_push_seen_notification_ids";
+    protected static readonly SEEN_IDS_MAX = 200;
+    protected static readonly POLL_FALLBACK_INTERVAL = 30000;
+
+    static get isSupported(): boolean {
+        return typeof window !== "undefined"
+            && "serviceWorker" in navigator
+            && "PushManager" in window
+            && "Notification" in window;
+    }
+
+    static async register(): Promise<ServiceWorkerRegistration | undefined> {
+        if (!this.isSupported) return undefined;
+        return navigator.serviceWorker.register(this.swPath, {
+            scope: "/",
+            updateViaCache: "none",
+        });
+    }
+
+    static async getSubscription(): Promise<PushSubscription | null> {
+        if (!this.isSupported) return null;
+        const registration = await navigator.serviceWorker.ready;
+        return registration.pushManager.getSubscription();
+    }
+
+    static async subscribe(): Promise<PushSubscription | null> {
+        if (!this.isSupported) return null;
+
+        const permission = await Notification.requestPermission();
+        if (permission !== "granted") return null;
+
+        const registration = await navigator.serviceWorker.ready;
+        const existing = await registration.pushManager.getSubscription();
+        if (existing) return existing;
+
+        const subscription = await registration.pushManager.subscribe({
+            userVisibleOnly: true,
+            applicationServerKey: this.urlBase64ToUint8Array(AppConfig.VAPID_PUBLIC_KEY),
+        });
+
+        await this.saveSubscription(subscription);
+
+        return subscription;
+    }
+
+    static async unsubscribe(): Promise<boolean> {
+        const subscription = await this.getSubscription();
+        if (!subscription) return false;
+
+        await this.removeSubscription(subscription);
+
+        return subscription.unsubscribe();
+    }
+
+    static async connect(): Promise<void> {
+        NotificationsSocketService.connectNotifications();
+    }
+
+    static async getNotifications<T = any>(page = 1, limit = 10): Promise<T> {
+        return NotificationsSocketService.getUserNotifications<T>(page, limit);
+    }
+
+    static async getOrganizationNotifications<T = any>(organizationId?: string, page = 1, limit = 10): Promise<T> {
+        return NotificationsSocketService.getOrganizationNotifications<T>(organizationId, page, limit);
+    }
+
+    static get clientState() {
+        return {
+            active: ActivityTrackerService.isActive,
+            visible: document.visibilityState === "visible",
+            focused: document.hasFocus(),
+        };
+    }
+
+    static startActivityTracking(): void {
+        if (!this.isSupported || this.trackingStarted) return;
+
+        this.trackingStarted = true;
+        this.visibilityHandler = () => this.syncClientState();
+
+        // Souscription au tracker partagé : libérer cette souscription n'arrête
+        // PAS le suivi si un autre consommateur (verrouillage automatique) l'utilise.
+        this.stopTracking = ActivityTrackerService.start({onStateChange: () => this.syncClientState()});
+        document.addEventListener("visibilitychange", this.visibilityHandler);
+
+        this.syncClientState();
+    }
+
+    static stopActivityTracking(): void {
+        if (!this.trackingStarted) return;
+
+        this.trackingStarted = false;
+        document.removeEventListener("visibilitychange", this.visibilityHandler);
+
+        this.stopTracking?.();
+        this.stopTracking = undefined;
+    }
+
+    static onInAppNotification(callback: (payload: any) => void): () => void {
+        const handler = (event: MessageEvent) => {
+            if (event.data && event.data.type === "NOTIFICATION_RECEIVED") {
+                callback(event.data.payload);
+            }
+        };
+
+        navigator.serviceWorker.addEventListener("message", handler);
+
+        return () => navigator.serviceWorker.removeEventListener("message", handler);
+    }
+
+    static get isPolling(): boolean {
+        return this.pollingTimer !== undefined;
+    }
+
+    /**
+     * Canal de secours REST : interroge périodiquement les notifications non lues
+     * et affiche une notification native pour les nouvelles entrées.
+     * Utilisé lorsque le Web Push n'est pas disponible (ex: Tauri).
+     */
+    static async startPolling(): Promise<void> {
+        if (this.isPolling || typeof window === "undefined") return;
+
+        this.hydrateSeenIds();
+        await this.seedSeenIds();
+
+        this.pollingTimer = setInterval(() => {
+            void this.poll();
+        }, AppConfig.APP_REFRESH_UI || this.POLL_FALLBACK_INTERVAL);
+    }
+
+    static stopPolling(): void {
+        if (!this.pollingTimer) return;
+
+        clearInterval(this.pollingTimer);
+        this.pollingTimer = undefined;
+    }
+
+    protected static async seedSeenIds(): Promise<void> {
+        const notifications = await this.fetchUnreadNotifications().catch(() => []);
+        notifications.forEach((notification) => this.seenNotificationIds.add(notification.id));
+    }
+
+    protected static async poll(): Promise<void> {
+        try {
+            const notifications = await this.fetchUnreadNotifications();
+
+            if (!notifications.length) {
+                this.seenNotificationIds.clear();
+                return;
+            }
+
+            const fresh = notifications
+                .filter((notification) => !this.seenNotificationIds.has(notification.id))
+                .reverse();
+
+            this.seenNotificationIds.clear();
+            notifications.forEach((notification) => this.seenNotificationIds.add(notification.id));
+            this.persistSeenIds();
+
+            for (const notification of fresh) {
+                await this.displayNativeNotification(notification.title, notification.content);
+            }
+        } catch {
+            // Silencieux : le polling reprendra au prochain tick
+        }
+    }
+
+    protected static async fetchUnreadNotifications(): Promise<{ id: string, title?: string, content?: string }[]> {
+        if (typeof window === "undefined") return [];
+
+        const response = await NotificationsApiService.getAll({read: false, limit: 10});
+        const payload = response?.data as any;
+        const data = Array.isArray(payload)
+            ? payload
+            : Array.isArray(payload?.data) ? payload.data : [];
+
+        return data.filter((notification: any) => notification && notification.id);
+    }
+
+    protected static async displayNativeNotification(title?: string, body?: string): Promise<void> {
+        // Instance visible au premier plan : pas de notification système (le badge/popover suffit)
+        if (document.visibilityState === "visible" && document.hasFocus()) return;
+
+        const displayTitle = title || "Nouvelle notification";
+        const displayBody = body || "Vous avez reçu une nouvelle notification";
+
+        if (isTauri()) {
+            try {
+                const plugin = await import("@tauri-apps/plugin-notification");
+                if (!(await plugin.isPermissionGranted())) return;
+                await plugin.sendNotification({title: displayTitle, body: displayBody});
+            } catch {
+                // Plugin indisponible
+            }
+            return;
+        }
+
+        if (typeof Notification !== "undefined" && Notification.permission === "granted") {
+            new Notification(displayTitle, {body: displayBody, icon: "/assets/logo/icon.png"});
+        }
+    }
+
+    protected static hydrateSeenIds(): void {
+        try {
+            const raw = localStorage.getItem(this.SEEN_IDS_STORAGE_KEY);
+            const ids = raw ? JSON.parse(raw) : [];
+            if (Array.isArray(ids)) ids.forEach((id) => this.seenNotificationIds.add(String(id)));
+        } catch {
+            // Stockage indisponible
+        }
+    }
+
+    protected static persistSeenIds(): void {
+        try {
+            if (this.seenNotificationIds.size > this.SEEN_IDS_MAX) {
+                const keep = Array.from(this.seenNotificationIds).slice(-this.SEEN_IDS_MAX);
+                this.seenNotificationIds = new Set(keep);
+            }
+
+            localStorage.setItem(this.SEEN_IDS_STORAGE_KEY, JSON.stringify(Array.from(this.seenNotificationIds)));
+        } catch {
+            // Stockage indisponible
+        }
+    }
+
+    protected static syncClientState(): void {
+        const controller = navigator.serviceWorker.controller;
+        if (!controller) return;
+        controller.postMessage({type: "CLIENT_STATE", ...this.clientState});
+    }
+
+    protected static async saveSubscription(subscription: PushSubscription): Promise<void> {
+        const payload = {
+            endpoint: subscription.endpoint,
+            keys: {
+                p256dh: this.toBase64Url(subscription.getKey("p256dh")),
+                auth: this.toBase64Url(subscription.getKey("auth")),
+            },
+        };
+
+        try {
+            await NotificationsApiService.savePushSubscription(payload);
+        } catch (error) {
+            console.error("Push subscription could not be saved", error);
+        }
+    }
+
+    protected static async removeSubscription(subscription: PushSubscription): Promise<void> {
+        try {
+            await NotificationsApiService.removePushSubscription(subscription.endpoint);
+        } catch (error) {
+            console.error("Push subscription could not be removed", error);
+        }
+    }
+
+    protected static urlBase64ToUint8Array(base64String: string): Uint8Array<ArrayBuffer> {
+        const padding = "=".repeat((4 - (base64String.length % 4)) % 4);
+        const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");
+        const rawData = window.atob(base64);
+        const outputArray = new Uint8Array(rawData.length);
+
+        for (let i = 0; i < rawData.length; ++i) {
+            outputArray[i] = rawData.charCodeAt(i);
+        }
+
+        return outputArray;
+    }
+
+    protected static toBase64Url(buffer: ArrayBuffer | null): string {
+        if (!buffer) return "";
+
+        const bytes = new Uint8Array(buffer);
+        let binary = "";
+        for (let i = 0; i < bytes.length; ++i) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+
+        return window.btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    }
+
+}

package/src/application/service/notifications-socket-service.ts

@@ -0,0 +1,76 @@
+"use client"
+
+import {SocketService} from "../../infrastructure/utilities/socket-service";
+import {AuthUserService} from "./auth-user.service";
+
+export interface SocketNotificationResponse<T = any> {
+    message: string;
+    statusCode: number;
+    data: T;
+}
+
+export class NotificationsSocketService extends SocketService {
+
+    protected static _listening: boolean = false;
+    protected static _pending: Map<string, Array<(response: SocketNotificationResponse) => void>> = new Map();
+
+    static connectNotifications(): WebSocket {
+        const socket = this.instance;
+        if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) {
+            return socket;
+        }
+        return this.connect('/socket/notifications');
+    }
+
+    static getUserNotifications<T = any>(page = 1, limit = 10): Promise<T> {
+        return this.emit<T>('user-notifications', {page, limit});
+    }
+
+    static getOrganizationNotifications<T = any>(organizationId?: string, page = 1, limit = 10): Promise<T> {
+        return this.emit<T>('organization-notifications', organizationId
+            ? {organizationId, page, limit}
+            : {page, limit});
+    }
+
+    protected static emit<T = any>(event: string, extra?: Record<string, any>): Promise<T> {
+        return new Promise<T>((resolve, reject) => {
+            const token = AuthUserService.getToken();
+            if (!token) {
+                reject(new Error('Token manquant'));
+                return;
+            }
+
+            this.connectNotifications();
+            this.listen();
+
+            const queue = this._pending.get(event) ?? [];
+            queue.push((response) => {
+                if (response.statusCode === 200) resolve(response.data as T);
+                else reject(response);
+            });
+            this._pending.set(event, queue);
+
+            this.send({event, data: {token, ...extra}});
+        });
+    }
+
+    protected static listen(): void {
+        if (this._listening) return;
+        this._listening = true;
+        this.on('message', (payload) => this.resolve(payload));
+    }
+
+    protected static resolve(payload: any): void {
+        const response = payload as SocketNotificationResponse;
+        if (!response || typeof response !== 'object' || !('statusCode' in response)) return;
+
+        for (const [event, queue] of this._pending.entries()) {
+            const resolve = queue.shift();
+            if (!resolve) continue;
+            if (queue.length === 0) this._pending.delete(event);
+            resolve(response);
+            return;
+        }
+    }
+
+}

package/src/application/service/organizations-api-service.ts

@@ -0,0 +1,104 @@
+import {ApiService} from "../../infrastructure/utilities/api-service";
+import {FetchResponseInterface} from "../../domain/typing/response";
+import {OrganizationApiAccessResponseInterface} from "../../domain/entities/organization.interface";
+
+export class OrganizationsApiService extends ApiService {
+    // Organizations
+    static async create(payload: any) {
+        return await this.post('/organizations/', payload);
+    }
+
+    static async getAll() {
+        return await this.get('/organizations/');
+    }
+
+    static async getById(id: string) {
+        return await this.get(`/organizations/${id}`);
+    }
+
+    static async updateOrganization(id: string, payload: any) {
+        return await this.put(`/organizations/${id}`, payload);
+    }
+
+    static async deleteOrganization(id: string) {
+        return await this.delete(`/organizations/${id}`);
+    }
+
+    static async updateModules(id: string, modules: string[]) {
+        return await this.put(`/organizations/${id}/modules`, { modules });
+    }
+
+    static async getModulesList() {
+        return await this.get('/organizations/modules/list');
+    }
+
+    static async addMember(id: string, member: any) {
+        return await this.post(`/organizations/${id}/members`, member);
+    }
+
+    static async getMembers(id: string) {
+        return await this.get(`/organizations/${id}/members`);
+    }
+
+    static async removeMember(id: string, userId: string) {
+        return await this.delete(`/organizations/${id}/members/${userId}`);
+    }
+
+    static async createApiKey(id: string, data: any) {
+        return await this.post(`/organizations/${id}/api-keys`, data);
+    }
+
+    static async getApiKeys(id: string) {
+        return await this.get(`/organizations/${id}/api-keys`);
+    }
+
+    static async getApiAccess(id: string) {
+        return await this.get<FetchResponseInterface<OrganizationApiAccessResponseInterface>>(`/organizations/public/${id}/api/access`);
+    }
+
+    static async deleteApiKey(keyId: string) {
+        return await this.delete(`/organizations/api-keys/${keyId}`);
+    }
+
+    static async verifyApiKey(data: any) {
+        return await this.post('/organizations/api-keys/verify', data);
+    }
+
+    // Organization Preferences
+    static async createPreference(payload: any) {
+        return await this.post('/organization-preferences/', payload);
+    }
+
+    static async getAllPreferences() {
+        return await this.get('/organization-preferences/');
+    }
+
+    static async getPreferenceByOrgId(organizationId: string) {
+        return await this.get(`/organization-preferences/organization/${organizationId}`);
+    }
+
+    static async updatePreference(id: string, payload: any) {
+        return await this.put(`/organization-preferences/${id}`, payload);
+    }
+
+    static async deletePreference(id: string) {
+        return await this.delete(`/organization-preferences/${id}`);
+    }
+
+    // Organization Document Types
+    static async createDocumentType(payload: any) {
+        return await this.post('/organization-document-types/', payload);
+    }
+
+    static async getDocumentTypesByOrg(organizationId: string) {
+        return await this.get(`/organization-document-types/organization/${organizationId}`);
+    }
+
+    static async updateDocumentType(id: string, payload: any) {
+        return await this.put(`/organization-document-types/${id}`, payload);
+    }
+
+    static async deleteDocumentType(id: string) {
+        return await this.delete(`/organization-document-types/${id}`);
+    }
+}

package/src/application/service/otp-api-service.ts

@@ -0,0 +1,11 @@
+import {ApiService} from "../../infrastructure/utilities/api-service";
+
+export class OtpApiService extends ApiService {
+    static async createOtp(payload: { phone: string; domain?: string }) {
+        return await this.post('/otp/create', payload);
+    }
+
+    static async validateOtp(payload: { phone: string; code: string; domain?: string }) {
+        return await this.post('/otp/validate', payload);
+    }
+}

package/src/application/service/storage-api-service.ts

@@ -0,0 +1,77 @@
+import {ApiService} from "../../infrastructure/utilities/api-service";
+import {MediaLabelService} from "../../infrastructure/utilities/media-label.service";
+import type {MediaSection, MediaUploadOptions} from "../../domain/entities/media";
+import type {AxiosProgressEvent, AxiosRequestConfig} from "axios";
+
+export class StorageApiService extends ApiService {
+    static async uploadFile(file: File, options?: MediaUploadOptions, onUploadProgress?: (progressEvent: AxiosProgressEvent) => void, config?: AxiosRequestConfig<any>) {
+        const formData = new FormData();
+        formData.append("file", file);
+        // Type déclaré par le navigateur : prioritaire sur le reniflement du
+        // parseur multipart côté API (cf. UploadFileDto.mimeType).
+        if (file.type) formData.append("mimeType", file.type);
+
+        if (options?.module) formData.append("module", options.module);
+        if (options?.type) formData.append("type", options.type);
+
+        const section: MediaSection = options?.isDocument
+            ? "document"
+            : (options?.section as MediaSection | undefined) ?? MediaLabelService.sectionFor({mime: file.type, extension: file.name.split(".").pop()});
+        const label = MediaLabelService.build(options?.module ?? "", section, options?.type);
+        formData.append("label", label);
+
+        return await super.upload('/storages/upload', formData, onUploadProgress, config);
+    }
+
+    static async getAll() {
+        return await this.get('/storages/');
+    }
+
+    static async getById(id: string) {
+        return await this.get(`/storages/${id}`);
+    }
+
+    static async updateStorage(id: string, payload: Record<string, any>) {
+        return await this.put(`/storages/${id}`, payload);
+    }
+
+    static async deleteStorage(id: string) {
+        return await this.delete(`/storages/${id}`);
+    }
+
+    static async getFile(id: string, config?: AxiosRequestConfig<any>) {
+        return await this.get(`/storages/${id}/file`, undefined, config);
+    }
+
+    static async getPublicFile(id: string) {
+        return await this.get(`/storages/public/${id}/file`);
+    }
+
+    static async createDocument(userId: string, payload: Record<string, any>) {
+        return await this.post(`/storages/documents/${userId}`, payload);
+    }
+
+    static async getDocumentsByUser(userId: string) {
+        return await this.get(`/storages/documents/${userId}`);
+    }
+
+    static async getDocument(userId: string, documentId: string) {
+        return await this.get(`/storages/documents/${userId}/${documentId}`);
+    }
+
+    static async updateDocument(userId: string, documentId: string, payload: Record<string, any>) {
+        return await this.put(`/storages/documents/${userId}/${documentId}`, payload);
+    }
+
+    static async deleteDocument(userId: string, documentId: string) {
+        return await this.delete(`/storages/documents/${userId}/${documentId}`);
+    }
+
+    static async hasDocument(type: string) {
+        return await this.get('/storages/documents/me/has-document', { type });
+    }
+
+    static async hasDocumentForUser(userId: string, type: string) {
+        return await this.get(`/storages/documents/${userId}/has-document`, { type });
+    }
+}

package/src/application/service/storefront-api.service.ts

@@ -0,0 +1,72 @@
+import {ApiService} from "../../infrastructure/utilities/api-service";
+import {AppConfig} from "../../domain/config/app.config";
+import {FetchResponseInterface} from "../../domain/typing/response";
+import {
+    CatalogCategoryInterface,
+    CatalogModuleInterface,
+    CreateCatalogCategoryPayloadInterface,
+    CreateCatalogModulePayloadInterface,
+    UpdateCatalogCategoryPayloadInterface,
+    UpdateCatalogModulePayloadInterface
+} from "../../domain/entities/catalog.interface";
+
+/**
+ * Service API du catalogue public (storefront).
+ *
+ * Cible `liorian-api-store` (base `/catalog`). Lecture publique du catalogue
+ * sans auth ; les mutations (fiche produit / catégorie) sont réservées au
+ * SuperAdmin (JWT partagé émis par core).
+ */
+export class StorefrontApiService extends ApiService {
+
+    protected static baseUrl: string = (AppConfig.STORE_API_HOST || AppConfig.CORE_API_HOST) as string;
+
+    // ─── Catalogue : modules ────────────────────────────────────────
+
+    /** Récupérer tous les modules du catalogue */
+    static async getCatalogModules() {
+        return await this.get<FetchResponseInterface<CatalogModuleInterface[]>>('/catalog/modules');
+    }
+
+    /** Récupérer un module du catalogue par son ID */
+    static async getCatalogModule(moduleId: string) {
+        return await this.get<FetchResponseInterface<CatalogModuleInterface>>(`/catalog/modules/${moduleId}`);
+    }
+
+    /** Créer une fiche produit (SuperAdmin) */
+    static async createCatalogModule(payload: CreateCatalogModulePayloadInterface) {
+        return await this.post<FetchResponseInterface<CatalogModuleInterface>>('/catalog/modules', payload);
+    }
+
+    /** Mettre à jour une fiche produit (SuperAdmin) */
+    static async updateCatalogModule(moduleId: string, payload: UpdateCatalogModulePayloadInterface) {
+        return await this.put<FetchResponseInterface<CatalogModuleInterface>>(`/catalog/modules/${moduleId}`, payload);
+    }
+
+    /** Supprimer une fiche produit (SuperAdmin) */
+    static async deleteCatalogModule(moduleId: string) {
+        return await this.delete(`/catalog/modules/${moduleId}`);
+    }
+
+    // ─── Catalogue : catégories ─────────────────────────────────────
+
+    /** Récupérer toutes les catégories du catalogue */
+    static async getCatalogCategories() {
+        return await this.get<FetchResponseInterface<CatalogCategoryInterface[]>>('/catalog/categories');
+    }
+
+    /** Créer une catégorie (SuperAdmin) */
+    static async createCatalogCategory(payload: CreateCatalogCategoryPayloadInterface) {
+        return await this.post<FetchResponseInterface<CatalogCategoryInterface>>('/catalog/categories', payload);
+    }
+
+    /** Mettre à jour une catégorie (SuperAdmin) */
+    static async updateCatalogCategory(categoryId: string, payload: UpdateCatalogCategoryPayloadInterface) {
+        return await this.put<FetchResponseInterface<CatalogCategoryInterface>>(`/catalog/categories/${categoryId}`, payload);
+    }
+
+    /** Supprimer une catégorie (SuperAdmin) */
+    static async deleteCatalogCategory(categoryId: string) {
+        return await this.delete(`/catalog/categories/${categoryId}`);
+    }
+}