notification filter / storage change (#122)

* notification filter

* Fixed conflicts

Author: Morten Hundevad

src/common/messages/message-handler.ts

@@ -38,10 +38,18 @@ const pageInfoHandler: MessageHandler<'pageInfo'> = (payload, context) => {
     });
 };
 
+const notifyUpdateHandler: MessageHandler<'notifyUpdate'> = (payload, context) => {
+    return new Promise(() => {
+        console.log('Notify update Received, triggering page load handler:', payload);
+        context.main.onNotifyUpdate(payload.pageId, payload.action);
+    });
+};
+
 const handlers = {
     log: logHandler,
     notify: notifyHandler,
     pageInfo: pageInfoHandler,
+    notifyUpdate: notifyUpdateHandler,
 } satisfies { [K in keyof MessageMap]: MessageHandler<K> };
 
 function messageHandler(

src/common/messages/messages.types.ts

@@ -12,6 +12,7 @@ export interface MessageMap {
     log: [{ message: string }];
     notify: [{ title: string; message: string }];
     pageInfo: [{ domain: string; url: string }];
+    notifyUpdate: [{ pageId: number; action: string }];
 }
 export interface MessageHandlerContext {
     main: Main;

src/main.ts

@@ -14,6 +14,8 @@ import { MessageHandlerContext } from '@/common/messages/messages.types';
 import browser from 'webextension-polyfill';
 import { Page } from './models/page';
 
+import NotificationsFilter, { INotificationsFilter } from './utils/helpers/notification-filter';
+
 export interface IMainMessage {
     badgeText: string;
     domain: string;
@@ -43,68 +45,67 @@ export class Main {
      * Display how many pages were found by updating the badge text
      */
     indicateCATPages(pages: CATWikiPageSearchResults, domMessenger: IDOMMessengerInterface): void {
-        const totalPages = pages.totalPagesFound;
-        console.log(pages);
-
-        if (totalPages > 0) {
-            this.onBadgeTextUpdate(totalPages.toString(), domMessenger);
-
-            Promise.all([
-                Preferences.getPreference(Preferences.IS_ENABLED_KEY),
-                Preferences.getPreference(Preferences.BROWSER_NOTIFICATIONS_ENABLED_KEY),
-            ])
-                .then(([isEnabled, browserNotificationsEnabled]) => {
-                    if (isEnabled && browserNotificationsEnabled) {
-                        // Example: show a notification about the found pages
-                        // NOTE: Requires "notifications" permission in your manifest.json
-                        void browser.notifications.create({
-                            type: 'basic',
-                            iconUrl: browser.runtime.getURL('alert.png'),
-                            title: 'CAT Pages Found',
-                            message: `Found ${pages.totalPagesFound.toString()} page(s).`,
-                        });
-                    }
-                })
-                .catch((error: unknown) =>
-                    console.error('Failed to get preferences to send browser notification:', error)
-                );
-            Promise.all([
-                Preferences.getPreference(Preferences.IS_ENABLED_KEY),
-                Preferences.getPreference(Preferences.PAGE_NOTIFICATIONS_ENABLED_KEY),
-            ])
-                .then(([isEnabled, pageNotificationsEnabled]) => {
-                    if (isEnabled && pageNotificationsEnabled) {
-                        const message = `Found ${pages.totalPagesFound.toString()} CAT page(s).`;
-                        const entries: Page[] = [];
-                        pages.pageEntries.forEach((page) => {
-                            entries.push(page);
-                        });
-
-                        domMessenger
-                            .showInPageNotification(message, entries)
-                            .then(() => console.log('In-page notification shown.'))
-                            .catch((error: unknown) => {
-                                if (error instanceof Error && error.message.includes('Receiving end does not exist')) {
-                                    console.warn(
-                                        `Failed to send in-page notification (tab might be inactive or closed/navigated away before message was sent): ${error.message}`
-                                    );
-                                } else {
-                                    console.error(
-                                        'Failed to show in-page notification due to unexpected error:',
-                                        error
-                                    );
-                                }
+        Promise.all([
+            Preferences.getPreference(Preferences.IS_ENABLED_KEY),
+            Preferences.getPreference(Preferences.BROWSER_NOTIFICATIONS_ENABLED_KEY),
+            Preferences.getPreference(Preferences.PAGE_NOTIFICATIONS_ENABLED_KEY),
+            NotificationsFilter.get(),
+        ])
+            .then(([isEnabled, browserNotificationsEnabled, pageNotificationsEnabled, filters]) => {
+                if (isEnabled) {
+                    let pageEntries = pages.pageEntries;
+                    pageEntries = NotificationsFilter.filterPages(pageEntries, filters, 60 * 60 * 1000); // check if muted 1 hour
+
+                    const totalPages = pageEntries.length;
+                    console.log('pageEntries', pages.pageEntries, pageEntries);
+                    if (totalPages > 0) {
+                        this.onBadgeTextUpdate(totalPages.toString(), domMessenger);
+
+                        if (browserNotificationsEnabled) {
+                            // Example: show a notification about the found pages
+                            // NOTE: Requires "notifications" permission in your manifest.json
+                            void browser.notifications.create({
+                                type: 'basic',
+                                iconUrl: browser.runtime.getURL('alert.png'),
+                                title: 'CAT Pages Found',
+                                message: `Found ${totalPages.toString()} page(s).`,
                             });
+                        }
+
+                        if (pageNotificationsEnabled) {
+                            const message = `Found ${totalPages.toString()} CAT page(s).`;
+                            const entries: Page[] = [];
+                            pageEntries.forEach((page) => {
+                                entries.push(page);
+                            });
+
+                            domMessenger
+                                .showInPageNotification(message, entries)
+                                .then(() => console.log('In-page notification shown.'))
+                                .catch((error: unknown) => {
+                                    if (
+                                        error instanceof Error &&
+                                        error.message.includes('Receiving end does not exist')
+                                    ) {
+                                        console.warn(
+                                            `Failed to send in-page notification (tab might be inactive or closed/navigated away before message was sent): ${error.message}`
+                                        );
+                                    } else {
+                                        console.error(
+                                            'Failed to show in-page notification due to unexpected error:',
+                                            error
+                                        );
+                                    }
+                                });
+                        }
+                    } else {
+                        // Revert badge text back to "on" or "off" as set by indicateStatus
+                        console.log('Resetting badge text');
+                        this.indicateStatus();
                     }
-                })
-                .catch((error: unknown) =>
-                    console.error('Failed to get preferences to send in-page notification:', error)
-                );
-        } else {
-            // Revert badge text back to "on" or "off" as set by indicateStatus
-            console.log('Resetting badge text');
-            this.indicateStatus();
-        }
+                }
+            })
+            .catch((error: unknown) => console.error('Failed to get preferences to send in-page notification:', error));
     }
 
     notify(message: string) {
@@ -186,6 +187,22 @@ export class Main {
         await this.contentScanner.checkPageContents(scannerParameters);
     }
 
+    /**
+     * Called when a page (tab) has finished loading.
+     * Scans the domain and in-page contents, merges results,
+     * and indicates how many CAT pages were found.
+     */
+    onNotifyUpdate(pageId: number, action: string) {
+        const page: INotificationsFilter = {
+            timestamp: 0,
+            pageId: pageId,
+        };
+        if (action == 'mute') {
+            page.timestamp = Date.now();
+        }
+        NotificationsFilter.update(page);
+    }
+
     /**
      * Called when the extension is installed.
      * Initializes default settings and indicates current status.

src/ui/inpagenotification/Inspagenotification.tsx

@@ -1,7 +1,6 @@
 import React from 'react';
 
 import { ArticleType, IPage, Page } from '@/models/page';
-import LocalStorage from '@/utils/helpers/local-storage';
 import { CompanyPage, ICompanyPage } from '@/models/company';
 import { IIncidentPage, IncidentPage } from '@/models/incident';
 import { IProductPage, ProductPage } from '@/models/product';
@@ -14,14 +13,16 @@ export interface IInpagenotificationPage {
 const InpagenotificationPage = ({ page }: IInpagenotificationPage) => {
     const componentReferance = React.createRef<HTMLParagraphElement>();
 
-    const showPage = Date.now() > LocalStorage.readPage(page.pageId).timestamp + 60 * 60 * 1000; // curent mute 1 hour, TODO: should come from an option.
-
     const closePage = () => {
-        const storedPage = LocalStorage.readPage(page.pageId);
-
-        storedPage.timestamp = Date.now();
+        const notifyUpdatePayload = {
+            pageId: page.pageId,
+            action: 'mute',
+        };
 
-        LocalStorage.writePage(storedPage);
+        void browser.runtime.sendMessage({
+            type: 'notifyUpdate',
+            payload: notifyUpdatePayload,
+        });
 
         if (componentReferance) {
             componentReferance.current?.remove();
@@ -41,28 +42,24 @@ const InpagenotificationPage = ({ page }: IInpagenotificationPage) => {
         }
     };
 
-    if (showPage) {
-        return (
-            <>
-                <div className="page" ref={componentReferance}>
-                    <div className="page-menu">
-                        <span className="page-more" onClick={seeMore}>
-                            ⯈
-                        </span>
-                        <span className="page-close" onClick={closePage}>
-                            ✖
-                        </span>
-                    </div>
-                    <a href={page.url()} target="_blank">
-                        {page.pageName}
-                    </a>
-                    <div className="page-info hidden">{page.description}</div>
+    return (
+        <>
+            <div className="page" ref={componentReferance}>
+                <div className="page-menu">
+                    <span className="page-more" onClick={seeMore}>
+                        ⯈
+                    </span>
+                    <span className="page-close" onClick={closePage}>
+                        ✖
+                    </span>
                 </div>
-            </>
-        );
-    } else {
-        return <></>;
-    }
+                <a href={page.url()} target="_blank">
+                    {page.pageName}
+                </a>
+                <div className="page-info hidden">{page.description}</div>
+            </div>
+        </>
+    );
 };
 
 export interface IInpagenotificationMessage {

src/utils/helpers/notification-filter.ts

@@ -0,0 +1,43 @@
+import Preferences from '@/common/services/preferences';
+
+import { Page } from '@/models/page';
+
+export interface INotificationsFilter {
+    timestamp: number;
+    pageId: number;
+}
+
+class NotificationsFilter {
+    static readonly NOTIFICATIONS_FILTER_KEY = 'notifications_filter';
+
+    public static async get(): Promise<Record<string, INotificationsFilter>> {
+        let result: Record<string, INotificationsFilter> = {};
+        const data = await Preferences.getStorage(NotificationsFilter.NOTIFICATIONS_FILTER_KEY);
+        if (data) {
+            result = data as Record<string, INotificationsFilter>;
+        }
+        return result;
+    }
+
+    public static update(page: INotificationsFilter) {
+        Promise.all([NotificationsFilter.get()])
+            .then(([pages]) => {
+                pages[page.pageId] = page;
+                Preferences.setStorage(NotificationsFilter.NOTIFICATIONS_FILTER_KEY, pages);
+            })
+            .catch((error: unknown) => console.error('Failed to get notifications filter:', error));
+    }
+
+    public static filterPages(pages: readonly Page[], filters: Record<string, INotificationsFilter>, muteTime: number) {
+        const now = Date.now();
+        return pages.filter((entry) => {
+            const existingPage = filters[entry.pageId];
+
+            if (!existingPage) return true;
+
+            return existingPage.timestamp + muteTime < now;
+        });
+    }
+}
+
+export default NotificationsFilter;