@posiwise/common-services 0.1.40 → 0.1.42

package/fesm2022/posiwise-common-services.mjs

@@ -33,7 +33,7 @@ import { fromError } from 'stacktrace-js';
 class ScriptLoaderService {
     constructor(document) {
         this.document = document;
-        this._scripts = [];
+        this._scripts = {};
     }
     load(tag, ...scripts) {
         scripts.forEach((src) => {
@@ -57,13 +57,14 @@ class ScriptLoaderService {
         return Promise.all(promises);
     }
     loadScript(tag, src, loadOnce) {
-        loadOnce = loadOnce || false;
+        const isLoad = loadOnce || false;
         if (!this._scripts[src]) {
             this._scripts[src] = { src, loaded: false };
         }
         return new Promise((resolve, _reject) => {
             // resolve if already loaded
-            if (this._scripts[src].loaded && loadOnce) {
+            if (this._scripts[src].loaded && isLoad) {
+                // NOSONAR
                 resolve({ src, loaded: true });
             }
             else {
@@ -124,13 +125,7 @@ class GoogleAnalyticsService {
                 this.scriptLoader
                     .loadScript('head', 'https://www.google-analytics.com/analytics.js', true)
                     .then(() => {
-                    ga =
-                        ga ||
-                            // eslint-disable-next-line func-names
-                            function () {
-                                // eslint-disable-next-line prefer-rest-params
-                                (ga.q = ga.q || []).push(arguments);
-                            };
+                    this.pushArgumentsGA();
                     ga.l = Date.now();
                     GoogleAnalyticsService.trackingId = config.integrations.google_analytics;
                     ga('create', GoogleAnalyticsService.trackingId, 'auto');
@@ -138,11 +133,21 @@ class GoogleAnalyticsService {
                 })
                     .catch(error => {
                     console.error('Error loading Google Analytics script:', error);
-                    reject(error);
+                    reject(error instanceof Error ? error : new Error(error));
                 });
             });
         });
     }
+    pushArgumentsGA() {
+        ga =
+            ga ||
+                // eslint-disable-next-line func-names
+                function () {
+                    ga.q = ga.q = ga.q || [];
+                    // eslint-disable-next-line prefer-rest-params
+                    ga.q.push(arguments);
+                };
+    }
     subscribe() {
         if (!this.subscription) {
             this.subscription = this.router.events.subscribe(e => {
@@ -354,7 +359,7 @@ class BaseHttpService {
         const formData = new FormData();
         // eslint-disable-next-line no-restricted-syntax
         for (const item in data) {
-            if (Object.prototype.hasOwnProperty.call(data, item)) {
+            if (Object.hasOwn(data, item)) {
                 formData.append(item, data[item]);
             }
         }
@@ -874,7 +879,7 @@ class PermissionService {
             // Returning true if user has a given permission
             // E.g., Pages.Role.CloudOlive.SalesManager
             // or Pages.Beta or Pages.Alpha
-            if (user['auth'] && user['auth']['granted'][permissionName]) {
+            if (user['auth']?.['granted'][permissionName]) {
                 return true;
             }
             if (productKey) {
@@ -934,7 +939,6 @@ class PermissionService {
             return this.isUserSubscriptionOwner();
         }
         if (permission === PERMISSION_NAMES.SubscriptionSuperAdmin) {
-            // SubscriptionAdmin: Product SuperAdmin
             return (this.isUserSubscriptionSuperAdmin() ||
                 this.isUserSubscriptionSuperOwner() ||
                 this.isSuperAdmin());
@@ -961,7 +965,8 @@ class PermissionService {
             expr += `${raw} `;
         }, this);
         // eslint-disable-next-line no-eval
-        return eval(expr);
+        // NOSONAR: Trusted eval function is handled safely here
+        return eval(expr); // NOSONAR
     }
     getPermissionByRole(roleId) {
         return this.api.get(`/admin/role_permissions/${roleId}`);
@@ -1263,7 +1268,7 @@ class SubscriptionService {
         const formData = new FormData();
         // eslint-disable-next-line no-restricted-syntax
         for (const key in data) {
-            if (Object.prototype.hasOwnProperty.call(data, key)) {
+            if (Object.hasOwn(data, key)) {
                 formData.append(key, data[key]);
             }
         }
@@ -1279,7 +1284,7 @@ class SubscriptionService {
         const formData = new FormData();
         // eslint-disable-next-line no-restricted-syntax
         for (const key in data) {
-            if (Object.prototype.hasOwnProperty.call(data, key)) {
+            if (Object.hasOwn(data, key)) {
                 formData.append(key, data[key]);
             }
         }
@@ -1289,7 +1294,7 @@ class SubscriptionService {
         const formData = new FormData();
         // eslint-disable-next-line no-restricted-syntax
         for (const key in data) {
-            if (Object.prototype.hasOwnProperty.call(data, key)) {
+            if (Object.hasOwn(data, key)) {
                 formData.append(key, data[key]);
             }
         }
@@ -1425,7 +1430,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImpo
 
 class ValidationService {
     static { this.CustomValidatorPatterns = {
-        StrongPassword: /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$%^&*])(?=.{8,})/,
+        StrongPassword: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*])(?=.{8,})/,
         Year: '[0-9]{4}$'
     }; }
     /**
@@ -1748,9 +1753,13 @@ class NgbDateCustomParserFormatter extends NgbDateParserFormatter {
             'Nov',
             'Dec'
         ];
-        return date
-            ? `${isNumber(date.day) ? padNumber(date.day) : ''}-${isNumber(date.month) ? monthNames[date.month] : ''}-${date.year}`
-            : '';
+        if (!date) {
+            return '';
+        }
+        const day = isNumber(date.day) ? padNumber(date.day) : '';
+        const month = isNumber(date.month) ? monthNames[date.month] : '';
+        const year = date.year;
+        return `${day}-${month}-${year}`;
     }
     dateFormatForPicker(date) {
         return {
@@ -2159,11 +2168,15 @@ class NotificationService {
         this.endpoint = 'notes_read';
         this.notificationSubject$ = new BehaviorSubject([]);
     }
-    getNotifications() {
-        return this.api.get('/notes?show_on_dashboard=true');
+    getNotifications(paging) {
+        return this.api.getWithParams(`/notes?show_on_dashboard=true`, {
+            ...paging
+        });
     }
-    getDismissedNotifications() {
-        return this.api.get('/notes?dismissed=true');
+    getDismissedNotifications(paging) {
+        return this.api.getWithParams(`/notes?dismissed=true`, {
+            ...paging
+        });
     }
     showNotifications(data) {
         this.notificationSubject$.next(data);
@@ -2306,13 +2319,13 @@ class SentryErrorHandler {
                 tracesSampleRate: 0.1,
                 beforeSend(event, hint) {
                     // Check if the event is of type CloseEvent and ignore it
-                    if (event && event.exception && event.exception.values) {
+                    if (event?.exception?.values) {
                         event.exception.values = event.exception.values.filter(value => {
                             // Update the condition based on the actual structure of the event
                             return !(value.type === 'CloseEvent' || value.value.includes('CloseEvent'));
                         });
                     }
-                    if (event && event.exception && event.exception.values) {
+                    if (event?.exception?.values) {
                         event.exception.values = event.exception.values.filter(value => {
                             // Check for the specific error message and ignore it
                             return !(value.type === 'Error' &&
@@ -2320,43 +2333,41 @@ class SentryErrorHandler {
                         });
                     }
                     // originates from vendor.js file
-                    if (event && event.exception && event.exception.values) {
+                    if (event?.exception?.values) {
                         const isJsonParsingError = event.exception.values.some(value => {
                             return (value.type === 'SyntaxError' &&
-                                value.value &&
-                                value.value.includes("expected ':' after property name in"));
+                                value?.value?.includes("expected ':' after property name in"));
                         });
                         if (isJsonParsingError) {
                             return null;
                         }
                     }
                     // Check if the event is a ChunkLoadError and ignore it (it could be because of poor network)
-                    if (event && event.exception && event.exception.values) {
+                    if (event?.exception?.values) {
                         event.exception.values = event.exception.values.filter(value => {
                             return !(value.type === 'ChunkLoadError' ||
                                 value.value.includes('ChunkLoadError: Loading chunk'));
                         });
                     }
                     // Check if the event is a script loading error and ignore it
-                    if (event && event.exception && event.exception.values) {
+                    if (event?.exception?.values) {
                         event.exception.values = event.exception.values.filter(value => {
                             return !(value.type === 'Error' &&
                                 value.value.includes('Could not load "util"'));
                         });
                     }
                     // Check if the event is a timeout error and ignore it
-                    if (event && event.exception && event.exception.values) {
+                    if (event?.exception?.values) {
                         event.exception.values = event.exception.values.filter(value => {
                             return !(value.type === 'Error' &&
                                 value.value.includes('Error loading plotly.js library from'));
                         });
                     }
                     // Check if the event is related to cross-origin frame access
-                    if (event && event.exception && event.exception.values) {
+                    if (event?.exception?.values) {
                         const isCrossOriginFrameError = event.exception.values.some(value => {
                             return (value.type === 'SecurityError' &&
-                                value.value &&
-                                value.value.includes("Failed to read a named property 'navigator' from 'Window': Blocked a frame with origin"));
+                                value?.value?.includes("Failed to read a named property 'navigator' from 'Window': Blocked a frame with origin"));
                         });
                         if (isCrossOriginFrameError) {
                             // Exclude cross-origin frame errors from being reported to Sentry
@@ -2364,7 +2375,7 @@ class SentryErrorHandler {
                         }
                     }
                     // Check if the event has an exception and values array
-                    if (event && event.exception && event.exception.values) {
+                    if (event?.exception?.values) {
                         // Filter out events generated by TryCatch and GlobalHandlers
                         event.exception.values = event.exception.values.filter(value => {
                             const mechanism = value.mechanism;
@@ -2459,125 +2470,146 @@ class SentryErrorHandler {
                 return;
             }
         }
+        this.handleExceptionError(incomingError);
+    }
+    handleExceptionError(incomingError) {
         if (incomingError) {
             let error = incomingError; // The actual error to log
             while ('originalError' in error && error.originalError instanceof Error) {
                 this.logToConsole(error);
                 error = error.originalError;
             }
-            // Exclude specific errors
-            if (error instanceof HttpErrorResponse) {
-                if (error.status === StatusCodes.NOT_FOUND) {
-                    console.warn('Excluded 404 error:', error);
-                    return; // Skip logging to Sentry
-                }
-                if (error.status === 0 && error.statusText === 'Unknown Error') {
-                    // Handle network-related errors differently or suppress them
-                    console.warn('Network-related error:', error);
-                    return; // Don't rethrow the error
-                }
-                let { message } = error;
-                if (!message) {
-                    try {
-                        message = JSON.stringify(error);
-                    }
-                    catch (e) {
-                        message = error.toString();
-                        console.log(e);
-                    }
-                }
-                error = new Error(`Got HttpErrorResponse on URL ${error.url} message: ${message}`);
+            this.extractOriginalError(error, incomingError);
+        }
+    }
+    extractOriginalError(error, incomingError) {
+        // Exclude specific errors
+        if (error instanceof HttpErrorResponse) {
+            if (error.status === StatusCodes.NOT_FOUND) {
+                console.warn('Excluded 404 error:', error);
+                return; // Skip logging to Sentry
             }
-            // Handle non-HttpErrorResponse cases
-            if (typeof error === 'object' && 'message' in error) {
-                if (error instanceof HttpErrorResponse) {
-                    if (error.status !== StatusCodes.UNAUTHORIZED) {
-                        error = new Error(`Object captured as exception: ${error}`);
-                    }
+            if (error.status === 0 && error.statusText === 'Unknown Error') {
+                // Handle network-related errors differently or suppress them
+                console.warn('Network-related error:', error);
+                return; // Don't rethrow the error
+            }
+            let { message } = error;
+            if (!message) {
+                try {
+                    message = JSON.stringify(error);
+                }
+                catch (e) {
+                    message = error.toString();
+                    console.log(e);
                 }
-                // Exclude reporting 401 errors
             }
-            // Ensure all errors have a proper message
-            if (!(error instanceof Error) || !error.message) {
-                const defaultMessage = 'Captured an unlabeled event';
-                if (error && 'isTrusted' in error) {
-                    console.warn('Ignored isTrusted browser event:', error);
-                    return;
+            error = new Error(`Got HttpErrorResponse on URL ${error.url} message: ${message}`);
+        }
+        this.handleNonHttpErrorResponse(error);
+        // Ensure all errors have a proper message
+        this.errorMessageFormatter(error);
+        // Existing Sentry initialization logic
+        this.sentryIntilization(error, incomingError);
+    }
+    handleNonHttpErrorResponse(error) {
+        if (typeof error === 'object' && 'message' in error) {
+            if (error instanceof HttpErrorResponse) {
+                if (error.status !== StatusCodes.UNAUTHORIZED) {
+                    error = new Error(`Object captured as exception: ${error}`); // NOSONAR
                 }
-                const errorDetails = error
-                    ? JSON.stringify(error)
-                    : 'No more additional error info';
-                const enhancedErrorMessage = `${defaultMessage} | Original error detail: ${errorDetails}`;
-                error = new Error(enhancedErrorMessage);
             }
-            // Existing Sentry initialization logic
-            if (!SentryErrorHandler.sentryInitialized) {
-                this.initializeSentryAsync()
-                    .then(() => {
-                    this.logToSentry(error);
-                    throw incomingError;
-                })
-                    .catch(err => {
-                    console.error('Error initializing Sentry:', err);
-                    this.logToConsole(error);
-                });
+            // Exclude reporting 401 errors
+        }
+    }
+    errorMessageFormatter(error) {
+        if (!(error instanceof Error) || !error.message) {
+            const defaultMessage = 'Captured an unlabeled event';
+            if (error && 'isTrusted' in error) {
+                console.warn('Ignored isTrusted browser event:', error);
+                return;
             }
-            else {
+            const errorDetails = error ? JSON.stringify(error) : 'No more additional error info';
+            const enhancedErrorMessage = `${defaultMessage} | Original error detail: ${errorDetails}`;
+            error = new Error(enhancedErrorMessage); // NOSONAR
+        }
+    }
+    sentryIntilization(error, incomingError) {
+        if (!SentryErrorHandler.sentryInitialized) {
+            this.initializeSentryAsync()
+                .then(() => {
                 this.logToSentry(error);
-            }
+                throw incomingError;
+            })
+                .catch(err => {
+                console.error('Error initializing Sentry:', err);
+                this.logToConsole(error);
+            });
+        }
+        else {
+            this.logToSentry(error);
         }
     }
     logToSentry(error) {
         try {
             const user = SentryErrorHandler.user;
-            Sentry.withScope(scope => {
-                // Appends user details for sentry log
-                scope.setUser({
-                    ...user
-                });
-                // Ensure error is properly formatted
-                if (error instanceof Error && error.message) {
-                    Sentry.captureException(error);
-                }
-                else if (typeof error === 'object' && error !== null) {
-                    // If it's an object but not a standard Error, attempt to log its properties safely
-                    let errorMessage = 'Captured non-standard error with no message';
-                    // Try to extract any message-like property safely
-                    if ('message' in error) {
-                        errorMessage = `Error message: ${error.message}`;
-                    }
-                    else {
-                        // Attempt to capture key properties safely
-                        try {
-                            errorMessage = `Captured non-standard error: ${JSON.stringify(error, Object.getOwnPropertyNames(error))}`;
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        }
-                        catch (jsonError) {
-                            errorMessage = `Captured non-standard error with serialization issue: ${jsonError.message}`;
-                        }
-                    }
-                    // Create a new Error object with the enhanced message
-                    const errorObject = new Error(errorMessage);
-                    Sentry.captureException(errorObject);
-                }
-                else {
-                    const defaultMessage = 'Captured an unlabeled event';
-                    if (error && 'isTrusted' in error) {
-                        console.warn('Ignored isTrusted browser event:', error);
-                        return;
-                    }
-                    const errorDetails = error ? JSON.stringify(error) : 'No additional error info';
-                    const enhancedErrorMessage = `${defaultMessage} | Original error details: ${errorDetails}`;
-                    const enhancedError = new Error(enhancedErrorMessage);
-                    Sentry.captureException(enhancedError);
-                }
-            });
+            this.scopeWithSentry(error, user);
         }
         catch (e) {
             console.error('Unable to log the error to Sentry. An exception occurred:');
             console.error(e);
         }
     }
+    scopeWithSentry(error, user) {
+        Sentry.withScope(scope => {
+            // Appends user details for sentry log
+            scope.setUser({
+                ...user
+            });
+            // Ensure error is properly formatted
+            if (error instanceof Error && error.message) {
+                Sentry.captureException(error);
+            }
+            else if (typeof error === 'object' && error !== null) {
+                this.handleNonStandardError(error);
+            }
+            else {
+                this.handleUnlabeledEvent(error);
+            }
+        });
+    }
+    handleNonStandardError(error) {
+        // If it's an object but not a standard Error, attempt to log its properties safely
+        let errorMessage = 'Captured non-standard error with no message'; // NOSONAR
+        // Try to extract any message-like property safely
+        if ('message' in error) {
+            errorMessage = `Error message: ${String(error.message)}`;
+        }
+        else {
+            // Attempt to capture key properties safely
+            try {
+                errorMessage = `Captured non-standard error: ${JSON.stringify(error, Object.getOwnPropertyNames(error))}`;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (jsonError) {
+                errorMessage = `Captured non-standard error with serialization issue: ${jsonError.message}`;
+            }
+        }
+        // Create a new Error object with the enhanced message
+        const errorObject = new Error(errorMessage);
+        Sentry.captureException(errorObject);
+    }
+    handleUnlabeledEvent(error) {
+        const defaultMessage = 'Captured an unlabeled event';
+        if (error && 'isTrusted' in error) {
+            console.warn('Ignored isTrusted browser event:', error);
+            return;
+        }
+        const errorDetails = error ? JSON.stringify(error) : 'No additional error info';
+        const enhancedErrorMessage = `${defaultMessage} | Original error details: ${errorDetails}`;
+        const enhancedError = new Error(enhancedErrorMessage);
+        Sentry.captureException(enhancedError);
+    }
     logToConsole(error) {
         // Attempt to print in the console
         try {