@hmcts/ccd-case-ui-toolkit 5.0.7-angular11-upgrade → 5.0.10-angular11-upgrade

package/esm2015/lib/shared/components/case-editor/services/page-validation.service.js

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { ShowCondition } from '../../../directives/conditional-show/domain/conditional-show.model';
+import { CaseFieldService } from '../../../services/case-fields/case-field.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/case-fields/case-field.service";
+export class PageValidationService {
+    constructor(caseFieldService) {
+        this.caseFieldService = caseFieldService;
+    }
+    isPageValid(page, editForm) {
+        return page.case_fields
+            .filter(caseField => !this.caseFieldService.isReadOnly(caseField))
+            .filter(caseField => !this.isHidden(caseField, editForm))
+            .every(caseField => {
+            const theControl = editForm.controls['data'].get(caseField.id);
+            return this.checkDocumentField(caseField, theControl) && this.checkOptionalField(caseField, theControl);
+        });
+    }
+    isHidden(caseField, editForm, path) {
+        const formFields = editForm.getRawValue();
+        const condition = ShowCondition.getInstance(caseField.show_condition);
+        if (path && path.indexOf('_' + caseField.id + '_') === -1) {
+            path = `${path}${caseField.id}`;
+        }
+        return !condition.match(formFields.data, path);
+    }
+    checkDocumentField(caseField, theControl) {
+        if (caseField.field_type.id !== 'Document') {
+            return true;
+        }
+        return !(this.checkMandatoryField(caseField, theControl));
+    }
+    checkOptionalField(caseField, theControl) {
+        if (!theControl) {
+            return this.caseFieldService.isOptional(caseField);
+        }
+        else {
+            return theControl.valid || theControl.disabled;
+        }
+    }
+    checkMandatoryField(caseField, theControl) {
+        return this.caseFieldService.isMandatory(caseField) && theControl === null;
+    }
+}
+PageValidationService.ɵfac = function PageValidationService_Factory(t) { return new (t || PageValidationService)(i0.ɵɵinject(i1.CaseFieldService)); };
+PageValidationService.ɵprov = i0.ɵɵdefineInjectable({ token: PageValidationService, factory: PageValidationService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PageValidationService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.CaseFieldService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared/components/case-editor/services/wizard-factory.service.js

@@ -0,0 +1,7 @@
+import { Wizard } from '../domain/wizard.model';
+export class WizardFactoryService {
+    create(eventTrigger) {
+        return new Wizard(eventTrigger.wizard_pages);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l6YXJkLWZhY3Rvcnkuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NjZC1jYXNlLXVpLXRvb2xraXQvc3JjL2xpYi9zaGFyZWQvY29tcG9uZW50cy9jYXNlLWVkaXRvci9zZXJ2aWNlcy93aXphcmQtZmFjdG9yeS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUVoRCxNQUFNLE9BQU8sb0JBQW9CO0lBQ3hCLE1BQU0sQ0FBQyxZQUE4QjtRQUMxQyxPQUFPLElBQUksTUFBTSxDQUFDLFlBQVksQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUMvQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDYXNlRXZlbnRUcmlnZ2VyIH0gZnJvbSAnLi4vLi4vLi4vZG9tYWluL2Nhc2Utdmlldy9jYXNlLWV2ZW50LXRyaWdnZXIubW9kZWwnO1xuaW1wb3J0IHsgV2l6YXJkIH0gZnJvbSAnLi4vZG9tYWluL3dpemFyZC5tb2RlbCc7XG5cbmV4cG9ydCBjbGFzcyBXaXphcmRGYWN0b3J5U2VydmljZSB7XG4gIHB1YmxpYyBjcmVhdGUoZXZlbnRUcmlnZ2VyOiBDYXNlRXZlbnRUcmlnZ2VyKTogV2l6YXJkIHtcbiAgICByZXR1cm4gbmV3IFdpemFyZChldmVudFRyaWdnZXIud2l6YXJkX3BhZ2VzKTtcbiAgfVxufVxuIl19

package/esm2015/lib/shared/components/case-history/case-history.component.js

@@ -0,0 +1,264 @@
+import { Component, Input } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { ShowCondition } from '../../directives/conditional-show/domain/conditional-show.model';
+import { HttpError } from '../../domain/http/http-error.model';
+import { AlertService } from '../../services/alert/alert.service';
+import { OrderService } from '../../services/order/order.service';
+import { CaseNotifier } from '../case-editor/services/case.notifier';
+import { CaseHistoryService } from './services/case-history.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../services/alert/alert.service";
+import * as i3 from "../../services/order/order.service";
+import * as i4 from "../case-editor/services/case.notifier";
+import * as i5 from "./services/case-history.service";
+import * as i6 from "@angular/common";
+import * as i7 from "../case-header/case-header.component";
+import * as i8 from "../../directives/substitutor/label-substitutor.directive";
+import * as i9 from "../palette/base-field/field-read.component";
+import * as i10 from "../palette/utils/date.pipe";
+import * as i11 from "../palette/utils/dash.pipe";
+import * as i12 from "../../pipes/complex/ccd-read-fields-filter.pipe";
+import * as i13 from "../../pipes/complex/ccd-tab-fields.pipe";
+import * as i14 from "../palette/utils/is-compound.pipe";
+function CaseHistoryComponent_div_0_ng_container_49_ng_container_5_tr_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "tr");
+    i0.ɵɵelementStart(1, "th", 14);
+    i0.ɵɵelementStart(2, "div", 15);
+    i0.ɵɵtext(3);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(4, "td");
+    i0.ɵɵelement(5, "ccd-field-read", 16);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const field_r4 = i0.ɵɵnextContext().$implicit;
+    const ctx_r5 = i0.ɵɵnextContext(3);
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(field_r4.label);
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("caseField", field_r4)("caseReference", ctx_r5.caseHistory.case_id);
+} }
+function CaseHistoryComponent_div_0_ng_container_49_ng_container_5_tr_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "tr", 17);
+    i0.ɵɵelementStart(1, "td", 18);
+    i0.ɵɵelement(2, "ccd-field-read", 16);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const field_r4 = i0.ɵɵnextContext().$implicit;
+    const ctx_r6 = i0.ɵɵnextContext(3);
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("caseField", field_r4)("caseReference", ctx_r6.caseHistory.case_id);
+} }
+function CaseHistoryComponent_div_0_ng_container_49_ng_container_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "div", 10);
+    i0.ɵɵelementContainerStart(2, 11);
+    i0.ɵɵpipe(3, "ccdIsCompound");
+    i0.ɵɵtemplate(4, CaseHistoryComponent_div_0_ng_container_49_ng_container_5_tr_4_Template, 6, 3, "tr", 12);
+    i0.ɵɵtemplate(5, CaseHistoryComponent_div_0_ng_container_49_ng_container_5_tr_5_Template, 3, 2, "tr", 13);
+    i0.ɵɵelementContainerEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const field_r4 = ctx.$implicit;
+    const tab_r2 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("caseField", field_r4)("contextFields", tab_r2.fields)("hidden", field_r4.hidden);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngSwitch", !i0.ɵɵpipeBind1(3, 6, field_r4));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngSwitchCase", true);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngSwitchCase", false);
+} }
+function CaseHistoryComponent_div_0_ng_container_49_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "div", 7);
+    i0.ɵɵelementStart(2, "h3", 8);
+    i0.ɵɵtext(3);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(4, "table", 9);
+    i0.ɵɵtemplate(5, CaseHistoryComponent_div_0_ng_container_49_ng_container_5_Template, 6, 8, "ng-container", 6);
+    i0.ɵɵpipe(6, "ccdReadFieldsFilter");
+    i0.ɵɵpipe(7, "ccdTabFields");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const tab_r2 = ctx.$implicit;
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(tab_r2.label);
+    i0.ɵɵadvance(1);
+    i0.ɵɵpropertyInterpolate("id", tab_r2.id);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", i0.ɵɵpipeBind4(6, 3, i0.ɵɵpipeBind1(7, 8, tab_r2), false, undefined, true));
+} }
+function CaseHistoryComponent_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div");
+    i0.ɵɵelementStart(1, "div", 1);
+    i0.ɵɵelementStart(2, "div", 2);
+    i0.ɵɵelement(3, "ccd-case-header", 3);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(4, "div", 1);
+    i0.ɵɵelementStart(5, "div", 2);
+    i0.ɵɵelementStart(6, "div");
+    i0.ɵɵelementStart(7, "h2", 4);
+    i0.ɵɵtext(8, "Event Details");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(9, "table", 5);
+    i0.ɵɵelementStart(10, "tbody");
+    i0.ɵɵelementStart(11, "tr");
+    i0.ɵɵelementStart(12, "th");
+    i0.ɵɵtext(13, "Date");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(14, "td");
+    i0.ɵɵtext(15);
+    i0.ɵɵpipe(16, "ccdDate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(17, "tr");
+    i0.ɵɵelementStart(18, "th");
+    i0.ɵɵtext(19, "Author");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(20, "td");
+    i0.ɵɵtext(21);
+    i0.ɵɵpipe(22, "titlecase");
+    i0.ɵɵpipe(23, "uppercase");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(24, "tr");
+    i0.ɵɵelementStart(25, "th");
+    i0.ɵɵtext(26, "End state");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(27, "td");
+    i0.ɵɵtext(28);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(29, "tr");
+    i0.ɵɵelementStart(30, "th");
+    i0.ɵɵtext(31, "Event");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(32, "td");
+    i0.ɵɵtext(33);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(34, "tr");
+    i0.ɵɵelementStart(35, "th");
+    i0.ɵɵtext(36, "Summary");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(37, "td");
+    i0.ɵɵtext(38);
+    i0.ɵɵpipe(39, "ccdDash");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(40, "tr");
+    i0.ɵɵelementStart(41, "th");
+    i0.ɵɵtext(42, "Comment");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(43, "td");
+    i0.ɵɵtext(44);
+    i0.ɵɵpipe(45, "ccdDash");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(46, "div");
+    i0.ɵɵelementStart(47, "h2", 4);
+    i0.ɵɵtext(48, "Case Details");
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(49, CaseHistoryComponent_div_0_ng_container_49_Template, 8, 10, "ng-container", 6);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("caseDetails", ctx_r0.caseDetails);
+    i0.ɵɵadvance(12);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(16, 9, ctx_r0.caseHistory.event.timestamp));
+    i0.ɵɵadvance(6);
+    i0.ɵɵtextInterpolate2("", i0.ɵɵpipeBind1(22, 11, ctx_r0.caseHistory.event.user_first_name), " ", i0.ɵɵpipeBind1(23, 13, ctx_r0.caseHistory.event.user_last_name), "");
+    i0.ɵɵadvance(7);
+    i0.ɵɵtextInterpolate(ctx_r0.caseHistory.event.state_name);
+    i0.ɵɵadvance(5);
+    i0.ɵɵtextInterpolate(ctx_r0.caseHistory.event.event_name);
+    i0.ɵɵadvance(5);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(39, 15, ctx_r0.caseHistory.event.summary));
+    i0.ɵɵadvance(6);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(45, 17, ctx_r0.caseHistory.event.comment));
+    i0.ɵɵadvance(5);
+    i0.ɵɵproperty("ngForOf", ctx_r0.tabs);
+} }
+export class CaseHistoryComponent {
+    constructor(route, alertService, orderService, caseNotifier, caseHistoryService) {
+        this.route = route;
+        this.alertService = alertService;
+        this.orderService = orderService;
+        this.caseNotifier = caseNotifier;
+        this.caseHistoryService = caseHistoryService;
+    }
+    ngOnInit() {
+        this.caseSubscription = this.caseNotifier.caseView.subscribe(caseDetails => {
+            this.caseDetails = caseDetails;
+            const eventId = this.route.snapshot.paramMap.get(CaseHistoryComponent.PARAM_EVENT_ID) || this.event;
+            this.caseHistoryService
+                .get(this.caseDetails.case_id, eventId)
+                .pipe(map(caseHistory => {
+                if (!caseHistory) {
+                    const error = new HttpError();
+                    error.message = CaseHistoryComponent.ERROR_MESSAGE;
+                    throw error;
+                }
+                this.caseHistory = caseHistory;
+                this.tabs = this.orderService.sort(this.caseHistory.tabs);
+                this.tabs = this.sortTabFieldsAndFilterTabs(this.tabs);
+            }), catchError(error => {
+                console.error(error);
+                if (error.status !== 401 && error.status !== 403) {
+                    this.alertService.error(error.message);
+                }
+                return throwError(error);
+            })).toPromise();
+        });
+    }
+    ngOnDestroy() {
+        if (this.caseSubscription) {
+            this.caseSubscription.unsubscribe();
+        }
+    }
+    isDataLoaded() {
+        return !!(this.caseDetails && this.caseHistory);
+    }
+    sortTabFieldsAndFilterTabs(tabs) {
+        return tabs
+            .map(tab => Object.assign({}, tab, { fields: this.orderService.sort(tab.fields) }))
+            .filter(tab => ShowCondition.getInstance(tab.show_condition).matchByContextFields(tab.fields));
+    }
+}
+CaseHistoryComponent.PARAM_EVENT_ID = 'eid';
+CaseHistoryComponent.ERROR_MESSAGE = 'No case history to show';
+CaseHistoryComponent.ɵfac = function CaseHistoryComponent_Factory(t) { return new (t || CaseHistoryComponent)(i0.ɵɵdirectiveInject(i1.ActivatedRoute), i0.ɵɵdirectiveInject(i2.AlertService), i0.ɵɵdirectiveInject(i3.OrderService), i0.ɵɵdirectiveInject(i4.CaseNotifier), i0.ɵɵdirectiveInject(i5.CaseHistoryService)); };
+CaseHistoryComponent.ɵcmp = i0.ɵɵdefineComponent({ type: CaseHistoryComponent, selectors: [["ccd-case-history"]], inputs: { event: "event" }, decls: 1, vars: 1, consts: [[4, "ngIf"], [1, "grid-row"], [1, "column-full"], [3, "caseDetails"], [1, "heading-h2"], ["aria-describedby", "event details table", 1, "EventDetails"], [4, "ngFor", "ngForOf"], [1, "caseHistorySection"], [1, "heading-h3"], ["aria-describedby", "case history table", 1, "CaseHistory", 3, "id"], ["ccdLabelSubstitutor", "", 3, "caseField", "contextFields", "hidden"], [3, "ngSwitch"], [4, "ngSwitchCase"], ["class", "compound-field", 4, "ngSwitchCase"], ["id", "case-viewer-label-header"], [1, "case-viewer-label"], [3, "caseField", "caseReference"], [1, "compound-field"], ["colspan", "2"]], template: function CaseHistoryComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, CaseHistoryComponent_div_0_Template, 50, 19, "div", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.isDataLoaded());
+    } }, directives: [i6.NgIf, i7.CaseHeaderComponent, i6.NgForOf, i8.LabelSubstitutorDirective, i6.NgSwitch, i6.NgSwitchCase, i9.FieldReadComponent], pipes: [i10.DatePipe, i6.TitleCasePipe, i6.UpperCasePipe, i11.DashPipe, i12.ReadFieldsFilterPipe, i13.CcdTabFieldsPipe, i14.IsCompoundPipe], styles: [".CaseHistory[_ngcontent-%COMP%]   td[_ngcontent-%COMP%], .CaseHistory[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{border-bottom:none}.caseHistorySection[_ngcontent-%COMP%]{margin-top:40px}.EventDetails[_ngcontent-%COMP%]   td[_ngcontent-%COMP%], .EventDetails[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{border-bottom:none}th[_ngcontent-%COMP%]{width:1%;white-space:nowrap;vertical-align:top}.compound-field[_ngcontent-%COMP%]   td[_ngcontent-%COMP%]{padding:0}.case-viewer-controls[_ngcontent-%COMP%]{margin-top:47px;margin-bottom:20px}ccd-case-header[_ngcontent-%COMP%]{float:left;margin-right:10px}ccd-event-trigger[_ngcontent-%COMP%]{float:right}.case-viewer-label[_ngcontent-%COMP%]{min-width:300px;white-space:normal}"] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseHistoryComponent, [{
+        type: Component,
+        args: [{
+                selector: 'ccd-case-history',
+                templateUrl: './case-history.component.html',
+                styleUrls: ['./case-history.component.scss']
+            }]
+    }], function () { return [{ type: i1.ActivatedRoute }, { type: i2.AlertService }, { type: i3.OrderService }, { type: i4.CaseNotifier }, { type: i5.CaseHistoryService }]; }, { event: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-history.component.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/case-history/case-history.component.ts","../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/case-history/case-history.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnDestroy, OnInit } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\nimport { Subscription, throwError } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport { ShowCondition } from '../../directives/conditional-show/domain/conditional-show.model';\nimport { CaseTab } from '../../domain/case-view/case-tab.model';\nimport { CaseView } from '../../domain/case-view/case-view.model';\nimport { HttpError } from '../../domain/http/http-error.model';\nimport { AlertService } from '../../services/alert/alert.service';\nimport { OrderService } from '../../services/order/order.service';\nimport { CaseNotifier } from '../case-editor/services/case.notifier';\nimport { CaseHistory } from './domain/case-history.model';\nimport { CaseHistoryService } from './services/case-history.service';\n\n@Component({\n  selector: 'ccd-case-history',\n  templateUrl: './case-history.component.html',\n  styleUrls: ['./case-history.component.scss']\n})\nexport class CaseHistoryComponent implements OnInit, OnDestroy {\n  public static readonly PARAM_EVENT_ID = 'eid';\n\n  private static readonly ERROR_MESSAGE = 'No case history to show';\n\n  @Input()\n  public event: string;\n\n  public caseHistory: CaseHistory;\n  public caseDetails: CaseView;\n  public tabs: CaseTab[];\n  public caseSubscription: Subscription;\n\n  constructor(\n    private readonly route: ActivatedRoute,\n    private readonly alertService: AlertService,\n    private readonly orderService: OrderService,\n    private readonly caseNotifier: CaseNotifier,\n    private readonly caseHistoryService: CaseHistoryService) { }\n\n  public ngOnInit() {\n    this.caseSubscription = this.caseNotifier.caseView.subscribe(caseDetails => {\n      this.caseDetails = caseDetails;\n      const eventId = this.route.snapshot.paramMap.get(CaseHistoryComponent.PARAM_EVENT_ID) || this.event;\n      this.caseHistoryService\n        .get(this.caseDetails.case_id, eventId)\n        .pipe(\n          map(caseHistory => {\n            if (!caseHistory) {\n              const error = new HttpError();\n              error.message = CaseHistoryComponent.ERROR_MESSAGE;\n              throw error;\n            }\n\n            this.caseHistory = caseHistory;\n            this.tabs = this.orderService.sort(this.caseHistory.tabs);\n            this.tabs = this.sortTabFieldsAndFilterTabs(this.tabs);\n          }),\n          catchError(error => {\n            console.error(error);\n            if (error.status !== 401 && error.status !== 403) {\n              this.alertService.error(error.message);\n            }\n            return throwError(error);\n            })\n        ).toPromise();\n    });\n  }\n\n  public ngOnDestroy(): void {\n    if (this.caseSubscription) {\n      this.caseSubscription.unsubscribe();\n    }\n  }\n\n  public isDataLoaded() {\n    return !!(this.caseDetails && this.caseHistory);\n  }\n\n  private sortTabFieldsAndFilterTabs(tabs: CaseTab[]): CaseTab[] {\n    return tabs\n      .map(tab => Object.assign({}, tab, { fields: this.orderService.sort(tab.fields) }))\n      .filter(tab => ShowCondition.getInstance(tab.show_condition).matchByContextFields(tab.fields));\n  }\n}\n","<div *ngIf=\"isDataLoaded()\">\n  <div class=\"grid-row\">\n    <div class=\"column-full\">\n      <ccd-case-header [caseDetails]=\"caseDetails\"></ccd-case-header>\n    </div>\n  </div>\n  <div class=\"grid-row\">\n    <div class=\"column-full\">\n      <div>\n        <h2 class=\"heading-h2\">Event Details</h2>\n        <table class=\"EventDetails\" aria-describedby=\"event details table\">\n          <tbody>\n          <tr>\n            <th>Date</th>\n            <td>{{caseHistory.event.timestamp | ccdDate}}</td>\n          </tr>\n          <tr>\n            <th>Author</th>\n            <td>{{caseHistory.event.user_first_name | titlecase}} {{caseHistory.event.user_last_name | uppercase}}</td>\n          </tr>\n          <tr>\n            <th>End state</th>\n            <td>{{caseHistory.event.state_name}}</td>\n          </tr>\n          <tr>\n            <th>Event</th>\n            <td>{{caseHistory.event.event_name}}</td>\n          </tr>\n          <tr>\n            <th>Summary</th>\n            <td>{{caseHistory.event.summary | ccdDash}}</td>\n          </tr>\n          <tr>\n            <th>Comment</th>\n            <td>{{caseHistory.event.comment | ccdDash}}</td>\n          </tr>\n          </tbody>\n        </table>\n      </div>\n      <div>\n        <h2 class=\"heading-h2\">Case Details</h2>\n        <ng-container *ngFor=\"let tab of tabs\">\n          <div class=\"caseHistorySection\">\n            <h3 class=\"heading-h3\">{{tab.label}}</h3>\n            <table class=\"CaseHistory\" id=\"{{tab.id}}\" aria-describedby=\"case history table\">\n              <ng-container *ngFor=\"let field of tab | ccdTabFields | ccdReadFieldsFilter:false :undefined :true\">\n                <div ccdLabelSubstitutor [caseField]=\"field\" [contextFields]=\"tab.fields\" [hidden]=\"field.hidden\">\n                  <ng-container [ngSwitch]=\"!(field | ccdIsCompound)\">\n                    <tr *ngSwitchCase=\"true\">\n                      <th id=\"case-viewer-label-header\">\n                        <div class=\"case-viewer-label\">{{field.label}}</div>\n                      </th>\n                      <td>\n                        <ccd-field-read [caseField]=\"field\" [caseReference]=\"caseHistory.case_id\"></ccd-field-read>\n                      </td>\n                    </tr>\n                    <tr *ngSwitchCase=\"false\" class=\"compound-field\">\n                      <td colspan=\"2\">\n                        <ccd-field-read [caseField]=\"field\" [caseReference]=\"caseHistory.case_id\"></ccd-field-read>\n                      </td>\n                    </tr>\n                  </ng-container>\n                </div>\n              </ng-container>\n            </table>\n          </div>\n        </ng-container>\n      </div>\n    </div>\n  </div>\n</div>\n"]}

package/esm2015/lib/shared/components/case-history/case-history.module.js

@@ -0,0 +1,52 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { ConditionalShowModule, LabelSubstitutorModule } from '../../directives';
+import { CaseHeaderModule } from '../case-header/case-header.module';
+import { PaletteModule } from '../palette';
+import { CaseHistoryComponent } from './case-history.component';
+import { CaseHistoryService } from './services/case-history.service';
+import * as i0 from "@angular/core";
+export class CaseHistoryModule {
+}
+CaseHistoryModule.ɵfac = function CaseHistoryModule_Factory(t) { return new (t || CaseHistoryModule)(); };
+CaseHistoryModule.ɵmod = i0.ɵɵdefineNgModule({ type: CaseHistoryModule });
+CaseHistoryModule.ɵinj = i0.ɵɵdefineInjector({ providers: [
+        CaseHistoryService,
+    ], imports: [[
+            CommonModule,
+            RouterModule,
+            CaseHeaderModule,
+            ConditionalShowModule,
+            PaletteModule,
+            LabelSubstitutorModule
+        ]] });
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CaseHistoryModule, { declarations: [CaseHistoryComponent], imports: [CommonModule,
+        RouterModule,
+        CaseHeaderModule,
+        ConditionalShowModule,
+        PaletteModule,
+        LabelSubstitutorModule], exports: [CaseHistoryComponent] }); })();
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseHistoryModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    RouterModule,
+                    CaseHeaderModule,
+                    ConditionalShowModule,
+                    PaletteModule,
+                    LabelSubstitutorModule
+                ],
+                declarations: [
+                    CaseHistoryComponent
+                ],
+                providers: [
+                    CaseHistoryService,
+                ],
+                exports: [
+                    CaseHistoryComponent,
+                ]
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared/components/case-history/domain/case-history.model.js

@@ -0,0 +1,28 @@
+import { __decorate, __metadata } from "tslib";
+import { Type } from 'class-transformer';
+import { CaseTab } from '../../../domain/case-view/case-tab.model';
+import { CaseViewEvent } from '../../../domain/case-view/case-view-event.model';
+import { Jurisdiction } from '../../../domain/definition/jurisdiction.model';
+// @dynamic
+export class CaseHistoryCaseType {
+}
+__decorate([
+    Type(() => Jurisdiction),
+    __metadata("design:type", Jurisdiction)
+], CaseHistoryCaseType.prototype, "jurisdiction", void 0);
+// @dynamic
+export class CaseHistory {
+}
+__decorate([
+    Type(() => CaseHistoryCaseType),
+    __metadata("design:type", CaseHistoryCaseType)
+], CaseHistory.prototype, "caseType", void 0);
+__decorate([
+    Type(() => CaseTab),
+    __metadata("design:type", Array)
+], CaseHistory.prototype, "tabs", void 0);
+__decorate([
+    Type(() => CaseViewEvent),
+    __metadata("design:type", CaseViewEvent)
+], CaseHistory.prototype, "event", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FzZS1oaXN0b3J5Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9jb21wb25lbnRzL2Nhc2UtaGlzdG9yeS9kb21haW4vY2FzZS1oaXN0b3J5Lm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDekMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQ25FLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxpREFBaUQsQ0FBQztBQUNoRixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sK0NBQStDLENBQUM7QUFFN0UsV0FBVztBQUNYLE1BQU0sT0FBTyxtQkFBbUI7Q0FPL0I7QUFEQztJQURDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxZQUFZLENBQUM7OEJBQ0osWUFBWTt5REFBQztBQUdwQyxXQUFXO0FBQ1gsTUFBTSxPQUFPLFdBQVc7Q0FXdkI7QUFQQztJQURDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQzs4QkFDZixtQkFBbUI7NkNBQUM7QUFHckM7SUFEQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsT0FBTyxDQUFDOzt5Q0FDRztBQUd2QjtJQURDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxhQUFhLENBQUM7OEJBQ1osYUFBYTswQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFR5cGUgfSBmcm9tICdjbGFzcy10cmFuc2Zvcm1lcic7XG5pbXBvcnQgeyBDYXNlVGFiIH0gZnJvbSAnLi4vLi4vLi4vZG9tYWluL2Nhc2Utdmlldy9jYXNlLXRhYi5tb2RlbCc7XG5pbXBvcnQgeyBDYXNlVmlld0V2ZW50IH0gZnJvbSAnLi4vLi4vLi4vZG9tYWluL2Nhc2Utdmlldy9jYXNlLXZpZXctZXZlbnQubW9kZWwnO1xuaW1wb3J0IHsgSnVyaXNkaWN0aW9uIH0gZnJvbSAnLi4vLi4vLi4vZG9tYWluL2RlZmluaXRpb24vanVyaXNkaWN0aW9uLm1vZGVsJztcblxuLy8gQGR5bmFtaWNcbmV4cG9ydCBjbGFzcyBDYXNlSGlzdG9yeUNhc2VUeXBlIHtcbiAgcHVibGljIGlkOiBzdHJpbmc7XG4gIHB1YmxpYyBuYW1lOiBzdHJpbmc7XG4gIHB1YmxpYyBkZXNjcmlwdGlvbj86IHN0cmluZztcblxuICBAVHlwZSgoKSA9PiBKdXJpc2RpY3Rpb24pXG4gIHB1YmxpYyBqdXJpc2RpY3Rpb246IEp1cmlzZGljdGlvbjtcbn1cblxuLy8gQGR5bmFtaWNcbmV4cG9ydCBjbGFzcyBDYXNlSGlzdG9yeSB7XG4gIHB1YmxpYyBjYXNlX2lkPzogc3RyaW5nO1xuXG4gIEBUeXBlKCgpID0+IENhc2VIaXN0b3J5Q2FzZVR5cGUpXG4gIHB1YmxpYyBjYXNlVHlwZTogQ2FzZUhpc3RvcnlDYXNlVHlwZTtcblxuICBAVHlwZSgoKSA9PiBDYXNlVGFiKVxuICBwdWJsaWMgdGFiczogQ2FzZVRhYltdO1xuXG4gIEBUeXBlKCgpID0+IENhc2VWaWV3RXZlbnQpXG4gIHB1YmxpYyBldmVudDogQ2FzZVZpZXdFdmVudDtcbn1cbiJdfQ==

package/esm2015/lib/shared/components/case-history/index.js

@@ -0,0 +1,3 @@
+export * from './case-history.component';
+export * from './case-history.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2NvbXBvbmVudHMvY2FzZS1oaXN0b3J5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2FzZS1oaXN0b3J5LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Nhc2UtaGlzdG9yeS5tb2R1bGUnO1xuIl19

package/esm2015/lib/shared/components/case-history/services/case-history.service.js

@@ -0,0 +1,40 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { plainToClass } from 'class-transformer';
+import { throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../../app.config';
+import { HttpErrorService } from '../../../services/http/http-error.service';
+import { HttpService } from '../../../services/http/http.service';
+import { CaseHistory } from '../domain/case-history.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/http/http.service";
+import * as i2 from "../../../services/http/http-error.service";
+import * as i3 from "../../../../app.config";
+export class CaseHistoryService {
+    constructor(httpService, httpErrorService, appConfig) {
+        this.httpService = httpService;
+        this.httpErrorService = httpErrorService;
+        this.appConfig = appConfig;
+    }
+    get(caseId, eventId) {
+        const url = this.appConfig.getCaseHistoryUrl(caseId, eventId);
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', CaseHistoryService.V2_MEDIATYPE_CASE_EVENT_VIEW)
+            .set('Content-Type', 'application/json');
+        return this.httpService
+            .get(url, { headers, observe: 'body' })
+            .pipe(map((caseHistory) => plainToClass(CaseHistory, caseHistory)), catchError((error) => {
+            this.httpErrorService.setError(error);
+            return throwError(error);
+        }));
+    }
+}
+CaseHistoryService.V2_MEDIATYPE_CASE_EVENT_VIEW = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-event-view.v2+json;charset=UTF-8';
+CaseHistoryService.ɵfac = function CaseHistoryService_Factory(t) { return new (t || CaseHistoryService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.HttpErrorService), i0.ɵɵinject(i3.AbstractAppConfig)); };
+CaseHistoryService.ɵprov = i0.ɵɵdefineInjectable({ token: CaseHistoryService, factory: CaseHistoryService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseHistoryService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.HttpErrorService }, { type: i3.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared/components/case-timeline/case-timeline.component.js

@@ -0,0 +1,118 @@
+import { Component, Input } from '@angular/core';
+import { throwError } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AlertService } from '../../services/alert/alert.service';
+import { CaseNotifier, CasesService } from '../case-editor';
+import * as i0 from "@angular/core";
+import * as i1 from "../case-editor";
+import * as i2 from "../../services/alert/alert.service";
+import * as i3 from "@angular/common";
+import * as i4 from "../palette/history/event-log/event-log.component";
+import * as i5 from "../case-history/case-history.component";
+function CaseTimelineComponent_div_0_ng_container_2_ccd_event_log_1_Template(rf, ctx) { if (rf & 1) {
+    const _r5 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "ccd-event-log", 4);
+    i0.ɵɵlistener("onCaseHistory", function CaseTimelineComponent_div_0_ng_container_2_ccd_event_log_1_Template_ccd_event_log_onCaseHistory_0_listener($event) { i0.ɵɵrestoreView(_r5); const ctx_r4 = i0.ɵɵnextContext(3); return ctx_r4.caseHistoryClicked($event); });
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r3 = i0.ɵɵnextContext(3);
+    i0.ɵɵproperty("events", ctx_r3.events);
+} }
+function CaseTimelineComponent_div_0_ng_container_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, CaseTimelineComponent_div_0_ng_container_2_ccd_event_log_1_Template, 1, 1, "ccd-event-log", 3);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r1.displayMode === ctx_r1.dspMode.TIMELINE);
+} }
+function CaseTimelineComponent_div_0_ng_container_3_Template(rf, ctx) { if (rf & 1) {
+    const _r7 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "div", 5);
+    i0.ɵɵelementStart(2, "ol", 6);
+    i0.ɵɵelementStart(3, "li", 7);
+    i0.ɵɵelementStart(4, "a", 8);
+    i0.ɵɵlistener("click", function CaseTimelineComponent_div_0_ng_container_3_Template_a_click_4_listener() { i0.ɵɵrestoreView(_r7); const ctx_r6 = i0.ɵɵnextContext(2); return ctx_r6.goToCaseTimeline(); });
+    i0.ɵɵtext(5, "Back to case timeline");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(6, "ccd-case-history", 9);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(6);
+    i0.ɵɵproperty("event", ctx_r2.selectedEventId);
+} }
+function CaseTimelineComponent_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div");
+    i0.ɵɵelementContainerStart(1, 1);
+    i0.ɵɵtemplate(2, CaseTimelineComponent_div_0_ng_container_2_Template, 2, 1, "ng-container", 2);
+    i0.ɵɵtemplate(3, CaseTimelineComponent_div_0_ng_container_3_Template, 7, 1, "ng-container", 2);
+    i0.ɵɵelementContainerEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngSwitch", ctx_r0.displayMode);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngSwitchCase", ctx_r0.dspMode.TIMELINE);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngSwitchCase", ctx_r0.dspMode.DETAILS);
+} }
+export var CaseTimelineDisplayMode;
+(function (CaseTimelineDisplayMode) {
+    CaseTimelineDisplayMode[CaseTimelineDisplayMode["TIMELINE"] = 0] = "TIMELINE";
+    CaseTimelineDisplayMode[CaseTimelineDisplayMode["DETAILS"] = 1] = "DETAILS";
+})(CaseTimelineDisplayMode || (CaseTimelineDisplayMode = {}));
+export class CaseTimelineComponent {
+    constructor(caseNotifier, casesService, alertService) {
+        this.caseNotifier = caseNotifier;
+        this.casesService = casesService;
+        this.alertService = alertService;
+        this.dspMode = CaseTimelineDisplayMode;
+        this.displayMode = CaseTimelineDisplayMode.TIMELINE;
+    }
+    ngOnInit() {
+        this.casesService
+            .getCaseViewV2(this.case)
+            .pipe(map(caseView => {
+            this.events = caseView.events;
+            this.caseNotifier.announceCase(caseView);
+        }))
+            .toPromise()
+            .catch((error) => {
+            this.alertService.error(error.message);
+            return throwError(error);
+        });
+    }
+    isDataLoaded() {
+        return this.events ? true : false;
+    }
+    caseHistoryClicked(eventId) {
+        this.displayMode = CaseTimelineDisplayMode.DETAILS;
+        this.selectedEventId = eventId;
+    }
+    goToCaseTimeline() {
+        this.displayMode = CaseTimelineDisplayMode.TIMELINE;
+    }
+}
+CaseTimelineComponent.ɵfac = function CaseTimelineComponent_Factory(t) { return new (t || CaseTimelineComponent)(i0.ɵɵdirectiveInject(i1.CaseNotifier), i0.ɵɵdirectiveInject(i1.CasesService), i0.ɵɵdirectiveInject(i2.AlertService)); };
+CaseTimelineComponent.ɵcmp = i0.ɵɵdefineComponent({ type: CaseTimelineComponent, selectors: [["ccd-case-timeline"]], inputs: { case: "case" }, decls: 1, vars: 1, consts: [[4, "ngIf"], [3, "ngSwitch"], [4, "ngSwitchCase"], [3, "events", "onCaseHistory", 4, "ngIf"], [3, "events", "onCaseHistory"], [1, "govuk-breadcrumbs"], [1, "govuk-breadcrumbs__list"], [1, "govuk-breadcrumbs__list-item"], ["href", "javascript:void(0)", 1, "govuk-back-link", 3, "click"], [3, "event"]], template: function CaseTimelineComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, CaseTimelineComponent_div_0_Template, 4, 3, "div", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.isDataLoaded());
+    } }, directives: [i3.NgIf, i3.NgSwitch, i3.NgSwitchCase, i4.EventLogComponent, i5.CaseHistoryComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseTimelineComponent, [{
+        type: Component,
+        args: [{
+                selector: 'ccd-case-timeline',
+                templateUrl: './case-timeline.component.html'
+            }]
+    }], function () { return [{ type: i1.CaseNotifier }, { type: i1.CasesService }, { type: i2.AlertService }]; }, { case: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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