Add ability to mute words from the main feed (#46)

* Add ability to mute words from the main feed

* Add mute toast feedback

Author: derme302

src/app/services/feed.service.spec.ts

@@ -13,4 +13,24 @@ describe('FeedService', () => {
   it('should be created', () => {
     expect(service).toBeTruthy();
   });
+
+  it('filters out articles with muted words', () => {
+    const settings = {
+      preview: true,
+      showImages: false,
+      compressedFeed: false,
+      locale: 'en-AU',
+      retrievalTimeout: 5000, // 5 seconds
+      defaultPollingFrequency: 0, // Unlimited
+      maxFeedLength: 10,
+      mutedWords: ['spoiler']
+    };
+    const articles = [
+      { title: 'Spoiler Alert', content: '...'},
+      { title: 'Daily News', content: '...'}
+    ];
+    const result = service.filterArticles(articles, settings);
+    expect(result.length).toBe(1);
+    expect(result[0].title).toBe('Daily News');
+  });
 });

src/app/services/feed.service.ts

@@ -3,6 +3,7 @@
 import { Injectable, OnDestroy } from '@angular/core';
 import { StorageService } from './storage.service';
 import { SourcesService } from './sources.service';
+import { ISettingsDict, SettingsService } from './settings.service';
 
 const STORAGE_FEED_DATA = 'storage_list_feed_data';
 const STORAGE_FEED_DATA_TIMESTAMP = 'storage_list_feed_data_timestamp';
@@ -14,8 +15,9 @@ export class FeedService implements OnDestroy {
 
   public entries: any = [];
   public lastUpdated: number = 0;
+  public hidden: number = 0;
 
-  constructor(private sourcesService: SourcesService, private storageService: StorageService) { 
+  constructor(private settingsService: SettingsService, private sourcesService: SourcesService, private storageService: StorageService) { 
     this.storageService.onReady.subscribe(() => {
       this.initFeedData(this.storageService.onReady.value);
     });
@@ -51,7 +53,7 @@ export class FeedService implements OnDestroy {
   public async syncEntriesWithUpstream(event: any): Promise<void> {
     try {
       const feedList = this.sourcesService.getSources();
-      const tempFeedMasterData = await Promise.all(
+      let tempFeedMasterData = await Promise.all(
         feedList.map(async (feed) => {
           const nextPollDate = feed.lastRetrieved + (feed.pollingFrequency * 1000); // Milliseconds
           let feedData: Array<any> | null = null;
@@ -73,11 +75,15 @@ export class FeedService implements OnDestroy {
       );
 
       // Flatten the array of arrays and update master feed
-      this.entries = this.sortByDate(tempFeedMasterData.flat());
+      tempFeedMasterData = this.sortByDate(tempFeedMasterData.flat());
+      this.entries = this.filterArticles(tempFeedMasterData, this.settingsService.getSettings());
+      this.hidden = tempFeedMasterData.length - this.entries.length; 
       this.storageService.set(STORAGE_FEED_DATA, JSON.stringify(this.entries));
       console.log('[FeedService] Rebuilt master feed from upstream');
       this.lastUpdated = Date.now();
       this.storageService.set(STORAGE_FEED_DATA_TIMESTAMP, this.lastUpdated);
+      if (this.hidden > 0)
+        this.sourcesService.presentWarnToast(`${this.hidden} articles muted`);
       event.target.complete();
     } catch (error) {
       console.error('[FeedService] An error occurred:', error);
@@ -103,6 +109,11 @@ export class FeedService implements OnDestroy {
     }
 
     this.entries = this.sortByDate(this.entries);
+    const fullLength = this.entries.length;
+    this.entries = this.filterArticles(this.entries, this.settingsService.getSettings());
+    this.hidden = fullLength - this.entries.length;
+    if (this.hidden > 0)
+      this.sourcesService.presentWarnToast(`${this.hidden} articles muted`);
     this.storageService.set(STORAGE_FEED_DATA, JSON.stringify(this.entries));
     console.log('[FeedService] Appended feed ' + feedUrl + ' from cache');
   }
@@ -115,9 +126,19 @@ export class FeedService implements OnDestroy {
       console.warn(`[FeedService] ${item.url} not found for bookmark status change`);
   }
 
-  private sortByDate(array: Array<any>): Array<any> {
+  public sortByDate(array: Array<any>): Array<any> {
     return array.sort((a: any, b: any) => {
       return new Date(b.isoDate).valueOf() - new Date(a.isoDate).valueOf();
     });
   }
+
+  public filterArticles(array: Array<any>, settings: ISettingsDict): Array<any> {
+    const muted = settings.mutedWords.map(w => w.toLowerCase());
+    return array.filter(a => {
+      const content = (a.title + ' ' + a.content).toLowerCase();
+      return !muted.some(word => content.includes(word));
+    });
+  }
+
+
 }

src/app/services/settings.service.ts

@@ -10,7 +10,8 @@ export interface ISettingsDict {
     locale: string,
     retrievalTimeout: number,
     defaultPollingFrequency: number,
-    maxFeedLength: number
+    maxFeedLength: number,
+    mutedWords: Array<string>
 }
 
 @Injectable({
@@ -24,7 +25,8 @@ export class SettingsService {
     locale: 'en-AU',
     retrievalTimeout: 5000, // 5 seconds
     defaultPollingFrequency: 0, // Unlimited
-    maxFeedLength: 10
+    maxFeedLength: 10,
+    mutedWords: []
   };
 
   constructor(private storageService: StorageService) {
@@ -54,10 +56,17 @@ export class SettingsService {
   }
 
   public async loadSettingsDict() {
+    console.log('[SettingsService] Loading settings from storage');
     const storage_feed = await this.storageService.getObjectFromStorage(SETTINGS_DICT);
 
-    if (storage_feed !== null)
+    if (storage_feed !== null) {
+      // Backwards compatible check with <= 2.3.4
+      if (!Array.isArray(storage_feed.mutedWords)) {
+        storage_feed.mutedWords = [];
+      }
+
       this._settingsDict = storage_feed;
+    }
     else
       this.storageService.set(SETTINGS_DICT, JSON.stringify(this._settingsDict));
   }

src/app/services/sources.service.ts

@@ -210,7 +210,7 @@ export class SourcesService {
     return tempFeedData;
   }
 
-  async presentErrorToast(message: string) {
+  public async presentErrorToast(message: string) {
     const toast = await this.toastController.create({
       message: message,
       duration: 2000,
@@ -222,6 +222,18 @@ export class SourcesService {
     await toast.present();
   }
 
+  public async presentWarnToast(message: string) {
+    const toast = await this.toastController.create({
+      message: message,
+      duration: 2000,
+      position: 'bottom',
+      color: 'warning',
+      positionAnchor: 'tab-bar'
+    });
+
+    await toast.present();
+  }
+
   private getItemMedia(item: any): string | null {
     let mediaLinkURL = item.mediaContent;
 

src/app/settings/settings.component.html

@@ -50,5 +50,9 @@ <h1>Preferences</h1>
         <ion-select-option value="0">Unlimited</ion-select-option>
       </ion-select>
     </ion-item>
+    <ion-item button (click)="openMutedWordsDialog()">
+      <ion-label>Muted Words</ion-label>
+      <ion-note slot="end">{{ (currentSettings.mutedWords || []).length }}</ion-note>
+    </ion-item>
   </ion-list>
 </ion-content>

src/app/settings/settings.component.ts

@@ -1,22 +1,22 @@
 import { Component, OnInit } from '@angular/core';
-import { IonContent, IonInput, IonItem, IonList, IonModal, IonSelect, IonSelectOption, IonToggle } from '@ionic/angular/standalone';
-import { ISettingsDict, SettingsService } from '../services/settings.service';
 import { FormsModule } from '@angular/forms';
+import { AlertController, IonContent, IonInput, IonItem, IonLabel, IonList, IonModal, IonNote, IonSelect, IonSelectOption, IonToggle } from '@ionic/angular/standalone';
+import { ISettingsDict, SettingsService } from '../services/settings.service';
 import { CountryCodeList } from './country-code-list';
 
 @Component({
   selector: 'app-settings',
   templateUrl: './settings.component.html',
   styleUrls: ['./settings.component.scss'],
   standalone: true,
-  imports: [FormsModule, IonSelectOption, IonSelect, IonInput, IonItem, IonToggle, IonList, IonContent, IonModal]
+  imports: [FormsModule, IonNote, IonSelectOption, IonSelect, IonInput, IonItem, IonToggle, IonLabel, IonList, IonContent, IonModal]
 })
 export class SettingsComponent  implements OnInit {
 
   public currentSettings: ISettingsDict;
   public countryCodeList = CountryCodeList;
 
-  constructor(public settingsService: SettingsService) {
+  constructor(public settingsService: SettingsService, private alertController: AlertController) {
     this.currentSettings = this.settingsService.getSettings();
   }
 
@@ -31,6 +31,61 @@ export class SettingsComponent  implements OnInit {
     return country.officialLanguageCode + '-' + country.countryCode;
   }
 
+  async openMutedWordsDialog() {
+    const alert = await this.alertController.create({
+      header: 'Muted Words',
+      inputs: this.currentSettings.mutedWords.map(word => ({
+        name: word,
+        type: 'checkbox',
+        label: word,
+        value: word,
+        checked: true,
+      })),
+      buttons: [
+        {
+          text: 'Add New',
+          handler: async () => {
+            const prompt = await this.alertController.create({
+              header: 'Add Muted Word',
+              inputs: [
+                {
+                  name: 'newWord',
+                  type: 'text',
+                  placeholder: 'e.g., politics'
+                }
+              ],
+              buttons: [
+                { text: 'Cancel', role: 'cancel' },
+                {
+                  text: 'Add',
+                  handler: (data) => {
+                    if (data.newWord?.trim()) {
+                      this.currentSettings.mutedWords.push(data.newWord.trim().toLowerCase());
+                      this.settingsService.updateSettings(this.currentSettings);
+                    }
+                  }
+                }
+              ]
+            });
+            await prompt.present();
+          }
+        },
+        {
+          text: 'Remove Selected',
+          handler: (selected: string[]) => {
+            this.currentSettings.mutedWords = this.currentSettings.mutedWords.filter(w => !selected.includes(w));
+            this.settingsService.updateSettings(this.currentSettings);
+          }
+        },
+        {
+          text: 'Cancel',
+          role: 'cancel'
+        }
+      ]
+    });
+    await alert.present();
+  }
+
   // Getter/Setters for settings stored as numbers to ensure types are correct
   get retrievalTimeout() { return String(this.currentSettings.retrievalTimeout); }
   set retrievalTimeout(v) { this.currentSettings.retrievalTimeout = Number(v); }