feat(#9231): add facility indicator in aggregates targets (#9282)

Author: latin-panda

webapp/tests/karma/ts/modules/analytics/analytics-target-aggregates-sidebar-filter-component.spec.ts

@@ -1,222 +1,122 @@
-import { ComponentFixture, fakeAsync, flush, TestBed } from '@angular/core/testing';
-import { MatExpansionModule } from '@angular/material/expansion';
-import { TranslateFakeLoader, TranslateLoader, TranslateModule } from '@ngx-translate/core';
-import sinon from 'sinon';
-import { expect } from 'chai';
-import { FormsModule } from '@angular/forms';
-import { provideMockStore, MockStore } from '@ngrx/store/testing';
-
-import { Selectors } from '@mm-selectors/index';
-import { AnalyticsTargetAggregatesSidebarFilterComponent }
-  from '@mm-modules/analytics/analytics-target-aggregates-sidebar-filter.component';
-import { ContactTypesService } from '@mm-services/contact-types.service';
-import { SettingsService } from '@mm-services/settings.service';
-import { GlobalActions } from '@mm-actions/global';
-import { ReportingPeriod } from '@mm-modules/analytics/analytics-target-aggregates-sidebar-filter.component';
-
-describe('Analytics Target Aggregate Sidebar Filter Component', () => {
-  let component: AnalyticsTargetAggregatesSidebarFilterComponent;
-  let fixture: ComponentFixture<AnalyticsTargetAggregatesSidebarFilterComponent>;
-  let contactTypesService;
-  let settingsService;
-  let globalActions;
-  let store: MockStore;
-
-  beforeEach(async () => {
-    contactTypesService = {
-      getTypeId: sinon.stub().returns('district_hospital')
-    };
-    settingsService = {
-      get: sinon.stub().resolves(
-        { contact_types: [{ id: 'district_hospital', name_key: 'District Hospital', }] }
-      )
-    };
-    globalActions = {
-      setSidebarFilter: sinon.stub(GlobalActions.prototype, 'setSidebarFilter'),
-    };
-
-    const mockedSelectors = [
-      { selector: Selectors.getSidebarFilter, value: {} },
-    ];
-
-    await TestBed
-      .configureTestingModule({
-        imports: [
-          FormsModule,
-          TranslateModule.forRoot({ loader: { provide: TranslateLoader, useClass: TranslateFakeLoader } }),
-          MatExpansionModule
-        ],
-        declarations: [
-          AnalyticsTargetAggregatesSidebarFilterComponent,
-        ],
-        providers: [
-          provideMockStore({ selectors: mockedSelectors }),
-          { provide: ContactTypesService, useValue: contactTypesService },
-          { provide: SettingsService, useValue: settingsService },
-        ]
+import { Injectable } from '@angular/core';
+import { Place } from '@medic/cht-datasource';
+
+import { CacheService } from '@mm-services/cache.service';
+import { GetDataRecordsService } from '@mm-services/get-data-records.service';
+import { DbService } from '@mm-services/db.service';
+import { SessionService } from '@mm-services/session.service';
+import { LanguageService } from '@mm-services/language.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UserSettingsService {
+  private readonly cache;
+  constructor(
+    private cacheService: CacheService,
+    private getDataRecordsService: GetDataRecordsService,
+    private dbService: DbService,
+    private languageService: LanguageService,
+    private sessionService: SessionService,
+  ) {
+    this.cache = this.cacheService.register({
+      get: callback => {
+        const docId = this.userDocId();
+        this.dbService.get()
+          .get(docId)
+          .catch(() => {
+            // might be first load - try the remote db
+            return dbService.get({ remote: true }).get(docId);
+          })
+          .then(doc => {
+            callback(null, doc);
+          })
+          .catch(callback);
+      },
+      invalidate: change => {
+        const docId = this.userDocId();
+        return change.id === docId;
+      }
+    });
+  }
+
+  private userDocId() {
+    const userCtx = this.sessionService.userCtx();
+    if (userCtx) {
+      return 'org.couchdb.user:' + userCtx.name;
+    }
+  }
+
+  get(): Promise<UserSettings> {
+    const docId = this.userDocId();
+    if (!docId) {
+      return Promise.reject(new Error('UserCtx not found'));
+    }
+
+    return new Promise((resolve, reject) => {
+      this.cache((err, userSettings: UserSettings) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(userSettings);
+      });
+    });
+  }
+
+  async hasMultipleFacilities(): Promise<boolean> {
+    return this
+      .get()
+      .then((userSettings: UserSettings) => {
+        const userFacility = userSettings.facility_id;
+        return Array.isArray(userFacility) && userFacility.length > 1;
+      });
+  }
+
+  getUserFacilities(): Promise<Place.v1.Place[]> {
+    return this
+      .get()
+      .then((userSettings: UserSettings) => {
+        let userFacilities = userSettings.facility_id;
+        if (userFacilities && !Array.isArray(userFacilities)) {
+          userFacilities = [userFacilities];
+        }
+        return this.getDataRecordsService.get(userFacilities);
       })
-      .compileComponents()
-      .then(() => {
-        fixture = TestBed.createComponent(AnalyticsTargetAggregatesSidebarFilterComponent);
-        component = fixture.componentInstance;
-        store = TestBed.inject(MockStore);
-        component.userFacilities = [];
-        fixture.detectChanges();
+      .catch((err) => {
+        console.error('Error fetching user facility:', err);
+        return [];
       });
-  });
-
-  afterEach(() => {
-    store.resetSelectors();
-    sinon.restore();
-  });
-
-  it('should create component', fakeAsync(() => {
-    expect(component).to.exist;
-    expect(component.isOpen).to.be.false;
-  }));
-
-  it('should unsubscribe from observables on component destroy', () => {
-    const unsubscribeSpy = sinon.spy(component.subscriptions, 'unsubscribe');
-
-    component.ngOnDestroy();
-
-    expect(unsubscribeSpy.callCount).to.equal(1);
-  });
-
-  it('should toggle sidebar filter', () => {
-    component.toggleSidebarFilter();
-    component.toggleSidebarFilter();
-    component.toggleSidebarFilter();
-
-    expect(globalActions.setSidebarFilter.calledThrice).to.be.true;
-    expect(globalActions.setSidebarFilter.args[0][0]).to.deep.equal({ isOpen: true });
-    expect(globalActions.setSidebarFilter.args[1][0]).to.deep.equal({ isOpen: false });
-    expect(globalActions.setSidebarFilter.args[2][0]).to.deep.equal({ isOpen: true });
-  });
-
-  it('should set selectedFacility when default filter specified', fakeAsync(() => {
-    sinon.resetHistory();
-    store.overrideSelector(Selectors.getSidebarFilter, { defaultFilters: { facility: { _id: 'facility_2' } } });
-    store.refreshState();
-    flush();
-
-    expect(component.selectedFacility).to.deep.equal({ _id: 'facility_2' });
-
-    component.selectedFacility = null;
-    store.overrideSelector(Selectors.getSidebarFilter, { defaultFilters: { facility: { _id: 'facility_1' } } });
-    store.refreshState();
-    flush();
-
-    expect(component.selectedFacility).to.deep.equal({ _id: 'facility_1' });
-  }));
-
-  it('should not set selectedFacility when no default filter specified', fakeAsync(() => {
-    sinon.resetHistory();
-    store.overrideSelector(Selectors.getSidebarFilter, { defaultFilters: { facility: null } });
-    store.refreshState();
-    flush();
-
-    expect(component.selectedFacility).to.be.undefined;
-  }));
-
-  it('should set user facility name_key as facilityFilterLabel, when user has multiple facilities', fakeAsync(() => {
-    sinon.resetHistory();
-    component.userFacilities = [
-      { _id: 'id_1', type: 'district_hospital' },
-      { _id: 'id_2', type: 'district_hospital' },
-      { _id: 'id_3', type: 'district_hospital' },
-    ];
-    const settings = { contact_types: [{ id: 'district_hospital', name_key: 'District Hospital' }] };
-    settingsService.get.resolves(settings);
-    contactTypesService.getTypeId.returns('district_hospital');
-
-    component.ngOnInit();
-    flush();
-
-    expect(component.facilityFilterLabel).to.equal('District Hospital');
-    expect(contactTypesService.getTypeId.callCount).to.equal(1);
-    expect(settingsService.get.callCount).to.equal(1);
-  }));
-
-  it('should set error and default facilityFilterLabel when settingsService fails', fakeAsync(() => {
-    sinon.resetHistory();
-    component.userFacilities = [
-      { _id: 'place_1', type: 'district_hospital' },
-      { _id: 'place_2', type: 'district_hospital' },
-    ];
-    settingsService.get.rejects({ some: 'err' });
-
-    component.ngOnInit();
-    flush();
-
-    expect(component.facilityFilterLabel).to.equal(component.DEFAULT_FACILITY_LABEL);
-    expect(settingsService.get.callCount).to.equal(1);
-  }));
-
-  it('should set default facilityFilterLabel when getTypeId returns undefined', fakeAsync(() => {
-    sinon.resetHistory();
-    const settings = { contact_types: [{ id: 'district_hospital', name_key: 'District Hospital' }] };
-    component.userFacilities = [
-      { _id: 'place_1', type: 'district_hospital' },
-      { _id: 'place_2', type: 'district_hospital' },
-    ];
-    settingsService.get.resolves(settings);
-    contactTypesService.getTypeId.returns(undefined);
-
-    component.ngOnInit();
-    flush();
-
-    expect(component.facilityFilterLabel).to.equal(component.DEFAULT_FACILITY_LABEL);
-    expect(settingsService.get.callCount).to.equal(1);
-    expect(contactTypesService.getTypeId.callCount).to.equal(1);
-  }));
-
-  it('should set default facilityFilterLabel when contact type is not found', fakeAsync(() => {
-    sinon.resetHistory();
-    const settings = { contact_types: [{ id: 'health_center', name_key: 'Health Center' }] };
-    component.userFacilities = [
-      { _id: 'id_1', type: 'district_hospital' },
-      { _id: 'id_2', type: 'district_hospital' },
-    ];
-    settingsService.get.resolves(settings);
-    contactTypesService.getTypeId.returns('district_hospital');
-
-    component.ngOnInit();
-    flush();
-
-    expect(component.facilityFilterLabel).to.equal(component.DEFAULT_FACILITY_LABEL);
-    expect(settingsService.get.callCount).to.equal(1);
-    expect(contactTypesService.getTypeId.callCount).to.equal(1);
-  }));
-
-  it('should emit selected facility when fetchAggregateTargetsByFacility is called', () => {
-    const facility = { _id: 'place_1', type: 'district_hospital' };
-    const spyFacility = sinon.spy(component.facilitySelectionChanged, 'emit');
-
-    component.fetchAggregateTargetsByFacility(facility);
-
-    expect(component.selectedFacility).to.deep.equal(facility);
-    expect(spyFacility.callCount).to.equal(1);
-    expect(spyFacility.firstCall.args[0]).to.deep.equal(facility);
-  });
-
-  it('should emit default current reporting period when fetchAggregateTargetsByReportingPeriod is called', () => {
-    const spyReportingPeriod = sinon.spy(component.reportingPeriodSelectionChanged, 'emit');
-
-    component.selectedReportingPeriod = ReportingPeriod.CURRENT;
-    component.fetchAggregateTargetsByReportingPeriod();
-
-    expect(spyReportingPeriod.callCount).to.equal(1);
-    expect(spyReportingPeriod.firstCall.args[0]).to.equal(ReportingPeriod.CURRENT);
-  });
-
-  it('should emit previous reporting period when toggled', () => {
-    const spyReportingPeriod = sinon.spy(component.reportingPeriodSelectionChanged, 'emit');
-
-    component.selectedReportingPeriod = ReportingPeriod.PREVIOUS;
-    component.fetchAggregateTargetsByReportingPeriod();
-
-    expect(spyReportingPeriod.callCount).to.equal(1);
-    expect(spyReportingPeriod.firstCall.args[0]).to.equal(ReportingPeriod.PREVIOUS);
-  });
-});
+  }
+
+  async getWithLanguage(): Promise<Object> {
+    const [userSettings, language] = await Promise.all([
+      this.get(),
+      this.languageService.get()
+    ]);
+    return { ...userSettings, language };
+  }
+
+  put(doc): Promise<Object> {
+    return this.dbService
+      .get()
+      .put(doc);
+  }
+
+  setAsKnown(): Promise<Object> {
+    return this.get()
+      .then((userSettings: any) => {
+        userSettings.known = true;
+        return this.put(userSettings);
+      });
+  }
+
+}
+
+interface UserSettings {
+  _id: string;
+  contact_id: string;
+  facility_id: string[];
+  name: string;
+  roles: string[];
+  type: string;
+}