diff --git a/webapp/src/ts/modules/trainings/trainings-content.component.html b/webapp/src/ts/modules/trainings/trainings-content.component.html
new file mode 100644
index 00000000000..f9843168916
--- /dev/null
+++ b/webapp/src/ts/modules/trainings/trainings-content.component.html
@@ -0,0 +1,21 @@
+
+
+
{{ 'training_materials.page.no_selected' | translate }}
+
+
+
+
+
+
+
+
+
+
diff --git a/webapp/src/ts/modules/trainings/trainings-content.component.ts b/webapp/src/ts/modules/trainings/trainings-content.component.ts
new file mode 100644
index 00000000000..1fb5c052965
--- /dev/null
+++ b/webapp/src/ts/modules/trainings/trainings-content.component.ts
@@ -0,0 +1,112 @@
+import { Component, OnDestroy, OnInit, ViewChild } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { Store } from '@ngrx/store';
+import { Subscription } from 'rxjs';
+
+import { GlobalActions } from '@mm-actions/global';
+import { ModalService } from '@mm-services/modal.service';
+import { PerformanceService } from '@mm-services/performance.service';
+import { Selectors } from '@mm-selectors/index';
+
+@Component({
+ selector: 'training-content',
+ templateUrl: './trainings-content.component.html'
+})
+export class TrainingsContentComponent implements OnInit, OnDestroy {
+ @ViewChild('confirmModal') confirmModalTemplate;
+ private readonly globalActions: GlobalActions;
+ private confirmModalRef;
+ private trackRender;
+ private trainingCardID;
+ private canExit = false;
+ showNoSelection = false;
+ showConfirmExit = false;
+ hasError = false;
+ subscriptions: Subscription = new Subscription();
+
+ constructor(
+ private readonly store: Store,
+ private readonly route: ActivatedRoute,
+ private readonly router: Router,
+ private readonly modalService: ModalService,
+ private readonly performanceService: PerformanceService,
+ ) {
+ this.globalActions = new GlobalActions(this.store);
+ }
+
+ ngOnInit() {
+ this.trackRender = this.performanceService.track();
+ this.subscribeToRouteParams();
+ this.subscribeToStore();
+ }
+
+ ngOnDestroy() {
+ this.subscriptions.unsubscribe();
+ this.globalActions.clearNavigation();
+ this.globalActions.clearTrainingCards();
+ }
+
+ private subscribeToStore() {
+ const reduxSubscription = this.store
+ .select(Selectors.getTrainingCardFormId)
+ .subscribe(trainingCardID => this.trainingCardID = trainingCardID);
+ this.subscriptions.add(reduxSubscription);
+ }
+
+ private subscribeToRouteParams() {
+ const routeSubscription = this.route.params.subscribe(params => {
+ this.globalActions.setTrainingCard({ formId: params?.id || null });
+ if (!params?.id) {
+ this.showNoSelection = true;
+ this.globalActions.setShowContent(false);
+ }
+ });
+ this.subscriptions.add(routeSubscription);
+ }
+
+ close(nextUrl?) {
+ this.canExit = true;
+ this.globalActions.clearNavigation();
+ this.globalActions.clearTrainingCards();
+ if (nextUrl) {
+ return this.router.navigateByUrl(nextUrl);
+ }
+ return this.router.navigate([ '/', 'trainings' ]);
+ }
+
+ exitTraining(nextUrl: string) {
+ this.trackRender?.stop({
+ name: [ 'enketo', this.trainingCardID, 'add', 'quit' ].join(':'),
+ });
+
+ this.close(nextUrl);
+ this.confirmModalRef?.close();
+ }
+
+ continueTraining() {
+ this.confirmModalRef?.close();
+ }
+
+ quit() {
+ if (this.hasError) {
+ return this.close();
+ }
+
+ this.showConfirmExit = true;
+ this.confirmModalRef = this.modalService.show(this.confirmModalTemplate);
+ const subscription = this.confirmModalRef
+ ?.afterClosed()
+ .subscribe(() => this.showConfirmExit = false);
+ this.subscriptions.add(subscription);
+ }
+
+ canDeactivate(nextUrl) {
+ if (this.canExit) {
+ this.canExit = false;
+ return true;
+ }
+ this.globalActions.setTrainingCard({ nextUrl });
+ this.quit();
+ return false;
+ }
+}
diff --git a/webapp/src/ts/modules/trainings/trainings-route.guard.provider.ts b/webapp/src/ts/modules/trainings/trainings-route.guard.provider.ts
new file mode 100644
index 00000000000..6fe39900d6b
--- /dev/null
+++ b/webapp/src/ts/modules/trainings/trainings-route.guard.provider.ts
@@ -0,0 +1,18 @@
+import { CanDeactivate, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { Injectable } from '@angular/core';
+
+import { TrainingsContentComponent } from '@mm-modules/trainings/trainings-content.component';
+
+@Injectable({
+ providedIn: 'root'
+})
+export class TrainingsRouteGuardProvider implements CanDeactivate
{
+ canDeactivate(
+ component:TrainingsContentComponent,
+ currentRoute:ActivatedRouteSnapshot,
+ currentState:RouterStateSnapshot,
+ nextState:RouterStateSnapshot,
+ ) {
+ return component.canDeactivate(nextState.url);
+ }
+}
diff --git a/webapp/src/ts/modules/trainings/trainings.component.html b/webapp/src/ts/modules/trainings/trainings.component.html
new file mode 100644
index 00000000000..95ff6bf484e
--- /dev/null
+++ b/webapp/src/ts/modules/trainings/trainings.component.html
@@ -0,0 +1,42 @@
+
+
+
+
+
+
+
+
+
+
{{ 'training_materials.page.no_trainings' | translate }}
+
+ {{ 'training_materials.page.no_more_trainings' | translate }}
+
+
+
+
+
+
+
+
+
+
Tool bar mock
'
+ }
+ })
+ .compileComponents()
+ .then(() => {
+ fixture = TestBed.createComponent(TrainingsComponent);
+ component = fixture.componentInstance;
+ fixture.detectChanges();
+ sinon.resetHistory();
+ store = TestBed.inject(MockStore);
+ });
+ });
+
+ afterEach(() => {
+ store.resetSelectors();
+ sinon.restore();
+ });
+
+ it('should unsubscribe from store and clear selected from global state', () => {
+ const unsubscribeStub = sinon.stub(component.subscriptions, 'unsubscribe');
+
+ component.ngOnDestroy();
+
+ expect(unsubscribeStub.calledOnce).to.be.true;
+ expect(globalActions.unsetSelected.calledOnce).to.be.true;
+ });
+
+ it('should not get trainings when no forms', fakeAsync(async () => {
+ store.overrideSelector(Selectors.getTrainingMaterials, []);
+ store.refreshState();
+ flush();
+
+ expect(trainingCardsService.getNextTrainings.notCalled).to.be.true;
+ }));
+
+ it('should load trainings when there are forms', fakeAsync(async () => {
+ trainingCardsService.getNextTrainings.returns([ { code: 'form-1' } ]);
+ store.overrideSelector(Selectors.getTrainingMaterials, [ { _id: 'form-1' }, { _id: 'form-2' } ]);
+ store.refreshState();
+ flush();
+
+ expect(trainingCardsService.getNextTrainings.calledOnce).to.be.true;
+ expect(trainingCardsService.getNextTrainings.args[0]).to.have.deep.members([
+ [ { _id: 'form-1' }, { _id: 'form-2' } ],
+ 50,
+ 0,
+ ]);
+ expect(component.moreTrainings).to.be.false;
+ expect(component.loading).to.be.false;
+ expect(component.trainingList).to.have.deep.members([ { code: 'form-1' } ]);
+ expect(stopPerformanceTrackStub.calledOnce).to.be.true;
+ expect(scrollLoaderProvider.init.calledOnce).to.be.true;
+ expect(consoleErrorMock.notCalled).to.be.true;
+ }));
+
+ it('should load next page of trainings', fakeAsync(async () => {
+ store.overrideSelector(Selectors.getTrainingMaterials, [ { _id: 'form-3' }, { _id: 'form-4' } ]);
+ store.refreshState();
+ flush();
+ sinon.resetHistory();
+ const previousPage = Array
+ .from({ length: 50 })
+ .map((form, index) => ({
+ code: 'form-x-' + index,
+ id: 'form-id',
+ title: 'training-x',
+ startDate: new Date(),
+ duration: 1,
+ userRoles: [ 'chw' ],
+ isCompletedTraining: true,
+ }));
+ const nextPage = Array
+ .from({ length: 50 })
+ .map((form, index) => ({
+ code: 'form-y-' + index,
+ id: 'form-id',
+ title: 'training-y',
+ startDate: new Date(),
+ duration: 1,
+ userRoles: [ 'chw' ],
+ isCompletedTraining: true,
+ }));
+ component.trainingList = [...previousPage];
+ trainingCardsService.getNextTrainings.returns(nextPage);
+
+ await component.getTrainings();
+
+ expect(trainingCardsService.getNextTrainings.calledOnce).to.be.true;
+ expect(trainingCardsService.getNextTrainings.args[0]).to.have.deep.members([
+ [ { _id: 'form-3' }, { _id: 'form-4' } ],
+ 50,
+ 50,
+ ]);
+ expect(component.moreTrainings).to.be.true;
+ expect(component.loading).to.be.false;
+ expect(component.trainingList).to.have.deep.members([ ...previousPage, ...nextPage ]);
+ expect(scrollLoaderProvider.init.calledOnce).to.be.true;
+ expect(consoleErrorMock.notCalled).to.be.true;
+ }));
+
+ it('should catch error when loading a page of trainings', fakeAsync(async () => {
+ store.overrideSelector(Selectors.getTrainingMaterials, [ { _id: 'form-3' } ]);
+ store.refreshState();
+ flush();
+ sinon.resetHistory();
+ component.trainingList = [{
+ code: 'form-x',
+ id: 'form-id',
+ title: 'training-x',
+ startDate: new Date(),
+ duration: 1,
+ userRoles: [ 'chw' ],
+ isCompletedTraining: true,
+ }];
+ trainingCardsService.getNextTrainings.throws(new Error('Ups an error'));
+
+ await component.getTrainings();
+
+ expect(trainingCardsService.getNextTrainings.calledOnce).to.be.true;
+ expect(trainingCardsService.getNextTrainings.args[0]).to.have.deep.members([
+ [ { _id: 'form-3' } ],
+ 50,
+ 1,
+ ]);
+ expect(component.loading).to.be.false;
+ expect(stopPerformanceTrackStub.notCalled).to.be.true;
+ expect(scrollLoaderProvider.init.notCalled).to.be.true;
+ expect(consoleErrorMock.calledOnce).to.be.true;
+ expect(consoleErrorMock.args[0][0]).to.equal('Error getting training materials.');
+ }));
+});
+
diff --git a/webapp/tests/karma/ts/selectors/index.spec.ts b/webapp/tests/karma/ts/selectors/index.spec.ts
index ef29ab4fd92..579d7425eda 100644
--- a/webapp/tests/karma/ts/selectors/index.spec.ts
+++ b/webapp/tests/karma/ts/selectors/index.spec.ts
@@ -15,6 +15,7 @@ const globalState: GlobalState = {
showContent: true,
selectMode: false,
forms: [ { _id: 'these' } ],
+ trainingMaterials: [ { _id: 'these' } ],
filters: { some: 'filters' },
sidebarFilter: {
isOpen: false,
diff --git a/webapp/tests/karma/ts/services/training-cards.service.spec.ts b/webapp/tests/karma/ts/services/training-cards.service.spec.ts
index e7a67de3c7d..387c3718c4a 100644
--- a/webapp/tests/karma/ts/services/training-cards.service.spec.ts
+++ b/webapp/tests/karma/ts/services/training-cards.service.spec.ts
@@ -10,7 +10,8 @@ import { ModalService } from '@mm-services/modal.service';
import { TrainingCardsService } from '@mm-services/training-cards.service';
import { SessionService } from '@mm-services/session.service';
import { RouteSnapshotService } from '@mm-services/route-snapshot.service';
-import { FeedbackService } from '@mm-services/feedback.service';
+import { TranslateService } from '@ngx-translate/core';
+import { TranslateFromService } from '@mm-services/translate-from.service';
describe('TrainingCardsService', () => {
let service: TrainingCardsService;
@@ -20,24 +21,22 @@ describe('TrainingCardsService', () => {
let modalService;
let localDb;
let clock;
- let consoleErrorMock;
+ let consoleErrorSpy;
let sessionService;
let routeSnapshotService;
- let feedbackService;
beforeEach(() => {
- localDb = { allDocs: sinon.stub() };
+ localDb = { allDocs: sinon.stub().resolves({}) };
dbService = { get: () => localDb };
globalActions = { setTrainingCard: sinon.stub(GlobalActions.prototype, 'setTrainingCard') };
xmlFormsService = { subscribe: sinon.stub() };
modalService = { show: sinon.stub() };
sessionService = {
- userCtx: sinon.stub(),
+ userCtx: sinon.stub().returns({}),
hasRole: sinon.spy(SessionService.prototype, 'hasRole'),
};
- feedbackService = { submit: sinon.stub() };
- consoleErrorMock = sinon.stub(console, 'error');
- routeSnapshotService = { get: sinon.stub() };
+ consoleErrorSpy = sinon.spy(console, 'error');
+ routeSnapshotService = { get: sinon.stub().returns({}) };
TestBed.configureTestingModule({
providers: [
@@ -47,22 +46,23 @@ describe('TrainingCardsService', () => {
{ provide: ModalService, useValue: modalService },
{ provide: SessionService, useValue: sessionService },
{ provide: RouteSnapshotService, useValue: routeSnapshotService },
- { provide: FeedbackService, useValue: feedbackService },
- ]
+ { provide: TranslateService, useValue: { instant: sinon.stub() } },
+ { provide: TranslateFromService, useValue: { get: sinon.stub().returnsArg(0) } },
+ ],
});
service = TestBed.inject(TrainingCardsService);
});
afterEach(() => {
- clock && clock.restore();
+ clock?.restore();
sinon.restore();
document
.querySelectorAll('#enketo-test')
.forEach(element => element.remove());
});
- it('should set uncompleted training form when none are completed', async () => {
+ it('should show uncompleted training when none are completed', async () => {
sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'a_user' });
localDb.allDocs.resolves({ rows: [] });
clock = sinon.useFakeTimers(new Date('2022-05-23 20:29:25'));
@@ -104,16 +104,10 @@ describe('TrainingCardsService', () => {
},
},
];
- service.initTrainingCards();
-
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
- await callback(null, xforms);
+ await service.displayTrainingCards(xforms, true, true);
- expect(sessionService.userCtx.calledOnce).to.be.true;
+ expect(sessionService.userCtx.calledTwice).to.be.true;
expect(sessionService.hasRole.callCount).to.equal(4);
expect(localDb.allDocs.calledOnce).to.be.true;
expect(localDb.allDocs.args[0][0]).to.deep.equal({
@@ -121,13 +115,12 @@ describe('TrainingCardsService', () => {
startkey: 'training:a_user:',
endkey: 'training:a_user:\ufff0',
});
- expect(globalActions.setTrainingCard.calledOnce);
+ expect(globalActions.setTrainingCard.calledOnce).to.be.true;
expect(globalActions.setTrainingCard.args[0]).to.deep.equal([ { formId: 'training:form-b' } ]);
- expect(consoleErrorMock.notCalled).to.be.true;
- expect(feedbackService.submit.notCalled).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
});
- it('should set uncompleted training form when there are some completed', async () => {
+ it('should show uncompleted training when there are some completed', async () => {
sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'a_user' });
localDb.allDocs.resolves({ rows: [
{ doc: { form: 'training:form-a' } },
@@ -172,16 +165,10 @@ describe('TrainingCardsService', () => {
},
},
];
- service.initTrainingCards();
-
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
- await callback(null, xforms);
+ await service.displayTrainingCards(xforms, true, true);
- expect(sessionService.userCtx.calledOnce).to.be.true;
+ expect(sessionService.userCtx.calledTwice).to.be.true;
expect(sessionService.hasRole.callCount).to.equal(4);
expect(localDb.allDocs.calledOnce).to.be.true;
expect(localDb.allDocs.args[0][0]).to.deep.equal({
@@ -189,11 +176,10 @@ describe('TrainingCardsService', () => {
startkey: 'training:a_user:',
endkey: 'training:a_user:\ufff0',
});
- expect(globalActions.setTrainingCard.calledOnce);
+ expect(globalActions.setTrainingCard.calledOnce).to.be.true;
expect(globalActions.setTrainingCard.args[0]).to.deep.equal([ { formId: 'training:form-d' } ]);
- expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.notCalled).to.be.true;
- expect(feedbackService.submit.notCalled).to.be.true;
+ expect(modalService.show.calledOnce).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
});
it('should show uncompleted training form when they dont have duration set', async () => {
@@ -229,16 +215,10 @@ describe('TrainingCardsService', () => {
},
},
];
- service.initTrainingCards();
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
-
- await callback(null, xforms);
+ await service.displayTrainingCards(xforms, true, true);
- expect(sessionService.userCtx.calledOnce).to.be.true;
+ expect(sessionService.userCtx.calledTwice).to.be.true;
expect(sessionService.hasRole.calledThrice).to.be.true;
expect(localDb.allDocs.calledOnce).to.be.true;
expect(localDb.allDocs.args[0][0]).to.deep.equal({
@@ -246,11 +226,10 @@ describe('TrainingCardsService', () => {
startkey: 'training:a_user:',
endkey: 'training:a_user:\ufff0',
});
- expect(globalActions.setTrainingCard.calledOnce);
+ expect(globalActions.setTrainingCard.calledOnce).to.be.true;
expect(globalActions.setTrainingCard.args[0]).to.deep.equal([ { formId: 'training:form-c' } ]);
- expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.notCalled).to.be.true;
- expect(feedbackService.submit.notCalled).to.be.true;
+ expect(modalService.show.calledOnce).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
});
it('should show uncompleted training form when they dont have start_date set', async () => {
@@ -294,16 +273,10 @@ describe('TrainingCardsService', () => {
},
},
];
- service.initTrainingCards();
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
-
- await callback(null, xforms);
+ await service.displayTrainingCards(xforms, true, true);
- expect(sessionService.userCtx.calledOnce).to.be.true;
+ expect(sessionService.userCtx.calledTwice).to.be.true;
expect(sessionService.hasRole.callCount).to.equal(4);
expect(localDb.allDocs.calledOnce).to.be.true;
expect(localDb.allDocs.args[0][0]).to.deep.equal({
@@ -311,11 +284,30 @@ describe('TrainingCardsService', () => {
startkey: 'training:a_user:',
endkey: 'training:a_user:\ufff0',
});
- expect(globalActions.setTrainingCard.calledOnce);
+ expect(globalActions.setTrainingCard.calledOnce).to.be.true;
expect(globalActions.setTrainingCard.args[0]).to.deep.equal([ { formId: 'training:form-c' } ]);
+ expect(modalService.show.calledOnce).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
+ });
+
+ it('should not show training when privacy policy has not been accepted yet', async () => {
+ sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'a_user' });
+ localDb.allDocs.resolves({ rows: []});
+ clock = sinon.useFakeTimers(new Date('2022-05-23 20:29:25'));
+ const xforms = [{
+ _id: 'form:training:abc-100',
+ internalId: 'training:form-c',
+ context: { duration: 9, user_roles: [ 'chw' ] },
+ }];
+
+ await service.displayTrainingCards(xforms, true, false);
+
+ expect(sessionService.userCtx.notCalled).to.be.true;
+ expect(sessionService.hasRole.notCalled).to.be.true;
+ expect(localDb.allDocs.notCalled).to.be.true;
+ expect(globalActions.setTrainingCard.notCalled).to.be.true;
expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.notCalled).to.be.true;
- expect(feedbackService.submit.notCalled).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
});
it('should not show training form when all trainings are completed', async () => {
@@ -355,16 +347,10 @@ describe('TrainingCardsService', () => {
},
},
];
- service.initTrainingCards();
-
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
- await callback(null, xforms);
+ await service.displayTrainingCards(xforms, true, true);
- expect(sessionService.userCtx.calledOnce).to.be.true;
+ expect(sessionService.userCtx.calledTwice).to.be.true;
expect(sessionService.hasRole.calledThrice).to.be.true;
expect(localDb.allDocs.calledOnce).to.be.true;
expect(localDb.allDocs.args[0][0]).to.deep.equal({
@@ -374,8 +360,7 @@ describe('TrainingCardsService', () => {
});
expect(globalActions.setTrainingCard.notCalled).to.be.true;
expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.notCalled).to.be.true;
- expect(feedbackService.submit.notCalled).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
});
it('should not show training forms when all trainings have expired', async () => {
@@ -413,21 +398,14 @@ describe('TrainingCardsService', () => {
},
},
];
- service.initTrainingCards();
-
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
- await callback(null, xforms);
+ await service.displayTrainingCards(xforms, true, true);
expect(sessionService.hasRole.calledThrice).to.be.true;
expect(localDb.allDocs.notCalled).to.be.true;
expect(globalActions.setTrainingCard.notCalled).to.be.true;
expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.notCalled).to.be.true;
- expect(feedbackService.submit.notCalled).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
});
it('should not show training forms when all trainings start in the future', async () => {
@@ -463,21 +441,14 @@ describe('TrainingCardsService', () => {
},
},
];
- service.initTrainingCards();
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
-
- await callback(null, xforms);
+ await service.displayTrainingCards(xforms, true, true);
expect(sessionService.hasRole.calledThrice).to.be.true;
expect(localDb.allDocs.notCalled).to.be.true;
expect(globalActions.setTrainingCard.notCalled).to.be.true;
expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.notCalled).to.be.true;
- expect(feedbackService.submit.notCalled).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
});
it('should not show training forms if their internalID does not have the right prefix', async () => {
@@ -513,25 +484,19 @@ describe('TrainingCardsService', () => {
},
},
];
- service.initTrainingCards();
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
-
- await callback(null, xforms);
+ await service.displayTrainingCards(xforms, true, true);
expect(localDb.allDocs.notCalled).to.be.true;
expect(globalActions.setTrainingCard.notCalled).to.be.true;
expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.calledThrice).to.be.true;
- expect(consoleErrorMock.args[0][0].message)
+ expect(consoleErrorSpy.calledThrice).to.be.true;
+ expect(consoleErrorSpy.args[0][0].message)
.to.equal('Training Cards :: Incorrect internalId format. Doc ID: form:training:cards-1');
- expect(consoleErrorMock.args[1][0].message)
+ expect(consoleErrorSpy.args[1][0].message)
.to.equal('Training Cards :: Incorrect internalId format. Doc ID: form:training:cards-2');
- expect(consoleErrorMock.args[2][0].message)
+ expect(consoleErrorSpy.args[2][0].message)
.to.equal('Training Cards :: Incorrect internalId format. Doc ID: form:training:cards-3');
});
@@ -539,21 +504,14 @@ describe('TrainingCardsService', () => {
sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'a_user' });
localDb.allDocs.resolves({ rows: [] });
clock = sinon.useFakeTimers(new Date('2022-05-23 20:29:25'));
- service.initTrainingCards();
-
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
- await callback(null, []);
+ await service.displayTrainingCards([], true, true);
expect(sessionService.hasRole.notCalled).to.be.true;
expect(localDb.allDocs.notCalled).to.be.true;
expect(globalActions.setTrainingCard.notCalled).to.be.true;
expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.notCalled).to.be.true;
- expect(feedbackService.submit.notCalled).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
});
it('should log error from xmlFormsService', async () => {
@@ -566,14 +524,10 @@ describe('TrainingCardsService', () => {
await callback(new Error('some error'), []);
- expect(localDb.allDocs.notCalled).to.be.true;
- expect(sessionService.userCtx.notCalled).to.be.true;
- expect(sessionService.hasRole.notCalled).to.be.true;
expect(globalActions.setTrainingCard.notCalled).to.be.true;
- expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.calledOnce).to.be.true;
- expect(consoleErrorMock.args[0][0]).to.equal('Training Cards :: Error fetching forms.');
- expect(consoleErrorMock.args[0][1].message).to.equal('some error');
+ expect(consoleErrorSpy.calledOnce).to.be.true;
+ expect(consoleErrorSpy.args[0][0]).to.equal('Training Cards :: Error fetching forms.');
+ expect(consoleErrorSpy.args[0][1].message).to.equal('some error');
});
it('should catch exception', async () => {
@@ -589,34 +543,37 @@ describe('TrainingCardsService', () => {
user_roles: [ 'chw' ],
},
}];
- service.initTrainingCards();
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
-
- await callback(null, xforms);
+ await service.displayTrainingCards(xforms, true, true);
expect(sessionService.hasRole.calledOnce).to.be.true;
- expect(sessionService.userCtx.calledOnce).to.be.true;
+ expect(sessionService.userCtx.calledTwice).to.be.true;
expect(localDb.allDocs.calledOnce).to.be.true;
expect(globalActions.setTrainingCard.notCalled).to.be.true;
expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.calledOnce).to.be.true;
- expect(consoleErrorMock.args[0][0]).to.equal('Training Cards :: Error showing modal.');
- expect(consoleErrorMock.args[0][1].message).to.equal('some error');
+ expect(consoleErrorSpy.calledOnce).to.be.true;
+ expect(consoleErrorSpy.args[0][0]).to.equal('Training Cards :: Error showing modal.');
+ expect(consoleErrorSpy.args[0][1].message).to.equal('some error');
});
- it('should not display training if route has hideTraining flag', async () => {
+ it('should display training if route has hideTraining false', async () => {
+ sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'a_user' });
+ localDb.allDocs.resolves({ rows: [ { doc: { form: 'training:form-b' } } ] });
+ clock = sinon.useFakeTimers(new Date('2022-05-23 20:29:25'));
+ const xforms = [ {
+ _id: 'form:training:abc-100',
+ internalId: 'training:form-c',
+ context: { duration: 9, user_roles: [ 'chw' ] },
+ }];
+
routeSnapshotService.get.returns({ data: { hideTraining: true } });
- service.displayTrainingCards();
+ await service.displayTrainingCards(xforms, true, true);
+
expect(modalService.show.notCalled).to.be.true;
- });
- it('should display training', () => {
routeSnapshotService.get.returns({ data: { hideTraining: false } });
- service.displayTrainingCards();
+ await service.displayTrainingCards(xforms, true, true);
+
expect(modalService.show.calledOnce).to.be.true;
});
@@ -672,16 +629,10 @@ describe('TrainingCardsService', () => {
},
},
];
- service.initTrainingCards();
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
+ await service.displayTrainingCards(xforms, true, true);
- await callback(null, xforms);
-
- expect(sessionService.userCtx.calledOnce).to.be.true;
+ expect(sessionService.userCtx.calledTwice).to.be.true;
expect(sessionService.hasRole.callCount).to.equal(5);
expect(localDb.allDocs.calledOnce).to.be.true;
expect(localDb.allDocs.args[0][0]).to.deep.equal({
@@ -689,11 +640,10 @@ describe('TrainingCardsService', () => {
startkey: 'training:a_user:',
endkey: 'training:a_user:\ufff0',
});
- expect(globalActions.setTrainingCard.calledOnce);
+ expect(globalActions.setTrainingCard.calledOnce).to.be.true;
expect(globalActions.setTrainingCard.args[0]).to.deep.equal([ { formId: 'training:form-e' } ]);
- expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.notCalled).to.be.true;
- expect(feedbackService.submit.notCalled).to.be.true;
+ expect(modalService.show.calledOnce).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
});
it('should show uncompleted training when form does not have user_roles defined', async () => {
@@ -721,16 +671,10 @@ describe('TrainingCardsService', () => {
},
},
];
- service.initTrainingCards();
- expect(xmlFormsService.subscribe.calledOnce).to.be.true;
- expect(xmlFormsService.subscribe.args[0][0]).to.equal('TrainingCards');
- expect(xmlFormsService.subscribe.args[0][1]).to.deep.equal({ trainingCards: true });
- const callback = xmlFormsService.subscribe.args[0][2];
+ await service.displayTrainingCards(xforms, true, true);
- await callback(null, xforms);
-
- expect(sessionService.userCtx.calledOnce).to.be.true;
+ expect(sessionService.userCtx.calledTwice).to.be.true;
expect(sessionService.hasRole.calledOnce).to.be.true;
expect(localDb.allDocs.calledOnce).to.be.true;
expect(localDb.allDocs.args[0][0]).to.deep.equal({
@@ -738,11 +682,10 @@ describe('TrainingCardsService', () => {
startkey: 'training:a_user:',
endkey: 'training:a_user:\ufff0',
});
- expect(globalActions.setTrainingCard.calledOnce);
+ expect(globalActions.setTrainingCard.calledOnce).to.be.true;
expect(globalActions.setTrainingCard.args[0]).to.deep.equal([ { formId: 'training:form-d' } ]);
- expect(modalService.show.notCalled).to.be.true;
- expect(consoleErrorMock.notCalled).to.be.true;
- expect(feedbackService.submit.notCalled).to.be.true;
+ expect(modalService.show.calledOnce).to.be.true;
+ expect(consoleErrorSpy.notCalled).to.be.true;
});
it('should evaluate if the internalID is from a training card', () => {
@@ -777,46 +720,207 @@ describe('TrainingCardsService', () => {
it('should display training when it has not been displayed today', async () => {
routeSnapshotService.get.returns({ data: { hideTraining: false } });
- sessionService.userCtx.returns({ name: 'ronald' });
+ sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'ronald' });
window.localStorage.setItem('training-cards-last-viewed-date-ronald', '2024-05-23 20:29:25');
clock = sinon.useFakeTimers(new Date('2025-05-25 20:29:25'));
+ localDb.allDocs.resolves({ rows: [] });
+ const xforms = [ {
+ _id: 'form:training:abc-100',
+ internalId: 'training:form-c',
+ context: { duration: 9, user_roles: [ 'chw' ] },
+ }];
- service.displayTrainingCards();
+ await service.displayTrainingCards(xforms, true, true);
expect(modalService.show.calledOnce).to.be.true;
});
it('should display training when last viewed date is empty', async () => {
+ sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'ronald' });
routeSnapshotService.get.returns({ data: { hideTraining: false } });
window.localStorage.setItem('training-cards-last-viewed-date-ronald', '');
clock = sinon.useFakeTimers(new Date('2025-05-25 20:29:25'));
+ localDb.allDocs.resolves({ rows: [] });
+ const xforms = [ {
+ _id: 'form:training:abc-100',
+ internalId: 'training:form-c',
+ context: { duration: 9, user_roles: [ 'chw' ] },
+ }];
- service.displayTrainingCards();
+ await service.displayTrainingCards(xforms, true, true);
expect(modalService.show.calledOnce).to.be.true;
});
it('should not display training when it has been displayed today for the same user', async () => {
routeSnapshotService.get.returns({ data: { hideTraining: false } });
- sessionService.userCtx.returns({ name: 'ronald' });
+ sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'ronald' });
window.localStorage.setItem('training-cards-last-viewed-date-ronald', '2024-05-23 20:29:25');
clock = sinon.useFakeTimers(new Date('2024-05-23 06:29:25'));
+ localDb.allDocs.resolves({ rows: [] });
+ const xforms = [ {
+ _id: 'form:training:abc-100',
+ internalId: 'training:form-c',
+ context: { duration: 9, user_roles: [ 'chw' ] },
+ }];
- service.displayTrainingCards();
+ await service.displayTrainingCards(xforms, true, true);
expect(modalService.show.notCalled).to.be.true;
});
it('should display training when it has not been displayed for a different user', async () => {
routeSnapshotService.get.returns({ data: { hideTraining: false } });
- sessionService.userCtx.returns({ name: 'sarah' });
+ sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'sarah' });
window.localStorage.setItem('training-cards-last-viewed-date-ronald', '2024-05-23 20:29:25');
clock = sinon.useFakeTimers(new Date('2024-05-23 06:29:25'));
+ localDb.allDocs.resolves({ rows: [ { doc: { form: 'training:form-b' } } ] });
+ const xforms = [ {
+ _id: 'form:training:abc-100',
+ internalId: 'training:form-c',
+ context: { duration: 9, user_roles: [ 'chw' ] },
+ }];
- service.displayTrainingCards();
+ await service.displayTrainingCards(xforms, true, true);
expect(modalService.show.calledOnce).to.be.true;
});
});
+ describe('Get next available trainings', () => {
+ it('should return list of available trainings', async () => {
+ sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'a_user' });
+ localDb.allDocs.resolves({ rows: [
+ { doc: { form: 'training:form-a' } },
+ { doc: { form: 'training:form-b' } },
+ ]});
+ clock = sinon.useFakeTimers(new Date('2022-05-23 20:29:25'));
+ const xforms = [
+ {
+ _id: 'form:training:abc-789',
+ internalId: 'training:form-c',
+ context: { start_date: '2022-05-28', duration: 6, user_roles: [ 'chw' ] },
+ },
+ {
+ _id: 'form:training:abc-456',
+ internalId: 'training:form-a',
+ context: { start_date: '2022-05-18', duration: 2, user_roles: [ 'chw' ] },
+ },
+ {
+ _id: 'form:training:abc-123',
+ internalId: 'training:form-b',
+ context: { start_date: '2022-05-21', duration: 3, user_roles: [ 'chw' ] },
+ },
+ {
+ _id: 'form:training:abc-098',
+ internalId: 'training:form-d',
+ context: { start_date: '2022-05-21', duration: 9, user_roles: [ 'chw' ] },
+ },
+ ];
+
+ const result = await service.getNextTrainings(xforms, 50, 0);
+
+ expect(sessionService.userCtx.calledOnce).to.be.true;
+ expect(sessionService.hasRole.callCount).to.equal(4);
+ expect(localDb.allDocs.calledOnce).to.be.true;
+ expect(localDb.allDocs.args[0][0]).to.deep.equal({
+ include_docs: true,
+ startkey: 'training:a_user:',
+ endkey: 'training:a_user:\ufff0',
+ });
+ expect(result).excluding('startDate').to.have.deep.members([
+ {
+ id: 'form:training:abc-123',
+ code: 'training:form-b',
+ isCompletedTraining: true,
+ title: undefined,
+ userRoles: [ 'chw' ],
+ duration: 3,
+ },
+ {
+ id: 'form:training:abc-098',
+ code: 'training:form-d',
+ isCompletedTraining: false,
+ title: undefined,
+ userRoles: [ 'chw' ],
+ duration: 9,
+ },
+ ]);
+ });
+
+ it('should paginate the list of available trainings', async () => {
+ sessionService.userCtx.returns({ roles: [ 'chw' ], name: 'a_user' });
+ localDb.allDocs.resolves({ rows: [
+ { doc: { form: 'training:form-a' } },
+ { doc: { form: 'training:form-b' } },
+ ]});
+ clock = sinon.useFakeTimers(new Date('2022-05-23 20:29:25'));
+ const xforms = [
+ ...Array.from({ length: 30 }).map((item, index) => ({
+ _id: 'form:training:abc-123' + index,
+ internalId: 'training:form-b',
+ context: { start_date: '2022-05-21', duration: 3, user_roles: [ 'chw' ] },
+ })),
+ ...Array.from({ length: 30 }).map((item, index) => ({
+ _id: 'form:training:abc-789' + index,
+ internalId: 'training:form-c',
+ context: { start_date: '2022-05-28', duration: 6, user_roles: [ 'chw' ] },
+ })),
+ ...Array.from({ length: 30 }).map((item, index) => ({
+ _id: 'form:training:abc-098' + index,
+ title: 'A Title',
+ internalId: 'training:form-d',
+ context: { start_date: '2022-05-21', duration: 9, user_roles: [ 'chw' ] },
+ })),
+ ];
+
+ const expectedPage1 = [
+ ...Array.from({ length: 30 }).map((item, index) => ({
+ id: 'form:training:abc-123' + index,
+ code: 'training:form-b',
+ duration: 3,
+ title: undefined,
+ isCompletedTraining: true,
+ userRoles: [ 'chw' ],
+ })),
+ ...Array.from({ length: 20 }).map((item, index) => ({
+ id: 'form:training:abc-098' + index,
+ title: 'A Title',
+ code: 'training:form-d',
+ isCompletedTraining: false,
+ duration: 9,
+ userRoles: [ 'chw' ],
+ })),
+ ];
+
+ const expectedPage2 = [
+ ...Array.from({ length: 10 }).map((item, index) => ({
+ id: 'form:training:abc-098' + (20 + index),
+ title: 'A Title',
+ code: 'training:form-d',
+ isCompletedTraining: false,
+ duration: 9,
+ userRoles: [ 'chw' ],
+ })),
+ ];
+
+ const resultPage1 = await service.getNextTrainings(xforms, 50, 0);
+
+ expect(sessionService.userCtx.calledOnce).to.be.true;
+ expect(sessionService.hasRole.callCount).to.equal(90);
+ expect(localDb.allDocs.calledOnce).to.be.true;
+ expect(localDb.allDocs.args[0][0]).to.deep.equal({
+ include_docs: true,
+ startkey: 'training:a_user:',
+ endkey: 'training:a_user:\ufff0',
+ });
+ expect(resultPage1?.length).to.equal(50);
+ expect(resultPage1).excluding('startDate').to.have.deep.members(expectedPage1);
+
+ const resultPage2 = await service.getNextTrainings(xforms, 50, 50);
+
+ expect(resultPage2?.length).to.equal(10);
+ expect(resultPage2).excluding('startDate').to.have.deep.members(expectedPage2);
+ });
+ });
});