@hmcts/ccd-case-ui-toolkit 7.0.34-angular-upgrade → 7.0.34-cfv-sort-order-upload-date

package/esm2020/lib/shared/services/case-file-view/case-file-view.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { AbstractAppConfig } from '../../../app.config';
+import { HttpService } from '../http';
+import * as i0 from "@angular/core";
+import * as i1 from "../http";
+import * as i2 from "../../../app.config";
+export class CaseFileViewService {
+    constructor(http, appConfig) {
+        this.http = http;
+        this.appConfig = appConfig;
+    }
+    /**
+     * Retrieves the categories and documents for a case.
+     *
+     * @param caseRef 16-digit Case Reference number of the case
+     * @returns An `Observable` of the `CategoriesAndDocuments` for the case
+     */
+    getCategoriesAndDocuments(caseRef) {
+        let url = this.appConfig.getCategoriesAndDocumentsUrl();
+        if (url) {
+            url += `/${caseRef}`;
+            return this.http.get(url, { observe: 'body' });
+        }
+        return of(null);
+    }
+    updateDocumentCategory(caseRef, caseVersion, attributePath, categoryId) {
+        let url = this.appConfig.getDocumentDataUrl();
+        if (url) {
+            url += `/${caseRef}`;
+            const body = {
+                case_version: caseVersion,
+                attribute_path: attributePath,
+                category_id: categoryId
+            };
+            return this.http.put(url, body, { observe: 'body' });
+        }
+        return of(null);
+    }
+}
+CaseFileViewService.ɵfac = function CaseFileViewService_Factory(t) { return new (t || CaseFileViewService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig)); };
+CaseFileViewService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CaseFileViewService, factory: CaseFileViewService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseFileViewService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/services/case-flag/case-flag-refdata.service.mjs

@@ -0,0 +1,102 @@
+import { Injectable } from '@angular/core';
+import { of, throwError } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../app.config';
+import { HttpService } from '../http';
+import * as i0 from "@angular/core";
+import * as i1 from "../http";
+import * as i2 from "../../../app.config";
+export class CaseFlagRefdataService {
+    constructor(http, appConfig) {
+        this.http = http;
+        this.appConfig = appConfig;
+    }
+    /**
+     * Retrieves the Case Flag types for an HMCTS service.
+     *
+     * @param serviceId The HMCTS Service Code for a jurisdiction or service. **Note:** This is _not_ the service name
+     * @param flagType `PARTY` for party-level flags; `CASE` for case-level
+     * @param welshRequired `true` if Welsh language versions of flags are required; `false` otherwise
+     * @param externalFlagsOnly Only flags with the attribute `availableExternally` set to `true` will be returned
+     * @returns An `Observable` of an array of flag types
+     */
+    getCaseFlagsRefdata(serviceId, flagType, welshRequired, externalFlagsOnly) {
+        let url = this.appConfig.getCaseFlagsRefdataApiUrl();
+        if (url) {
+            url = url.replace(':sid', serviceId);
+            if (flagType) {
+                url += `?flag-type=${flagType}`;
+            }
+            if (typeof welshRequired === 'boolean') {
+                // Check if flag-type has been added to the query string; if so, append welsh-required with '&'
+                url.indexOf('?') > -1 ? url += '&' : url += '?';
+                welshRequired ? url += 'welsh-required=Y' : url += 'welsh-required=N';
+            }
+            if (externalFlagsOnly) {
+                // Check if anything has been added to the query string; if so, append available-external-flag with '&'
+                url.indexOf('?') > -1 ? url += '&' : url += '?';
+                url += 'available-external-flag=Y';
+            }
+            return this.http
+                .get(url, { observe: 'body' })
+                .pipe(
+            // Reference Data Common API returns a single object with a "flags" array, which itself contains a single object
+            // with a "FlagDetails" array, which contains a hierarchy of flag types in an object - one each for "Party" flags
+            // and "Case" flags
+            map(body => {
+                if (!body || !body.flags || !body.flags.length || !body.flags[0].FlagDetails || !body.flags[0].FlagDetails.length) {
+                    // Note: Reference Data Common API appears to respond with a 404 error rather than send an empty response,
+                    // so this may be redundant
+                    return throwError(new Error('No flag types could be retrieved'));
+                }
+                return body.flags[0].FlagDetails;
+            }));
+        }
+        return of(null);
+    }
+    /**
+     * Retrieves the HMCTS service details for a jurisdiction or service, including service codes. More than one
+     * service code may be present. For example, the Divorce jurisdiction/service has corresponding service codes of
+     * "ABA1" and "ABA2".
+     *
+     * @param serviceNames The service name(s) to look up, comma-separated if more than one
+     * @returns An `Observable` of an array of service details
+     */
+    getHmctsServiceDetailsByServiceName(serviceNames) {
+        let url = this.appConfig.getLocationRefApiUrl();
+        if (url) {
+            url += '/orgServices';
+            if (serviceNames) {
+                url += `?ccdServiceNames=${serviceNames}`;
+            }
+            return this.http.get(url, { observe: 'body' });
+        }
+        return of(null);
+    }
+    /**
+     * Retrieves the HMCTS service details for a case type, including service code. For example, the
+     * "FinancialRemedyContested" case type is associated with the Divorce jurisdiction/service and service code "ABA2".
+     *
+     * Note that a case type might not be associated with any service codes of a jurisdiction or service.
+     *
+     * @param caseTypeId The case type ID to look up
+     * @returns An `Observable` of an array of service details
+     */
+    getHmctsServiceDetailsByCaseType(caseTypeId) {
+        let url = this.appConfig.getLocationRefApiUrl();
+        if (url) {
+            url += '/orgServices';
+            if (caseTypeId) {
+                url += `?ccdCaseType=${caseTypeId}`;
+            }
+            return this.http.get(url, { observe: 'body' });
+        }
+        return of(null);
+    }
+}
+CaseFlagRefdataService.ɵfac = function CaseFlagRefdataService_Factory(t) { return new (t || CaseFlagRefdataService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig)); };
+CaseFlagRefdataService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CaseFlagRefdataService, factory: CaseFlagRefdataService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseFlagRefdataService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-flag-refdata.service.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/case-flag/case-flag-refdata.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, of, throwError } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { AbstractAppConfig } from '../../../app.config';\nimport { FlagType, HmctsServiceDetail } from '../../domain/case-flag';\nimport { HttpService } from '../http';\nimport { RefdataCaseFlagType } from './refdata-case-flag-type.enum';\n\n@Injectable()\nexport class CaseFlagRefdataService {\n  constructor(\n    private readonly http: HttpService,\n    private readonly appConfig: AbstractAppConfig\n  ) { }\n\n  /**\n   * Retrieves the Case Flag types for an HMCTS service.\n   *\n   * @param serviceId The HMCTS Service Code for a jurisdiction or service. **Note:** This is _not_ the service name\n   * @param flagType `PARTY` for party-level flags; `CASE` for case-level\n   * @param welshRequired `true` if Welsh language versions of flags are required; `false` otherwise\n   * @param externalFlagsOnly Only flags with the attribute `availableExternally` set to `true` will be returned\n   * @returns An `Observable` of an array of flag types\n   */\n  public getCaseFlagsRefdata(serviceId: string, flagType?: RefdataCaseFlagType, welshRequired?: boolean, externalFlagsOnly?: boolean): Observable<FlagType[]> {\n    let url = this.appConfig.getCaseFlagsRefdataApiUrl();\n\n    if (url) {\n      url = url.replace(':sid', serviceId);\n      if (flagType) {\n        url += `?flag-type=${flagType}`;\n      }\n      if (typeof welshRequired === 'boolean') {\n        // Check if flag-type has been added to the query string; if so, append welsh-required with '&'\n        url.indexOf('?') > -1 ? url += '&' : url += '?';\n        welshRequired ? url += 'welsh-required=Y' : url += 'welsh-required=N';\n      }\n\n      if (externalFlagsOnly) {\n        // Check if anything has been added to the query string; if so, append available-external-flag with '&'\n        url.indexOf('?') > -1 ? url += '&' : url += '?';\n        url += 'available-external-flag=Y';\n      }\n\n      return this.http\n        .get(url, {observe: 'body'})\n        .pipe(\n          // Reference Data Common API returns a single object with a \"flags\" array, which itself contains a single object\n          // with a \"FlagDetails\" array, which contains a hierarchy of flag types in an object - one each for \"Party\" flags\n          // and \"Case\" flags\n          map(body => {\n            if (!body || !body.flags || !body.flags.length || !body.flags[0].FlagDetails || !body.flags[0].FlagDetails.length) {\n              // Note: Reference Data Common API appears to respond with a 404 error rather than send an empty response,\n              // so this may be redundant\n              return throwError(new Error('No flag types could be retrieved'));\n            }\n            return body.flags[0].FlagDetails;\n          })\n        );\n    }\n\n    return of(null);\n  }\n\n  /**\n   * Retrieves the HMCTS service details for a jurisdiction or service, including service codes. More than one\n   * service code may be present. For example, the Divorce jurisdiction/service has corresponding service codes of\n   * \"ABA1\" and \"ABA2\".\n   *\n   * @param serviceNames The service name(s) to look up, comma-separated if more than one\n   * @returns An `Observable` of an array of service details\n   */\n  public getHmctsServiceDetailsByServiceName(serviceNames?: string): Observable<HmctsServiceDetail[]> {\n    let url = this.appConfig.getLocationRefApiUrl();\n\n    if (url) {\n      url += '/orgServices';\n      if (serviceNames) {\n        url += `?ccdServiceNames=${serviceNames}`;\n      }\n\n      return this.http.get(url, {observe: 'body'});\n    }\n\n    return of(null);\n  }\n\n  /**\n   * Retrieves the HMCTS service details for a case type, including service code. For example, the\n   * \"FinancialRemedyContested\" case type is associated with the Divorce jurisdiction/service and service code \"ABA2\".\n   *\n   * Note that a case type might not be associated with any service codes of a jurisdiction or service.\n   *\n   * @param caseTypeId The case type ID to look up\n   * @returns An `Observable` of an array of service details\n   */\n  public getHmctsServiceDetailsByCaseType(caseTypeId?: string): Observable<HmctsServiceDetail[]> {\n    let url = this.appConfig.getLocationRefApiUrl();\n\n    if (url) {\n      url += '/orgServices';\n      if (caseTypeId) {\n        url += `?ccdCaseType=${caseTypeId}`;\n      }\n\n      return this.http.get(url, {observe: 'body'});\n    }\n\n    return of(null);\n  }\n}\n"]}

package/esm2020/lib/shared/services/common-data-service/common-data-service.mjs

@@ -0,0 +1,28 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CommonDataService {
+    constructor(http) {
+        this.http = http;
+    }
+    getRefData(url) {
+        if (url) {
+            return this.http.get(url, { observe: 'body' });
+        }
+        return of(null);
+    }
+    getServiceOrgData(url) {
+        if (url) {
+            return this.http.get(url, { observe: 'body' });
+        }
+        return of(null);
+    }
+}
+CommonDataService.ɵfac = function CommonDataService_Factory(t) { return new (t || CommonDataService)(i0.ɵɵinject(i1.HttpClient)); };
+CommonDataService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CommonDataService, factory: CommonDataService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CommonDataService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/services/definitions/definitions.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { DefinitionsService } from './definitions.service';
+import * as i0 from "@angular/core";
+export class DefinitionsModule {
+}
+DefinitionsModule.ɵfac = function DefinitionsModule_Factory(t) { return new (t || DefinitionsModule)(); };
+DefinitionsModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: DefinitionsModule });
+DefinitionsModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+        DefinitionsService
+    ] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DefinitionsModule, [{
+        type: NgModule,
+        args: [{
+                providers: [
+                    DefinitionsService
+                ]
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmaW5pdGlvbnMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9zZXJ2aWNlcy9kZWZpbml0aW9ucy9kZWZpbml0aW9ucy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQzs7QUFRM0QsTUFBTSxPQUFPLGlCQUFpQjs7a0ZBQWpCLGlCQUFpQjttRUFBakIsaUJBQWlCO3dFQUxmO1FBQ1Asa0JBQWtCO0tBQ3JCO3VGQUdRLGlCQUFpQjtjQU43QixRQUFRO2VBQUM7Z0JBQ04sU0FBUyxFQUFFO29CQUNQLGtCQUFrQjtpQkFDckI7YUFDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEZWZpbml0aW9uc1NlcnZpY2UgfSBmcm9tICcuL2RlZmluaXRpb25zLnNlcnZpY2UnO1xuXG5ATmdNb2R1bGUoe1xuICAgIHByb3ZpZGVyczogW1xuICAgICAgICBEZWZpbml0aW9uc1NlcnZpY2VcbiAgICBdXG59KVxuXG5leHBvcnQgY2xhc3MgRGVmaW5pdGlvbnNNb2R1bGUge31cbiJdfQ==

package/esm2020/lib/shared/services/definitions/definitions.service.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { AbstractAppConfig as AppConfig } from '../../../app.config';
+import { HttpService } from '../http/http.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../http/http.service";
+import * as i2 from "../../../app.config";
+export class DefinitionsService {
+    constructor(http, appConfig) {
+        this.http = http;
+        this.appConfig = appConfig;
+    }
+    getCaseTypes(jurisdictionId, access) {
+        const url = `${this.appConfig.getApiUrl()}/caseworkers/:uid/jurisdictions/${jurisdictionId}/case-types?access=${access}`;
+        return this.http
+            .get(url).pipe(map(response => response));
+    }
+    getJurisdictions(access) {
+        const url = `${this.appConfig.getApiUrl()}/caseworkers/:uid/jurisdictions?access=${access}`;
+        return this.http
+            .get(url)
+            .pipe(map(response => response));
+    }
+}
+DefinitionsService.ɵfac = function DefinitionsService_Factory(t) { return new (t || DefinitionsService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig)); };
+DefinitionsService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DefinitionsService, factory: DefinitionsService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DefinitionsService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/services/document-management/document-management.service.mjs

@@ -0,0 +1,112 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { delay } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../app.config';
+import { HttpService } from '../http';
+import * as i0 from "@angular/core";
+import * as i1 from "../http";
+import * as i2 from "../../../app.config";
+export class DocumentManagementService {
+    constructor(http, appConfig) {
+        this.http = http;
+        this.appConfig = appConfig;
+    }
+    uploadFile(formData) {
+        const url = this.getDocStoreUrl();
+        // Do not set any headers, such as "Accept" or "Content-Type", with null values; this is not permitted with the
+        // Angular HttpClient in @angular/common/http. Just create and pass a new HttpHeaders object. Angular will add the
+        // correct headers and values automatically
+        const headers = new HttpHeaders();
+        return this.http
+            .post(url, formData, { headers, observe: 'body' })
+            .pipe(delay(DocumentManagementService.RESPONSE_DELAY));
+    }
+    getMediaViewerInfo(documentFieldValue) {
+        const mediaViewerInfo = {
+            document_binary_url: this.transformDocumentUrl(documentFieldValue.document_binary_url),
+            document_filename: documentFieldValue.document_filename,
+            content_type: this.getContentType(documentFieldValue),
+            annotation_api_url: this.appConfig.getAnnotationApiUrl(),
+            case_id: documentFieldValue.id,
+            case_jurisdiction: documentFieldValue.jurisdiction
+        };
+        return JSON.stringify(mediaViewerInfo);
+    }
+    getContentType(documentFieldValue) {
+        let fileExtension = '<unknown>';
+        if (documentFieldValue.document_filename) {
+            const position = documentFieldValue.document_filename.lastIndexOf('.');
+            if (position === documentFieldValue.document_filename.length) {
+                fileExtension = '';
+            }
+            else if (position >= 0) {
+                fileExtension = documentFieldValue.document_filename.slice(position + 1);
+            }
+        }
+        if (this.isImage(fileExtension)) {
+            return DocumentManagementService.IMAGE;
+        }
+        else if (this.isWord(fileExtension)) {
+            return DocumentManagementService.WORD;
+        }
+        else if (this.isExcel(fileExtension)) {
+            return DocumentManagementService.EXCEL;
+        }
+        else if (this.isPowerpoint(fileExtension)) {
+            return DocumentManagementService.POWERPOINT;
+        }
+        else if (fileExtension.toLowerCase() === 'txt') {
+            return DocumentManagementService.TXT;
+        }
+        else if (fileExtension.toLowerCase() === 'rtf') {
+            return DocumentManagementService.RTF;
+        }
+        else if (fileExtension.toLowerCase() === 'pdf') {
+            return DocumentManagementService.PDF;
+        }
+        else {
+            return fileExtension;
+        }
+    }
+    isImage(imageType) {
+        return DocumentManagementService.imagesList.find(e => e === imageType) !== undefined;
+    }
+    isWord(wordType) {
+        return DocumentManagementService.wordList.find(e => e === wordType) !== undefined;
+    }
+    isExcel(excelType) {
+        return DocumentManagementService.excelList.find(e => e === excelType) !== undefined;
+    }
+    isPowerpoint(powerpointType) {
+        return DocumentManagementService.powerpointList.find(e => e === powerpointType) !== undefined;
+    }
+    transformDocumentUrl(documentBinaryUrl) {
+        const remoteHrsPattern = new RegExp(this.appConfig.getRemoteHrsUrl());
+        documentBinaryUrl = documentBinaryUrl.replace(remoteHrsPattern, this.appConfig.getHrsUrl());
+        const remoteDocumentManagementPattern = new RegExp(this.appConfig.getRemoteDocumentManagementUrl());
+        return documentBinaryUrl.replace(remoteDocumentManagementPattern, this.getDocStoreUrl());
+    }
+    getDocStoreUrl() {
+        return this.appConfig.getDocumentSecureMode() ? this.appConfig.getDocumentManagementUrlV2() : this.appConfig.getDocumentManagementUrl();
+    }
+}
+DocumentManagementService.PDF = 'pdf';
+DocumentManagementService.IMAGE = 'image';
+DocumentManagementService.WORD = 'word';
+DocumentManagementService.EXCEL = 'excel';
+DocumentManagementService.POWERPOINT = 'powerpoint';
+DocumentManagementService.TXT = 'txt';
+DocumentManagementService.RTF = 'rtf';
+// This delay has been added to give enough time to the user on the UI to see the info messages on the document upload
+// field for cases when uploads are very fast.
+DocumentManagementService.RESPONSE_DELAY = 1000;
+DocumentManagementService.imagesList = ['GIF', 'JPG', 'JPEG', 'PNG', 'gif', 'jpg', 'jpeg', 'png'];
+DocumentManagementService.wordList = ['DOC', 'DOCX', 'doc', 'docx'];
+DocumentManagementService.excelList = ['XLS', 'XLSX', 'xls', 'xlsx'];
+DocumentManagementService.powerpointList = ['PPT', 'PPTX', 'ppt', 'pptx'];
+DocumentManagementService.ɵfac = function DocumentManagementService_Factory(t) { return new (t || DocumentManagementService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig)); };
+DocumentManagementService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DocumentManagementService, factory: DocumentManagementService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DocumentManagementService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-management.service.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/document-management/document-management.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHeaders } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { delay } from 'rxjs/operators';\nimport { AbstractAppConfig } from '../../../app.config';\nimport { DocumentData } from '../../domain/document/document-data.model';\nimport { HttpService } from '../http';\n\n@Injectable()\nexport class DocumentManagementService {\n  private static readonly PDF = 'pdf';\n  private static readonly IMAGE = 'image';\n  private static readonly WORD = 'word';\n  private static readonly EXCEL = 'excel';\n  private static readonly POWERPOINT = 'powerpoint';\n  private static readonly TXT = 'txt';\n  private static readonly RTF = 'rtf';\n\n  // This delay has been added to give enough time to the user on the UI to see the info messages on the document upload\n  // field for cases when uploads are very fast.\n  private static readonly RESPONSE_DELAY = 1000;\n\n  private static readonly imagesList: string[] = ['GIF', 'JPG', 'JPEG', 'PNG', 'gif', 'jpg', 'jpeg', 'png'];\n  private static readonly wordList: string[] = ['DOC', 'DOCX', 'doc', 'docx'];\n  private static readonly excelList: string[] = ['XLS', 'XLSX', 'xls', 'xlsx'];\n  private static readonly powerpointList: string[] = ['PPT', 'PPTX', 'ppt', 'pptx'];\n\n  constructor(private readonly http: HttpService, private readonly appConfig: AbstractAppConfig) {}\n\n  public uploadFile(formData: FormData): Observable<DocumentData> {\n    const url = this.getDocStoreUrl();\n    // Do not set any headers, such as \"Accept\" or \"Content-Type\", with null values; this is not permitted with the\n    // Angular HttpClient in @angular/common/http. Just create and pass a new HttpHeaders object. Angular will add the\n    // correct headers and values automatically\n    const headers = new HttpHeaders();\n    return this.http\n      .post(url, formData, {headers, observe: 'body'})\n      .pipe(delay(DocumentManagementService.RESPONSE_DELAY));\n  }\n\n  public getMediaViewerInfo(documentFieldValue: any): string {\n    const mediaViewerInfo = {\n        document_binary_url: this.transformDocumentUrl(documentFieldValue.document_binary_url),\n        document_filename: documentFieldValue.document_filename,\n        content_type: this.getContentType(documentFieldValue),\n        annotation_api_url: this.appConfig.getAnnotationApiUrl(),\n        case_id: documentFieldValue.id,\n        case_jurisdiction: documentFieldValue.jurisdiction\n      };\n    return JSON.stringify(mediaViewerInfo);\n  }\n\n  public getContentType(documentFieldValue: any): string {\n    let fileExtension = '<unknown>';\n    if (documentFieldValue.document_filename) {\n      const position = documentFieldValue.document_filename.lastIndexOf('.');\n      if (position === documentFieldValue.document_filename.length) {\n        fileExtension = '';\n      } else if (position >= 0) {\n        fileExtension = documentFieldValue.document_filename.slice(position + 1);\n      }\n    }\n    if (this.isImage(fileExtension)) {\n      return DocumentManagementService.IMAGE;\n    } else if (this.isWord(fileExtension)) {\n      return DocumentManagementService.WORD;\n    } else if (this.isExcel(fileExtension)) {\n      return DocumentManagementService.EXCEL;\n    } else if (this.isPowerpoint(fileExtension)) {\n      return DocumentManagementService.POWERPOINT;\n    } else if (fileExtension.toLowerCase() === 'txt') {\n      return DocumentManagementService.TXT;\n    } else if (fileExtension.toLowerCase() === 'rtf') {\n      return DocumentManagementService.RTF;\n    } else if (fileExtension.toLowerCase() === 'pdf') {\n      return DocumentManagementService.PDF;\n    } else {\n      return fileExtension;\n    }\n  }\n\n  public isImage(imageType: string): boolean {\n    return DocumentManagementService.imagesList.find(e => e === imageType) !== undefined;\n  }\n\n  public isWord(wordType: string): boolean {\n    return DocumentManagementService.wordList.find(e => e === wordType) !== undefined;\n  }\n\n  public isExcel(excelType: string): boolean {\n    return DocumentManagementService.excelList.find(e => e === excelType) !== undefined;\n  }\n\n  public isPowerpoint(powerpointType: string): boolean {\n    return DocumentManagementService.powerpointList.find(e => e === powerpointType) !== undefined;\n  }\n\n  private transformDocumentUrl(documentBinaryUrl: string): string {\n    const remoteHrsPattern = new RegExp(this.appConfig.getRemoteHrsUrl());\n    documentBinaryUrl = documentBinaryUrl.replace(remoteHrsPattern, this.appConfig.getHrsUrl());\n    const remoteDocumentManagementPattern = new RegExp(this.appConfig.getRemoteDocumentManagementUrl());\n    return documentBinaryUrl.replace(remoteDocumentManagementPattern, this.getDocStoreUrl());\n  }\n\n  private getDocStoreUrl(): string {\n    return this.appConfig.getDocumentSecureMode() ? this.appConfig.getDocumentManagementUrlV2() : this.appConfig.getDocumentManagementUrl();\n  }\n}\n"]}

package/esm2020/lib/shared/services/draft/draft.service.mjs

@@ -0,0 +1,86 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../app.config';
+import { Draft, DRAFT_PREFIX } from '../../domain/draft.model';
+import { HttpErrorService, HttpService } from '../http';
+import * as i0 from "@angular/core";
+import * as i1 from "../http";
+import * as i2 from "../../../app.config";
+export class DraftService {
+    constructor(http, appConfig, errorService) {
+        this.http = http;
+        this.appConfig = appConfig;
+        this.errorService = errorService;
+    }
+    createDraft(ctid, eventData) {
+        const saveDraftEndpoint = this.appConfig.getCreateOrUpdateDraftsUrl(ctid);
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', DraftService.V2_MEDIATYPE_DRAFT_CREATE)
+            .set('Content-Type', 'application/json');
+        return this.http
+            .post(saveDraftEndpoint, eventData, { headers, observe: 'body' })
+            .pipe(catchError((error) => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }));
+    }
+    updateDraft(ctid, draftId, eventData) {
+        const saveDraftEndpoint = this.appConfig.getCreateOrUpdateDraftsUrl(ctid) + draftId;
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', DraftService.V2_MEDIATYPE_DRAFT_UPDATE)
+            .set('Content-Type', 'application/json');
+        return this.http
+            .put(saveDraftEndpoint, eventData, { headers, observe: 'body' })
+            .pipe(catchError((error) => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }));
+    }
+    getDraft(draftId) {
+        const url = this.appConfig.getViewOrDeleteDraftsUrl(draftId.slice(DRAFT_PREFIX.length));
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', DraftService.V2_MEDIATYPE_DRAFT_READ)
+            .set('Content-Type', 'application/json');
+        return this.http
+            .get(url, { headers, observe: 'body' })
+            .pipe(catchError((error) => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }));
+    }
+    deleteDraft(draftId) {
+        const url = this.appConfig.getViewOrDeleteDraftsUrl(draftId.slice(DRAFT_PREFIX.length));
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', DraftService.V2_MEDIATYPE_DRAFT_DELETE)
+            .set('Content-Type', 'application/json');
+        return this.http
+            .delete(url, { headers, observe: 'body' }).pipe(catchError((error) => {
+            this.errorService.setError(error);
+            return throwError(error);
+        }));
+    }
+    createOrUpdateDraft(caseTypeId, draftId, caseEventData) {
+        if (!draftId) {
+            return this.createDraft(caseTypeId, caseEventData);
+        }
+        else {
+            return this.updateDraft(caseTypeId, Draft.stripDraftId(draftId), caseEventData);
+        }
+    }
+}
+DraftService.V2_MEDIATYPE_DRAFT_CREATE = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-draft-create.v2+json;charset=UTF-8';
+DraftService.V2_MEDIATYPE_DRAFT_UPDATE = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-draft-update.v2+json;charset=UTF-8';
+DraftService.V2_MEDIATYPE_DRAFT_READ = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-draft-read.v2+json;charset=UTF-8';
+DraftService.V2_MEDIATYPE_DRAFT_DELETE = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-draft-delete.v2+json;charset=UTF-8';
+DraftService.ɵfac = function DraftService_Factory(t) { return new (t || DraftService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig), i0.ɵɵinject(i1.HttpErrorService)); };
+DraftService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DraftService, factory: DraftService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DraftService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }, { type: i1.HttpErrorService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draft.service.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/draft/draft.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHeaders } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Observable, throwError } from 'rxjs';\nimport { catchError } from 'rxjs/operators';\nimport { AbstractAppConfig } from '../../../app.config';\nimport { CaseEventData } from '../../domain/case-event-data.model';\nimport { CaseView } from '../../domain/case-view/case-view.model';\nimport { Draft, DRAFT_PREFIX } from '../../domain/draft.model';\nimport { HttpErrorService, HttpService } from '../http';\n\n@Injectable()\nexport class DraftService {\n\n  public static readonly V2_MEDIATYPE_DRAFT_CREATE =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-draft-create.v2+json;charset=UTF-8';\n  public static readonly V2_MEDIATYPE_DRAFT_UPDATE =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-draft-update.v2+json;charset=UTF-8';\n  public static readonly V2_MEDIATYPE_DRAFT_READ =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-draft-read.v2+json;charset=UTF-8';\n  public static readonly V2_MEDIATYPE_DRAFT_DELETE =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-draft-delete.v2+json;charset=UTF-8';\n\n  constructor(\n    private readonly http: HttpService,\n    private readonly appConfig: AbstractAppConfig,\n    private readonly errorService: HttpErrorService\n  ) {}\n\n  public createDraft(ctid: string, eventData: CaseEventData): Observable<Draft> {\n    const saveDraftEndpoint = this.appConfig.getCreateOrUpdateDraftsUrl(ctid);\n    const headers = new HttpHeaders()\n      .set('experimental', 'true')\n      .set('Accept', DraftService.V2_MEDIATYPE_DRAFT_CREATE)\n      .set('Content-Type', 'application/json');\n    return this.http\n      .post(saveDraftEndpoint, eventData, {headers, observe: 'body'})\n      .pipe(catchError((error: any): any => {\n        this.errorService.setError(error);\n        return throwError(error);\n      }));\n  }\n\n  public updateDraft(ctid: string, draftId: string, eventData: CaseEventData): Observable<Draft> {\n    const saveDraftEndpoint = this.appConfig.getCreateOrUpdateDraftsUrl(ctid) + draftId;\n    const headers = new HttpHeaders()\n      .set('experimental', 'true')\n      .set('Accept', DraftService.V2_MEDIATYPE_DRAFT_UPDATE)\n      .set('Content-Type', 'application/json');\n    return this.http\n      .put(saveDraftEndpoint, eventData, {headers, observe: 'body'})\n      .pipe(catchError((error: any): any => {\n        this.errorService.setError(error);\n        return throwError(error);\n      }));\n  }\n\n  public getDraft(draftId: string): Observable<CaseView> {\n    const url = this.appConfig.getViewOrDeleteDraftsUrl(draftId.slice(DRAFT_PREFIX.length));\n    const headers = new HttpHeaders()\n      .set('experimental', 'true')\n      .set('Accept', DraftService.V2_MEDIATYPE_DRAFT_READ)\n      .set('Content-Type', 'application/json');\n    return this.http\n      .get(url, {headers, observe: 'body'})\n      .pipe(\n        catchError((error: any): any => {\n          this.errorService.setError(error);\n          return throwError(error);\n        })\n      );\n  }\n\n  public deleteDraft(draftId: string): Observable<{} | any> {\n    const url = this.appConfig.getViewOrDeleteDraftsUrl(draftId.slice(DRAFT_PREFIX.length));\n    const headers = new HttpHeaders()\n      .set('experimental', 'true')\n      .set('Accept', DraftService.V2_MEDIATYPE_DRAFT_DELETE)\n      .set('Content-Type', 'application/json');\n    return this.http\n      .delete(url, {headers, observe: 'body'}).pipe(\n        catchError((error: any): any => {\n          this.errorService.setError(error);\n          return throwError(error);\n        })\n      );\n  }\n\n  public createOrUpdateDraft(caseTypeId: string, draftId: string, caseEventData: CaseEventData): Observable<Draft> {\n    if (!draftId) {\n      return this.createDraft(caseTypeId, caseEventData);\n    } else {\n      return this.updateDraft(caseTypeId, Draft.stripDraftId(draftId), caseEventData);\n    }\n  }\n}\n"]}

package/esm2020/lib/shared/services/error/error-notifier.service.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ErrorNotifierService {
+    constructor() {
+        this.errorSource = new Subject();
+        this.error = this.errorSource.asObservable();
+    }
+    announceError(error) {
+        this.errorSource.next(error);
+    }
+}
+ErrorNotifierService.ɵfac = function ErrorNotifierService_Factory(t) { return new (t || ErrorNotifierService)(); };
+ErrorNotifierService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ErrorNotifierService, factory: ErrorNotifierService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ErrorNotifierService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3Itbm90aWZpZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NjZC1jYXNlLXVpLXRvb2xraXQvc3JjL2xpYi9zaGFyZWQvc2VydmljZXMvZXJyb3IvZXJyb3Itbm90aWZpZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBRy9CLE1BQU0sT0FBTyxvQkFBb0I7SUFEakM7UUFFUyxnQkFBVyxHQUFpQixJQUFJLE9BQU8sRUFBTyxDQUFDO1FBQy9DLFVBQUssR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLFlBQVksRUFBRSxDQUFDO0tBS2hEO0lBSFEsYUFBYSxDQUFDLEtBQVU7UUFDN0IsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDL0IsQ0FBQzs7d0ZBTlUsb0JBQW9COzBFQUFwQixvQkFBb0IsV0FBcEIsb0JBQW9CO3VGQUFwQixvQkFBb0I7Y0FEaEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFN1YmplY3QgfSBmcm9tICdyeGpzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEVycm9yTm90aWZpZXJTZXJ2aWNlIHtcbiAgcHVibGljIGVycm9yU291cmNlOiBTdWJqZWN0PGFueT4gPSBuZXcgU3ViamVjdDxhbnk+KCk7XG4gIHB1YmxpYyBlcnJvciA9IHRoaXMuZXJyb3JTb3VyY2UuYXNPYnNlcnZhYmxlKCk7XG5cbiAgcHVibGljIGFubm91bmNlRXJyb3IoZXJyb3I6IGFueSkge1xuICAgIHRoaXMuZXJyb3JTb3VyY2UubmV4dChlcnJvcik7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/shared/services/eventStatusService/event-status.service.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class EventStatusService {
+    static isIncomplete(eventStatus) {
+        if (!eventStatus) {
+            return false;
+        }
+        return EventStatusService.CALLBACK_STATUS_INCOMPLETE === eventStatus
+            || EventStatusService.DELETE_DRAFT_STATUS_INCOMPLETE === eventStatus;
+    }
+}
+EventStatusService.CALLBACK_STATUS_INCOMPLETE = 'INCOMPLETE_CALLBACK';
+EventStatusService.DELETE_DRAFT_STATUS_INCOMPLETE = 'INCOMPLETE_DELETE_DRAFT';
+EventStatusService.CALLBACK_STATUS_COMPLETE = 'CALLBACK_COMPLETED';
+EventStatusService.DELETE_DRAFT_STATUS_COMPLETE = 'DELETE_DRAFT_COMPLETED';
+EventStatusService.ɵfac = function EventStatusService_Factory(t) { return new (t || EventStatusService)(); };
+EventStatusService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EventStatusService, factory: EventStatusService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventStatusService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtc3RhdHVzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL3NlcnZpY2VzL2V2ZW50U3RhdHVzU2VydmljZS9ldmVudC1zdGF0dXMuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUczQyxNQUFNLE9BQU8sa0JBQWtCO0lBTXRCLE1BQU0sQ0FBQyxZQUFZLENBQUUsV0FBbUI7UUFDN0MsSUFBSSxDQUFDLFdBQVcsRUFBRTtZQUNoQixPQUFPLEtBQUssQ0FBQztTQUNkO1FBQ0QsT0FBTyxrQkFBa0IsQ0FBQywwQkFBMEIsS0FBSyxXQUFXO2VBQy9ELGtCQUFrQixDQUFDLDhCQUE4QixLQUFLLFdBQVcsQ0FBQztJQUN6RSxDQUFDOztBQVhzQiw2Q0FBMEIsR0FBRyxxQkFBcUIsQ0FBQztBQUNuRCxpREFBOEIsR0FBRyx5QkFBeUIsQ0FBQztBQUMzRCwyQ0FBd0IsR0FBRyxvQkFBb0IsQ0FBQztBQUNoRCwrQ0FBNEIsR0FBRyx3QkFBd0IsQ0FBQztvRkFKcEUsa0JBQWtCO3dFQUFsQixrQkFBa0IsV0FBbEIsa0JBQWtCO3VGQUFsQixrQkFBa0I7Y0FEOUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEV2ZW50U3RhdHVzU2VydmljZSB7XG4gIHB1YmxpYyBzdGF0aWMgcmVhZG9ubHkgQ0FMTEJBQ0tfU1RBVFVTX0lOQ09NUExFVEUgPSAnSU5DT01QTEVURV9DQUxMQkFDSyc7XG4gIHB1YmxpYyBzdGF0aWMgcmVhZG9ubHkgREVMRVRFX0RSQUZUX1NUQVRVU19JTkNPTVBMRVRFID0gJ0lOQ09NUExFVEVfREVMRVRFX0RSQUZUJztcbiAgcHVibGljIHN0YXRpYyByZWFkb25seSBDQUxMQkFDS19TVEFUVVNfQ09NUExFVEUgPSAnQ0FMTEJBQ0tfQ09NUExFVEVEJztcbiAgcHVibGljIHN0YXRpYyByZWFkb25seSBERUxFVEVfRFJBRlRfU1RBVFVTX0NPTVBMRVRFID0gJ0RFTEVURV9EUkFGVF9DT01QTEVURUQnO1xuXG4gIHB1YmxpYyBzdGF0aWMgaXNJbmNvbXBsZXRlIChldmVudFN0YXR1czogc3RyaW5nKSB7XG4gICAgaWYgKCFldmVudFN0YXR1cykge1xuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cbiAgICByZXR1cm4gRXZlbnRTdGF0dXNTZXJ2aWNlLkNBTExCQUNLX1NUQVRVU19JTkNPTVBMRVRFID09PSBldmVudFN0YXR1c1xuICAgICAgfHwgRXZlbnRTdGF0dXNTZXJ2aWNlLkRFTEVURV9EUkFGVF9TVEFUVVNfSU5DT01QTEVURSA9PT0gZXZlbnRTdGF0dXM7XG4gIH1cbn1cbiJdfQ==