feat(#9255): adds androidApi service to calculate task notifications

config/default/app_settings.json

@@ -284,6 +284,7 @@
     "can_default_facility_filter": [],
     "can_have_multiple_places": [],
     "can_skip_password_change": [],
+    "can_get_task_notifications": [],
     "can_export_devices_details": [
       "national_admin"
     ]

webapp/src/ts/services/android-api.service.ts

@@ -5,6 +5,7 @@ import { GeolocationService } from '@mm-services/geolocation.service';
 import { MRDTService } from '@mm-services/mrdt.service';
 import { SessionService } from '@mm-services/session.service';
 import { NavigationService } from '@mm-services/navigation.service';
+import { TasksNotificationService } from '@mm-services/task-notifications.service';
 
 /**
  * An API to provide integration with the medic-android app.
@@ -24,6 +25,7 @@ export class AndroidApiService {
     private sessionService:SessionService,
     private zone:NgZone,
     private navigationService:NavigationService,
+    private readonly tasksNotificationService: TasksNotificationService,
   ) { }
 
   private runInZone(property:string, args:any[]=[]) {
@@ -168,6 +170,14 @@ export class AndroidApiService {
     this.sessionService.logout();
   }
 
+  /**
+   * Gets notifcations for tasks
+   * returns {Promise} A promise that resolves to Notification[].
+   */
+  taskNotifications() {
+    return this.tasksNotificationService.get();
+  }
+
   /**
    * Handle the response from the MRDT app
    * @param response The stringified JSON response from the MRDT app.
@@ -222,5 +232,6 @@ export class AndroidApiService {
     smsStatusUpdate: (...args) => this.runInZone('smsStatusUpdate', args),
     locationPermissionRequestResolved: () => this.runInZone('locationPermissionRequestResolve'),
     resolveCHTExternalAppResponse: (...args) => this.runInZone('resolveCHTExternalAppResponse', args),
+    taskNotifications: () => this.runInZone('taskNotifications'),
   };
 }

webapp/src/ts/services/rules-engine.service.ts

@@ -33,13 +33,20 @@ interface DebounceActive {
   };
 }
 
+interface TaskDoc {
+  _id: string;
+  emission?: any;
+  owner: string;
+  stateHistory: Array<{ state: string, timestamp: number }>;
+}
+
 @Injectable({
   providedIn: 'root'
 })
 export class RulesEngineCoreFactoryService {
   constructor(
     private dbService: DbService
-  ) {}
+  ) { }
 
   get() {
     return RulesEngineCore(this.dbService.get());
@@ -63,23 +70,23 @@ export class RulesEngineService implements OnDestroy {
   private observable = new Subject();
 
   constructor(
-    private translateService:TranslateService,
-    private authService:AuthService,
-    private sessionService:SessionService,
-    private settingsService:SettingsService,
-    private telemetryService:TelemetryService,
-    private performanceService:PerformanceService,
-    private uhcSettingsService:UHCSettingsService,
-    private userContactService:UserContactService,
-    private userSettingsService:UserSettingsService,
-    private parseProvider:ParseProvider,
-    private changesService:ChangesService,
-    private contactTypesService:ContactTypesService,
-    private translateFromService:TranslateFromService,
-    private rulesEngineCoreFactoryService:RulesEngineCoreFactoryService,
-    private calendarIntervalService:CalendarIntervalService,
-    private ngZone:NgZone,
-    private chtDatasourceService:CHTDatasourceService
+    private translateService: TranslateService,
+    private authService: AuthService,
+    private sessionService: SessionService,
+    private settingsService: SettingsService,
+    private telemetryService: TelemetryService,
+    private performanceService: PerformanceService,
+    private uhcSettingsService: UHCSettingsService,
+    private userContactService: UserContactService,
+    private userSettingsService: UserSettingsService,
+    private parseProvider: ParseProvider,
+    private changesService: ChangesService,
+    private contactTypesService: ContactTypesService,
+    private translateFromService: TranslateFromService,
+    private rulesEngineCoreFactoryService: RulesEngineCoreFactoryService,
+    private calendarIntervalService: CalendarIntervalService,
+    private ngZone: NgZone,
+    private chtDatasourceService: CHTDatasourceService
   ) {
     this.initialized = this.initialize();
     this.rulesEngineCore = this.rulesEngineCoreFactoryService.get();
@@ -142,7 +149,7 @@ export class RulesEngineService implements OnDestroy {
     this.debounceActive[this.FRESHNESS_KEY] = {
       active: true,
       performance: {
-        name: this.getTelemetryTrackName( 'background-refresh', 'cancel'),
+        name: this.getTelemetryTrackName('background-refresh', 'cancel'),
         track: this.performanceService.track()
       },
       debounceRef: rulesDebounceRef
@@ -169,15 +176,16 @@ export class RulesEngineService implements OnDestroy {
     debounceInfo.active = false;
   }
 
-  private waitForDebounce(entity):Promise<any> | undefined {
+  private waitForDebounce(entity): Promise<any> | undefined {
     if (this.debounceActive[entity]?.active && this.debounceActive[entity]?.promise) {
       return this.debounceActive[entity].promise;
     }
 
     return Promise.resolve();
   }
 
-  private getRulesEngineContext(settingsDoc, userContactDoc, userSettingsDoc, enableTasks, enableTargets, chtScriptApi){
+  private getRulesEngineContext(settingsDoc, userContactDoc, userSettingsDoc, 
+    enableTasks, enableTargets, chtScriptApi) {
     return {
       settingsDoc,
       userContactDoc,
@@ -327,7 +335,7 @@ export class RulesEngineService implements OnDestroy {
     return this.rulesEngineCore.updateEmissionsFor(_uniq(contactsWithUpdatedTasks));
   }
 
-  private hydrateTaskDocs(taskDocs: { _id: string; emission?: any; owner: string }[] = []) {
+  private hydrateTaskDocs(taskDocs: Array<TaskDoc> = []) {
     taskDocs.forEach(taskDoc => {
       const { emission } = taskDoc;
       if (!emission) {
@@ -501,7 +509,7 @@ export class RulesEngineService implements OnDestroy {
     return this.observable.subscribe(callback);
   }
 
-  private getTelemetryTrackName(...params:string[]) {
+  private getTelemetryTrackName(...params: string[]) {
     return ['rules-engine', ...params].join(':');
   }
 

webapp/src/ts/services/task-notifications.service.ts

@@ -0,0 +1,117 @@
+import { Injectable } from '@angular/core';
+import * as moment from 'moment';
+
+import { RulesEngineService } from '@mm-services/rules-engine.service';
+import { TranslateService } from '@mm-services/translate.service';
+import { FormatDateService } from '@mm-services/format-date.service';
+import { SettingsService } from '@mm-services/settings.service';
+import { AuthService } from '@mm-services/auth.service';
+
+const TASK_NOTIFICATION_DAY = 'cht-task-notification-day';
+const LATEST_NOTIFICATION_TIMESTAMP = 'cht-task-notification-timestamp';
+const DEFAULT_MAX_NOTIFICATIONS = 10;
+
+export interface Notification {
+  _id: string,
+  readyAt: number,
+  title: string,
+  contentText: string,
+  dueDate: string,
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class TasksNotificationService {
+
+  constructor(
+    private readonly rulesEngineService: RulesEngineService,
+    private readonly translateService: TranslateService,
+    private readonly formatDateService: FormatDateService,
+    private readonly settingsService: SettingsService,
+    private readonly authService: AuthService,
+  ) { }
+
+  private async fetchNotifications(): Promise<Notification[]> {
+    try {
+      const isEnabled = await this.rulesEngineService.isEnabled();
+      if (!isEnabled) {
+        return [];
+      }
+      const today = moment().format('YYYY-MM-DD');
+      let latestNotificationTimestamp = this.getLatestNotificationTimestamp();
+      const taskDocs = await this.rulesEngineService.fetchTaskDocsForAllContacts();
+
+      let notifications: Notification[] = [];
+
+      taskDocs.forEach(task => {
+        const readyAt = this.getReadyStateTimestamp(task.stateHistory);
+        const dueDate = task.emission.dueDate;
+        if (dueDate <= today && readyAt > latestNotificationTimestamp) {
+          notifications.push({
+            _id: task._id,
+            readyAt,
+            title: task.emission.title,
+            contentText: this.translateContentText(
+              task.emission.title,
+              task.emission.contact.name,
+              task.emission.dueDate
+            ),
+            dueDate,
+          });
+        }
+      });
+
+      notifications = notifications.sort((a, b) => b.readyAt - a.readyAt);
+      notifications = notifications.slice(0, await this.getMaxNotificationSettings());
+      latestNotificationTimestamp = notifications[0]?.readyAt ?? latestNotificationTimestamp;
+      window.localStorage.setItem(LATEST_NOTIFICATION_TIMESTAMP, String(latestNotificationTimestamp));
+      return notifications;
+
+    } catch (exception) {
+      console.error('fetchNotifications(): Error fetching tasks', exception);
+      return [];
+    }
+  }
+
+  private getReadyStateTimestamp(stateHistory): number {
+    const readyState = stateHistory.find(state => state.state === 'Ready');
+    return readyState ? readyState.timestamp : 0;
+  }
+
+  private async getMaxNotificationSettings(): Promise<number> {
+    const settings = await this.settingsService.get();
+    if (settings?.tasks?.max_task_notifications) {
+      return settings.tasks.max_task_notifications;
+    }
+    console.warn('Invalid or missing max_task_notifications setting, using default value');
+    return DEFAULT_MAX_NOTIFICATIONS;
+  }
+
+  private getLatestNotificationTimestamp(): number {
+    if (this.isNewDay()) {
+      window.localStorage.setItem(TASK_NOTIFICATION_DAY, String(moment().startOf('day').valueOf()));
+      return 0;
+    }
+    return Number(window.localStorage.getItem(LATEST_NOTIFICATION_TIMESTAMP));
+  }
+
+  private isNewDay(): boolean {
+    const timestampToday = Number(window.localStorage.getItem(TASK_NOTIFICATION_DAY));
+    return !moment().isSame(timestampToday, 'day');
+  }
+
+  private translateContentText(taskName: string, contact: string, dueDate: string): string {
+    const key = 'android.notification.tasks.contentText';
+    const due = this.formatDateService.relative(dueDate, { task: true });
+    return this.translateService.instant(key, { taskName, contact, due });
+  }
+
+  async get(): Promise<Notification[]> {
+    const canGetTaskNotifications = await this.authService.has('can_get_task_notifications');
+    if (!canGetTaskNotifications) {
+      return [];
+    }
+    return await this.fetchNotifications();
+  }
+}

webapp/tests/karma/ts/services/android-api.service.spec.ts

@@ -9,6 +9,11 @@ import { GeolocationService } from '@mm-services/geolocation.service';
 import { MRDTService } from '@mm-services/mrdt.service';
 import { NavigationService } from '@mm-services/navigation.service';
 import { AndroidAppLauncherService } from '@mm-services/android-app-launcher.service';
+import { TranslateService } from '@mm-services/translate.service';
+import { RulesEngineService } from '@mm-services/rules-engine.service';
+import { FormatDateService } from '@mm-services/format-date.service';
+import { SettingsService } from '@mm-services/settings.service';
+import { AuthService } from '@mm-services/auth.service';
 
 describe('AndroidApi service', () => {
 
@@ -19,6 +24,7 @@ describe('AndroidApi service', () => {
   let consoleErrorMock;
   let navigationService;
   let androidAppLauncherService;
+  let translateService;
 
   beforeEach(() => {
     sessionService = {
@@ -47,13 +53,23 @@ describe('AndroidApi service', () => {
 
     consoleErrorMock = sinon.stub(console, 'error');
 
+    translateService = {
+      get: sinon.stub().resolvesArg(0),
+      instant: sinon.stub().returnsArg(0),
+    };
+
     TestBed.configureTestingModule({
       providers: [
         { provide: SessionService, useValue: sessionService },
         { provide: GeolocationService, useValue: geolocationService },
         { provide: MRDTService, useValue: mrdtService },
         { provide: NavigationService, useValue: navigationService },
         { provide: AndroidAppLauncherService, useValue: androidAppLauncherService },
+        { provide: TranslateService, useValue: translateService },
+        { provide: RulesEngineService, useValue: {} },
+        { provide: FormatDateService, useValue: {} },
+        { provide: SettingsService, useValue: {} },
+        { provide: AuthService, useValue: {} },
       ],
     });