@hmcts/ccd-case-ui-toolkit 7.0.39-angular-upgrade-rc → 7.0.39-case-consolidated-link

package/esm2020/lib/shared/components/case-header/case-header.module.mjs

@@ -0,0 +1,33 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { PaletteModule } from '../palette';
+import { CaseHeaderComponent } from './case-header.component';
+import * as i0 from "@angular/core";
+export class CaseHeaderModule {
+}
+CaseHeaderModule.ɵfac = function CaseHeaderModule_Factory(t) { return new (t || CaseHeaderModule)(); };
+CaseHeaderModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: CaseHeaderModule });
+CaseHeaderModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+        RouterModule,
+        PaletteModule] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseHeaderModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    RouterModule,
+                    PaletteModule
+                ],
+                declarations: [
+                    CaseHeaderComponent,
+                ],
+                exports: [
+                    CaseHeaderComponent,
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CaseHeaderModule, { declarations: [CaseHeaderComponent], imports: [CommonModule,
+        RouterModule,
+        PaletteModule], exports: [CaseHeaderComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FzZS1oZWFkZXIubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9jb21wb25lbnRzL2Nhc2UtaGVhZGVyL2Nhc2UtaGVhZGVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUMzQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQzs7QUFlOUQsTUFBTSxPQUFPLGdCQUFnQjs7Z0ZBQWhCLGdCQUFnQjtrRUFBaEIsZ0JBQWdCO3NFQVhyQixZQUFZO1FBQ1osWUFBWTtRQUNaLGFBQWE7dUZBU1IsZ0JBQWdCO2NBYjVCLFFBQVE7ZUFBQztnQkFDTixPQUFPLEVBQUU7b0JBQ0wsWUFBWTtvQkFDWixZQUFZO29CQUNaLGFBQWE7aUJBQ2hCO2dCQUNELFlBQVksRUFBRTtvQkFDVixtQkFBbUI7aUJBQ3RCO2dCQUNELE9BQU8sRUFBRTtvQkFDTCxtQkFBbUI7aUJBQ3RCO2FBQ0o7O3dGQUNZLGdCQUFnQixtQkFOckIsbUJBQW1CLGFBTG5CLFlBQVk7UUFDWixZQUFZO1FBQ1osYUFBYSxhQU1iLG1CQUFtQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUm91dGVyTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IFBhbGV0dGVNb2R1bGUgfSBmcm9tICcuLi9wYWxldHRlJztcbmltcG9ydCB7IENhc2VIZWFkZXJDb21wb25lbnQgfSBmcm9tICcuL2Nhc2UtaGVhZGVyLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW1xuICAgICAgICBDb21tb25Nb2R1bGUsXG4gICAgICAgIFJvdXRlck1vZHVsZSxcbiAgICAgICAgUGFsZXR0ZU1vZHVsZVxuICAgIF0sXG4gICAgZGVjbGFyYXRpb25zOiBbXG4gICAgICAgIENhc2VIZWFkZXJDb21wb25lbnQsXG4gICAgXSxcbiAgICBleHBvcnRzOiBbXG4gICAgICAgIENhc2VIZWFkZXJDb21wb25lbnQsXG4gICAgXVxufSlcbmV4cG9ydCBjbGFzcyBDYXNlSGVhZGVyTW9kdWxlIHt9XG4iXX0=

package/esm2020/lib/shared/components/case-history/case-history.component.mjs

@@ -0,0 +1,242 @@
+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";
+function CaseHistoryComponent_div_0_ng_container_57_ng_container_6_tr_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "tr")(1, "th", 14)(2, "div", 15);
+    i0.ɵɵtext(3);
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(4, "td");
+    i0.ɵɵelement(5, "ccd-field-read", 16);
+    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_57_ng_container_6_tr_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "tr", 17)(1, "td", 18);
+    i0.ɵɵelement(2, "ccd-field-read", 16);
+    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_57_ng_container_6_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_57_ng_container_6_tr_4_Template, 6, 3, "tr", 12);
+    i0.ɵɵtemplate(5, CaseHistoryComponent_div_0_ng_container_57_ng_container_6_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_57_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "div", 7)(2, "h3", 8);
+    i0.ɵɵtext(3);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(4, "table", 9);
+    i0.ɵɵpipe(5, "rpxTranslate");
+    i0.ɵɵtemplate(6, CaseHistoryComponent_div_0_ng_container_57_ng_container_6_Template, 6, 8, "ng-container", 6);
+    i0.ɵɵpipe(7, "ccdReadFieldsFilter");
+    i0.ɵɵpipe(8, "ccdTabFields");
+    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.ɵɵattribute("aria-describedby", i0.ɵɵpipeBind1(5, 4, "case history table"));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngForOf", i0.ɵɵpipeBind4(7, 6, i0.ɵɵpipeBind1(8, 11, tab_r2), false, undefined, true));
+} }
+function CaseHistoryComponent_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div")(1, "div", 1)(2, "div", 2);
+    i0.ɵɵelement(3, "ccd-case-header", 3);
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(4, "div", 1)(5, "div", 2)(6, "div")(7, "h2", 4);
+    i0.ɵɵtext(8);
+    i0.ɵɵpipe(9, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(10, "table", 5)(11, "tbody")(12, "tr")(13, "th");
+    i0.ɵɵtext(14);
+    i0.ɵɵpipe(15, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(16, "td");
+    i0.ɵɵtext(17);
+    i0.ɵɵpipe(18, "ccdDate");
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(19, "tr")(20, "th");
+    i0.ɵɵtext(21);
+    i0.ɵɵpipe(22, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(23, "td");
+    i0.ɵɵtext(24);
+    i0.ɵɵpipe(25, "titlecase");
+    i0.ɵɵpipe(26, "uppercase");
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(27, "tr")(28, "th");
+    i0.ɵɵtext(29);
+    i0.ɵɵpipe(30, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(31, "td");
+    i0.ɵɵtext(32);
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(33, "tr")(34, "th");
+    i0.ɵɵtext(35);
+    i0.ɵɵpipe(36, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(37, "td");
+    i0.ɵɵtext(38);
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(39, "tr")(40, "th");
+    i0.ɵɵtext(41);
+    i0.ɵɵpipe(42, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(43, "td");
+    i0.ɵɵtext(44);
+    i0.ɵɵpipe(45, "ccdDash");
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(46, "tr")(47, "th");
+    i0.ɵɵtext(48);
+    i0.ɵɵpipe(49, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(50, "td");
+    i0.ɵɵtext(51);
+    i0.ɵɵpipe(52, "ccdDash");
+    i0.ɵɵelementEnd()()()()();
+    i0.ɵɵelementStart(53, "div")(54, "h2", 4);
+    i0.ɵɵtext(55);
+    i0.ɵɵpipe(56, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(57, CaseHistoryComponent_div_0_ng_container_57_Template, 9, 13, "ng-container", 6);
+    i0.ɵɵelementEnd()()()();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("caseDetails", ctx_r0.caseDetails);
+    i0.ɵɵadvance(5);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(9, 17, "Event Details"));
+    i0.ɵɵadvance(6);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(15, 19, "Date"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind2(18, 21, ctx_r0.caseHistory.event.timestamp, "local"));
+    i0.ɵɵadvance(4);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(22, 24, "Author"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate2("", i0.ɵɵpipeBind1(25, 26, ctx_r0.caseHistory.event.user_first_name), " ", i0.ɵɵpipeBind1(26, 28, ctx_r0.caseHistory.event.user_last_name), "");
+    i0.ɵɵadvance(5);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(30, 30, "End state"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(ctx_r0.caseHistory.event.state_name);
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(36, 32, "Event"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(ctx_r0.caseHistory.event.event_name);
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(42, 34, "Summary"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(45, 36, ctx_r0.caseHistory.event.summary));
+    i0.ɵɵadvance(4);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(49, 38, "Comment"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(52, 40, ctx_r0.caseHistory.event.comment));
+    i0.ɵɵadvance(4);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(56, 42, "Case Details"));
+    i0.ɵɵadvance(2);
+    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 = /*@__PURE__*/ 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"], [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, 58, 44, "div", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.isDataLoaded());
+    } }, styles: [".CaseHistory[_ngcontent-%COMP%]   th[_ngcontent-%COMP%], .CaseHistory[_ngcontent-%COMP%]   td[_ngcontent-%COMP%]{border-bottom:none}.caseHistorySection[_ngcontent-%COMP%]{margin-top:40px}.EventDetails[_ngcontent-%COMP%]   th[_ngcontent-%COMP%], .EventDetails[_ngcontent-%COMP%]   td[_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', template: "<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' | rpxTranslate}}</h2>\n        <table class=\"EventDetails\" aria-describedby=\"event details table\">\n          <tbody>\n          <tr>\n            <th>{{'Date' | rpxTranslate}}</th>\n            <td>{{caseHistory.event.timestamp | ccdDate : 'local'}}</td>\n          </tr>\n          <tr>\n            <th>{{'Author' | rpxTranslate}}</th>\n            <td>{{caseHistory.event.user_first_name | titlecase}} {{caseHistory.event.user_last_name | uppercase}}</td>\n          </tr>\n          <tr>\n            <th>{{'End state' | rpxTranslate}}</th>\n            <td>{{caseHistory.event.state_name}}</td>\n          </tr>\n          <tr>\n            <th>{{'Event' | rpxTranslate}}</th>\n            <td>{{caseHistory.event.event_name}}</td>\n          </tr>\n          <tr>\n            <th>{{'Summary' | rpxTranslate}}</th>\n            <td>{{caseHistory.event.summary | ccdDash}}</td>\n          </tr>\n          <tr>\n            <th>{{'Comment' | rpxTranslate}}</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' | rpxTranslate}}</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}}\" [attr.aria-describedby]=\"'case history table' | rpxTranslate\">\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", styles: [".CaseHistory th,.CaseHistory td{border-bottom:none}.caseHistorySection{margin-top:40px}.EventDetails th,.EventDetails td{border-bottom:none}th{width:1%;white-space:nowrap;vertical-align:top}.compound-field td{padding:0}.case-viewer-controls{margin-top:47px;margin-bottom:20px}ccd-case-header{float:left;margin-right:10px}ccd-event-trigger{float:right}.case-viewer-label{min-width:300px;white-space:normal}\n"] }]
+    }], 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' | rpxTranslate}}</h2>\n        <table class=\"EventDetails\" aria-describedby=\"event details table\">\n          <tbody>\n          <tr>\n            <th>{{'Date' | rpxTranslate}}</th>\n            <td>{{caseHistory.event.timestamp | ccdDate : 'local'}}</td>\n          </tr>\n          <tr>\n            <th>{{'Author' | rpxTranslate}}</th>\n            <td>{{caseHistory.event.user_first_name | titlecase}} {{caseHistory.event.user_last_name | uppercase}}</td>\n          </tr>\n          <tr>\n            <th>{{'End state' | rpxTranslate}}</th>\n            <td>{{caseHistory.event.state_name}}</td>\n          </tr>\n          <tr>\n            <th>{{'Event' | rpxTranslate}}</th>\n            <td>{{caseHistory.event.event_name}}</td>\n          </tr>\n          <tr>\n            <th>{{'Summary' | rpxTranslate}}</th>\n            <td>{{caseHistory.event.summary | ccdDash}}</td>\n          </tr>\n          <tr>\n            <th>{{'Comment' | rpxTranslate}}</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' | rpxTranslate}}</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}}\" [attr.aria-describedby]=\"'case history table' | rpxTranslate\">\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/esm2020/lib/shared/components/case-history/case-history.module.mjs

@@ -0,0 +1,64 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { RpxTranslationModule } from 'rpx-xui-translation';
+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";
+import * as i1 from "rpx-xui-translation";
+import * as i2 from "@angular/common";
+import * as i3 from "../case-header/case-header.component";
+import * as i4 from "../palette/base-field/field-read.component";
+import * as i5 from "../../directives/substitutor/label-substitutor.directive";
+import * as i6 from "../palette/utils/date.pipe";
+import * as i7 from "../palette/utils/is-compound.pipe";
+import * as i8 from "../palette/utils/dash.pipe";
+import * as i9 from "../../pipes/complex/ccd-read-fields-filter.pipe";
+import * as i10 from "../../pipes/complex/ccd-tab-fields.pipe";
+export class CaseHistoryModule {
+}
+CaseHistoryModule.ɵfac = function CaseHistoryModule_Factory(t) { return new (t || CaseHistoryModule)(); };
+CaseHistoryModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: CaseHistoryModule });
+CaseHistoryModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+        CaseHistoryService,
+    ], imports: [CommonModule,
+        RouterModule,
+        CaseHeaderModule,
+        ConditionalShowModule,
+        PaletteModule,
+        LabelSubstitutorModule,
+        RpxTranslationModule.forChild()] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseHistoryModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    RouterModule,
+                    CaseHeaderModule,
+                    ConditionalShowModule,
+                    PaletteModule,
+                    LabelSubstitutorModule,
+                    RpxTranslationModule.forChild()
+                ],
+                declarations: [
+                    CaseHistoryComponent
+                ],
+                providers: [
+                    CaseHistoryService,
+                ],
+                exports: [
+                    CaseHistoryComponent,
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CaseHistoryModule, { declarations: [CaseHistoryComponent], imports: [CommonModule,
+        RouterModule,
+        CaseHeaderModule,
+        ConditionalShowModule,
+        PaletteModule,
+        LabelSubstitutorModule, i1.RpxTranslationModule], exports: [CaseHistoryComponent] }); })();
+i0.ɵɵsetComponentScope(CaseHistoryComponent, function () { return [i2.NgForOf, i2.NgIf, i2.NgSwitch, i2.NgSwitchCase, i3.CaseHeaderComponent, i4.FieldReadComponent, i5.LabelSubstitutorDirective]; }, function () { return [i2.UpperCasePipe, i2.TitleCasePipe, i6.DatePipe, i7.IsCompoundPipe, i8.DashPipe, i9.ReadFieldsFilterPipe, i10.CcdTabFieldsPipe, i1.RpxTranslatePipe]; });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/components/case-history/domain/case-history.model.mjs

@@ -0,0 +1,29 @@
+import { __decorate, __metadata } from "tslib";
+// tslint:disable:variable-name
+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,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

package/esm2020/lib/shared/components/case-history/services/case-history.service.mjs

@@ -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 = /*@__PURE__*/ 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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