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

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

@@ -27,19 +27,27 @@ interface DebounceActive {
     active?: boolean;
     debounceRef?: any;
     performance?: any;
-    params?:any;
-    promise?:Promise<any>;
-    resolve?:any;
+    params?: any;
+    promise?: Promise<any>;
+    resolve?: any;
   };
 }
 
+interface TaskDoc {
+  _id: string;
+  emission?: any;
+  owner: string
+  state: string;
+  authoredOn: number;
+}
+
 @Injectable({
   providedIn: 'root'
 })
 export class RulesEngineCoreFactoryService {
   constructor(
     private dbService: DbService
-  ) {}
+  ) { }
 
   get() {
     return RulesEngineCore(this.dbService.get());
@@ -63,23 +71,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 +150,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 +177,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 +336,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 +510,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,103 @@
+import { Injectable } from '@angular/core';
+import * as moment from 'moment';
+import { orderBy } from 'lodash-es';
+
+import { RulesEngineService } from '@mm-services/rules-engine.service';
+import { TranslateService } from '@mm-services/translate.service';
+import { DBSyncService } from '@mm-services/db-sync.service';
+
+/* 
+** avoid overloading app with too many notifications especially at once
+** 24 for android >= 10
+*/
+const MAX_NOTIFICATIONS = 24;
+const TODAY_TIMESTAMP = 'cht-today-timestamp';
+const LATEST_NOTIFICATION_TIMESTAMP = 'cht-latest-notification-timestamp';
+
+export interface Notification {
+  _id: string,
+  authoredOn: number,
+  state: string,
+  title: string,
+  contentText: string,
+  dueDate: string,
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class TasksNotificationService {
+
+  constructor(
+    private readonly rulesEngineService: RulesEngineService,
+    private readonly translateService: TranslateService,
+    private readonly dbSyncService: DBSyncService
+  ) { }
+
+  private async fetchNotifications(): Promise<Notification[]> {
+    try {
+      const today = moment().format('YYYY-MM-DD');
+      let latestNotificationTimestamp = this.getLatestNotificationTimestamp();
+      const isEnabled = await this.rulesEngineService.isEnabled();
+      const taskDocs = isEnabled ? await this.rulesEngineService.fetchTaskDocsForAllContacts() : [];
+
+      let notifications = taskDocs
+        .filter(task => {
+          return task.state === 'Ready' && task.emission.dueDate === today && 
+            task.authoredOn > latestNotificationTimestamp;
+        })
+        .map(task => ({
+          _id: task._id,
+          authoredOn: task.authoredOn,
+          state: task.state,
+          title: task.emission.title,
+          contentText: this.translateContentText(task.emission.title, task.emission.contact.name),
+          dueDate: task.emission.dueDate,
+        }));
+
+      notifications = orderBy(notifications, ['authoredOn'], ['desc']);
+      notifications = notifications.slice(0, MAX_NOTIFICATIONS);
+      latestNotificationTimestamp = notifications[0]?.authoredOn ?? latestNotificationTimestamp;
+      window.localStorage.setItem(LATEST_NOTIFICATION_TIMESTAMP, String(latestNotificationTimestamp));
+      return notifications;
+
+    } catch (exception) {
+      console.error('fetchNotifications(): Error fetching tasks', exception);
+      return [];
+    }
+  }
+
+  private getLatestNotificationTimestamp(): number {
+    if (this.isNewDay()) {
+      return 0;
+    }
+    return Number(window.localStorage.getItem(LATEST_NOTIFICATION_TIMESTAMP));
+  }
+
+  private isNewDay(): boolean {
+    const now = moment();
+    const timestampToday = Number(window.localStorage.getItem(TODAY_TIMESTAMP));
+    if (!now.isSame(timestampToday, 'day')) {
+      window.localStorage.setItem(TODAY_TIMESTAMP, String(moment().startOf('day').valueOf()));
+      return true;
+    }
+    return false;
+  }
+
+  private translateContentText(task: string, contact: string): string {
+    const key = 'android.notification.tasks.contentText';
+    return this.translateService.instant(key, { task, contact });
+  }
+
+  async get(): Promise<Notification[]> {
+    return Promise.race([
+      this.dbSyncService.sync(),
+      new Promise(resolve => setTimeout(() => resolve([]), 5 * 1000))
+    ]).then(() => {
+      return this.fetchNotifications();
+    }).catch((error) => {
+      console.error('get(): notifications error syncing db', error);
+      return this.fetchNotifications();
+    });
+  }
+}

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

@@ -9,6 +9,9 @@ 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 { DBSyncService } from '@mm-services/db-sync.service';
 
 describe('AndroidApi service', () => {
 
@@ -19,6 +22,9 @@ describe('AndroidApi service', () => {
   let consoleErrorMock;
   let navigationService;
   let androidAppLauncherService;
+  let translateService;
+  let rulesEngine;
+  let dbSyncService;
 
   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),
+    };
+    rulesEngine = { };
+    dbSyncService = { sync: sinon.stub() };
+
     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: rulesEngine },
+        { provide: DBSyncService, useValue: dbSyncService },
       ],
     });