@hmcts/ccd-case-ui-toolkit 6.10.7-rollback-case-link → 6.13.0-rc1

package/esm2015/lib/shared/directives/conditional-show/services/condition-parser.service.js

@@ -0,0 +1,201 @@
+import * as _score from 'underscore';
+import peg from './condition.peg';
+import { FieldsUtils } from '../../../services/fields/fields.utils';
+import { ShowCondition } from '../../conditional-show/domain/conditional-show.model';
+export class ConditionParser {
+    /**
+     * Parse the raw formula and output structured condition data
+     * that can be used in evaluating show/hide logic
+     * @param condition raw formula e.g. TextField = "Hello"
+     */
+    static parse(condition) {
+        if (!condition) {
+            return null;
+        }
+        ;
+        condition = condition.replace(/CONTAINS/g, ' CONTAINS');
+        return peg.parse(condition.trim(), {});
+    }
+    /**
+     * Evaluate the current fields against the conditions
+     * @param fields the current page fields and their value
+     * @param conditions The PegJS formula output
+     */
+    static evaluate(fields, conditions, path) {
+        if (!conditions) {
+            return true;
+        }
+        ;
+        const validJoinComparators = ['AND', 'OR'];
+        const result = conditions.reduce((accumulator, condition, index) => {
+            const isJoinComparator = (comparator) => (typeof comparator === 'string' && validJoinComparators.indexOf(comparator) !== -1);
+            if (isJoinComparator(condition)) {
+                return accumulator;
+            }
+            ;
+            let currentConditionResult = true;
+            if (Array.isArray(condition)) {
+                currentConditionResult = this.evaluate(fields, condition);
+                if (isJoinComparator(conditions[index - 1])) {
+                    return this.evaluateJoin(accumulator, conditions[index - 1], currentConditionResult);
+                }
+            }
+            if (condition.comparator) {
+                const formula = condition.fieldReference + condition.comparator + condition.value;
+                currentConditionResult = this.matchEqualityCondition(fields, formula, path);
+            }
+            if (isJoinComparator(conditions[index - 1])) {
+                return this.evaluateJoin(accumulator, conditions[index - 1], currentConditionResult);
+            }
+            return currentConditionResult;
+        }, true);
+        return result;
+    }
+    static evaluateJoin(leftResult, comparator, rightResult) {
+        switch (comparator) {
+            case 'OR': return leftResult || rightResult;
+            case 'AND': return leftResult && rightResult;
+        }
+    }
+    static matchEqualityCondition(fields, condition, path) {
+        const [field, conditionSeparator] = this.getField(condition);
+        const [head, ...tail] = field.split('.');
+        const currentValue = this.findValueForComplexCondition(fields, head, tail, path);
+        const expectedValue = this.unquoted(condition.split(conditionSeparator)[1]);
+        if (conditionSeparator === ShowCondition.CONTAINS) {
+            return this.checkValueContains(expectedValue, currentValue);
+        }
+        else {
+            return this.checkValueEquals(expectedValue, currentValue, conditionSeparator);
+        }
+    }
+    static getValue(fields, head) {
+        if (this.isDynamicList(fields[head])) {
+            return fields[head].value.code;
+        }
+        else {
+            return fields[head];
+        }
+    }
+    static isDynamicList(dynamiclist) {
+        return !_score.isEmpty(dynamiclist) &&
+            (_score.has(dynamiclist, 'value') && _score.has(dynamiclist, 'list_items'));
+    }
+    static getField(condition) {
+        let separator = ShowCondition.CONTAINS;
+        if (condition.indexOf(ShowCondition.CONTAINS) < 0) {
+            separator = ShowCondition.CONDITION_EQUALS;
+            if (condition.indexOf(ShowCondition.CONDITION_NOT_EQUALS) > -1) {
+                separator = ShowCondition.CONDITION_NOT_EQUALS;
+            }
+        }
+        return [condition.split(separator)[0], separator];
+    }
+    static checkValueEquals(expectedValue, currentValue, conditionSeparaor) {
+        if (expectedValue.search('[,]') > -1) { // for  multi-select list
+            return this.checkMultiSelectListEquals(expectedValue, currentValue, conditionSeparaor);
+        }
+        else if (expectedValue.endsWith('*') && currentValue && conditionSeparaor !== ShowCondition.CONDITION_NOT_EQUALS) {
+            if (typeof currentValue === 'string') {
+                return currentValue.startsWith(this.removeStarChar(expectedValue));
+            }
+            return expectedValue === '*';
+        }
+        else {
+            // changed from '===' to '==' to cover number field conditions
+            if (conditionSeparaor === ShowCondition.CONDITION_NOT_EQUALS) {
+                return this.checkValueNotEquals(expectedValue, currentValue);
+            }
+            else {
+                return currentValue == expectedValue || this.okIfBothEmpty(expectedValue, currentValue); // tslint:disable-line
+            }
+        }
+    }
+    static checkValueNotEquals(expectedValue, currentValue) {
+        const formatCurrentValue = currentValue ? currentValue.toString().trim() : '';
+        if ('*' === expectedValue && formatCurrentValue !== '') {
+            return false;
+        }
+        const formatExpectedValue = expectedValue ? expectedValue.toString().trim() : '';
+        return formatCurrentValue != formatExpectedValue; // tslint:disable-line
+    }
+    static checkMultiSelectListEquals(expectedValue, currentValue, conditionSeparator) {
+        const expectedValues = expectedValue.split(',').sort().toString();
+        const values = currentValue ? currentValue.sort().toString() : '';
+        if (conditionSeparator === ShowCondition.CONDITION_NOT_EQUALS) {
+            return expectedValues !== values;
+        }
+        else {
+            return expectedValues === values;
+        }
+    }
+    static checkValueContains(expectedValue, currentValue) {
+        if (expectedValue.search(',') > -1) {
+            const expectedValues = expectedValue.split(',').sort();
+            const values = currentValue ? currentValue.sort().toString() : '';
+            return expectedValues.every(item => values.search(item) >= 0);
+        }
+        else {
+            const values = currentValue && Array.isArray(currentValue) ? currentValue.toString() : '';
+            return values.search(expectedValue) >= 0;
+        }
+    }
+    static unquoted(str) {
+        const res = str.replace(/^"|"$/g, '');
+        return res;
+    }
+    static findValueForComplexCondition(fields, head, tail, path) {
+        if (!fields) {
+            return undefined;
+        }
+        if (tail.length === 0) {
+            return this.getValue(fields, head);
+        }
+        else {
+            if (FieldsUtils.isArray(fields[head])) {
+                return this.findValueForComplexConditionInArray(fields, head, tail, path);
+            }
+            else {
+                return this.findValueForComplexConditionForPathIfAny(fields, head, tail, path);
+            }
+        }
+    }
+    static findValueForComplexConditionForPathIfAny(fields, head, tail, path) {
+        if (path) {
+            const [_, ...pathTail] = path.split(/[_]+/g);
+            return this.findValueForComplexCondition(fields[head], tail[0], tail.slice(1), pathTail.join('_'));
+        }
+        else {
+            return this.findValueForComplexCondition(fields[head], tail[0], tail.slice(1), path);
+        }
+    }
+    static findValueForComplexConditionInArray(fields, head, tail, path) {
+        // use the path to resolve which array element we refer to
+        if (path.startsWith(head)) {
+            const [_, ...pathTail] = path.split(/[_]+/g);
+            if (pathTail.length > 0) {
+                try {
+                    const arrayIndex = Number.parseInt(pathTail[0], 10);
+                    const [__, ...dropNumberPath] = pathTail;
+                    return (fields[head][arrayIndex] !== undefined) ? this.findValueForComplexCondition(fields[head][arrayIndex]['value'], tail[0], tail.slice(1), dropNumberPath.join('_')) : null;
+                }
+                catch (e) {
+                    console.error('Error while parsing number', pathTail[0], e);
+                }
+            }
+        }
+        else {
+            console.error('Path in formArray should start with ', head, ', full path: ', path);
+        }
+    }
+    static removeStarChar(str) {
+        if (str && str.indexOf('*') > -1) {
+            return str.substring(0, str.indexOf('*'));
+        }
+        return str;
+    }
+    static okIfBothEmpty(right, value) {
+        return value === null && (right === '');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"condition-parser.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/directives/conditional-show/services/condition-parser.service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as _score from 'underscore';\nimport peg from './condition.peg';\nimport { FieldsUtils } from '../../../services/fields/fields.utils';\nimport { ShowCondition } from '../../conditional-show/domain/conditional-show.model';\n\nexport class ConditionParser {\n\n  /**\n   * Parse the raw formula and output structured condition data\n   * that can be used in evaluating show/hide logic\n   * @param condition raw formula e.g. TextField = \"Hello\"\n   */\n  public static parse(condition: string): any {\n    if (!condition) { return null };\n    condition = condition.replace(/CONTAINS/g, ' CONTAINS');\n    return peg.parse(condition.trim(), {});\n  }\n\n  /**\n   * Evaluate the current fields against the conditions\n   * @param fields the current page fields and their value\n   * @param conditions The PegJS formula output\n   */\n  public static evaluate(fields: any, conditions: any[], path?: string): boolean {\n    if (!conditions) { return true };\n    const validJoinComparators = ['AND', 'OR'];\n\n    const result: boolean = conditions.reduce((accumulator: boolean, condition, index: number) => {\n      const isJoinComparator = (comparator: string): boolean =>\n        (typeof comparator === 'string' && validJoinComparators.indexOf(comparator) !== -1);\n\n      if (isJoinComparator(condition)) { return accumulator };\n\n      let currentConditionResult = true;\n\n      if (Array.isArray(condition)) {\n        currentConditionResult = this.evaluate(fields, condition);\n\n        if (isJoinComparator(conditions[index - 1])) {\n          return this.evaluateJoin(accumulator, conditions[index - 1], currentConditionResult);\n        }\n      }\n\n      if (condition.comparator) {\n        const formula = condition.fieldReference + condition.comparator + condition.value;\n        currentConditionResult = this.matchEqualityCondition(fields, formula, path);\n      }\n\n      if (isJoinComparator(conditions[index - 1])) {\n        return this.evaluateJoin(accumulator, conditions[index - 1], currentConditionResult);\n      }\n\n      return currentConditionResult;\n    }, true);\n\n    return result;\n  }\n\n  private static evaluateJoin(leftResult: boolean, comparator, rightResult: boolean): boolean {\n    switch (comparator) {\n      case 'OR': return leftResult || rightResult;\n      case 'AND': return leftResult && rightResult;\n    }\n  }\n\n  private static matchEqualityCondition(fields: object, condition: string, path?: string): boolean {\n    const [field, conditionSeparator] = this.getField(condition);\n    const [head, ...tail] = field.split('.');\n    const currentValue = this.findValueForComplexCondition(fields, head, tail, path);\n    const expectedValue = this.unquoted(condition.split(conditionSeparator)[1]);\n    if (conditionSeparator === ShowCondition.CONTAINS) {\n      return this.checkValueContains(expectedValue, currentValue);\n    } else {\n      return this.checkValueEquals(expectedValue, currentValue, conditionSeparator);\n    }\n  }\n\n  private static getValue(fields: object, head: string): any {\n    if (this.isDynamicList(fields[head])) {\n      return fields[head].value.code;\n    } else {\n      return fields[head];\n    }\n  }\n\n  private static isDynamicList(dynamiclist: object): boolean {\n    return !_score.isEmpty(dynamiclist) &&\n        (_score.has(dynamiclist, 'value') && _score.has(dynamiclist, 'list_items'));\n  }\n\n  private static getField(condition: string): [string, string?] {\n    let separator: string = ShowCondition.CONTAINS;\n    if (condition.indexOf(ShowCondition.CONTAINS) < 0) {\n      separator = ShowCondition.CONDITION_EQUALS;\n      if (condition.indexOf(ShowCondition.CONDITION_NOT_EQUALS) > -1) {\n        separator = ShowCondition.CONDITION_NOT_EQUALS;\n      }\n    }\n    return [ condition.split(separator)[0], separator ];\n  }\n\n  private static checkValueEquals(expectedValue: string, currentValue: any, conditionSeparaor: string): boolean {\n    if (expectedValue.search('[,]') > -1) { // for  multi-select list\n      return this.checkMultiSelectListEquals(expectedValue, currentValue, conditionSeparaor);\n    } else if (expectedValue.endsWith('*') && currentValue && conditionSeparaor !== ShowCondition.CONDITION_NOT_EQUALS) {\n      if (typeof currentValue === 'string') {\n        return currentValue.startsWith(this.removeStarChar(expectedValue));\n      }\n      return expectedValue === '*';\n    } else {\n      // changed from '===' to '==' to cover number field conditions\n      if (conditionSeparaor === ShowCondition.CONDITION_NOT_EQUALS) {\n        return this.checkValueNotEquals(expectedValue, currentValue);\n      } else {\n        return currentValue == expectedValue || this.okIfBothEmpty(expectedValue, currentValue); // tslint:disable-line\n      }\n    }\n  }\n\n  private static checkValueNotEquals(expectedValue: string, currentValue: any): boolean {\n    const formatCurrentValue = currentValue ? currentValue.toString().trim() : '';\n    if ('*' === expectedValue && formatCurrentValue !== '') {\n      return false;\n    }\n    const formatExpectedValue = expectedValue ? expectedValue.toString().trim() : '';\n    return formatCurrentValue != formatExpectedValue; // tslint:disable-line\n  }\n\n  private static checkMultiSelectListEquals(expectedValue: string, currentValue: any, conditionSeparator: string): boolean {\n    const expectedValues = expectedValue.split(',').sort().toString();\n    const values = currentValue ? currentValue.sort().toString() : '';\n    if (conditionSeparator === ShowCondition.CONDITION_NOT_EQUALS) {\n      return expectedValues !== values;\n    } else {\n      return expectedValues === values;\n    }\n  }\n\n  private static checkValueContains(expectedValue: string, currentValue: any): boolean {\n    if (expectedValue.search(',') > -1) {\n      const expectedValues = expectedValue.split(',').sort();\n      const values = currentValue ? currentValue.sort().toString() : '';\n      return expectedValues.every(item => values.search(item) >= 0);\n    } else {\n      const values = currentValue && Array.isArray(currentValue) ? currentValue.toString() : '';\n      return values.search(expectedValue) >= 0;\n    }\n  }\n\n  private static unquoted(str: string): string {\n    const res = str.replace(/^\"|\"$/g, '');\n    return res;\n  }\n\n  private static findValueForComplexCondition(fields: object, head: string, tail: string[], path?: string): any {\n    if (!fields) {\n      return undefined;\n    }\n    if (tail.length === 0) {\n      return this.getValue(fields, head);\n    } else {\n      if (FieldsUtils.isArray(fields[head])) {\n        return this.findValueForComplexConditionInArray(fields, head, tail, path);\n      } else {\n        return this.findValueForComplexConditionForPathIfAny(fields, head, tail, path);\n      }\n    }\n  }\n\n  private static findValueForComplexConditionForPathIfAny(fields: object, head: string, tail: string[], path?: string): any {\n    if (path) {\n      const [_, ...pathTail] = path.split(/[_]+/g);\n      return this.findValueForComplexCondition(fields[head], tail[0], tail.slice(1), pathTail.join('_'));\n    } else {\n      return this.findValueForComplexCondition(fields[head], tail[0], tail.slice(1), path);\n    }\n  }\n\n  private static findValueForComplexConditionInArray(fields: object, head: string, tail: string[], path?: string): any {\n  // use the path to resolve which array element we refer to\n    if (path.startsWith(head)) {\n      const [_, ...pathTail] = path.split(/[_]+/g);\n      if (pathTail.length > 0) {\n        try {\n          const arrayIndex = Number.parseInt(pathTail[0], 10);\n          const [__, ...dropNumberPath] = pathTail;\n          return (fields[head][arrayIndex] !== undefined) ? this.findValueForComplexCondition(\n          fields[head][arrayIndex]['value'], tail[0], tail.slice(1), dropNumberPath.join('_')) : null;\n        } catch (e) {\n          console.error('Error while parsing number', pathTail[0], e);\n        }\n      }\n    } else {\n      console.error('Path in formArray should start with ', head, ', full path: ', path);\n    }\n  }\n\n  private static removeStarChar(str: string): string {\n    if (str && str.indexOf('*') > -1) {\n      return str.substring(0, str.indexOf('*'));\n    }\n    return str;\n  }\n\n  private static okIfBothEmpty(right: string, value: any): boolean {\n    return value === null && (right === '');\n  }\n}\n"]}

package/esm2015/lib/shared/directives/conditional-show/services/condition.peg.js

@@ -0,0 +1,90 @@
+import { generate } from 'pegjs';
+const conditionSource = `{
+    function flat(arr, depth = 1) {
+      var flatten = function (arr, depth = 1) {
+        if (depth) return arr;
+
+      // Otherwise, concatenate into the parent array
+      return arr.reduce(function (acc, val) {
+        return acc.concat(Array.isArray(val) ? flatten(val, depth - 1) : val);
+      }, []);
+
+      };
+
+    return flatten(arr, depth - 1);
+    }
+  }
+
+  Start
+    = Formula
+
+  Formula
+    = EnclosedFormula
+    / OpenFormula
+
+  EnclosedFormula
+    = bracket formula:OpenFormula bracket join:(JoinComparator)*
+      { return flat([ [formula], join[0] ], 1) }
+
+  OpenFormula
+    = eq:OpenEqualityCheck joins:(JoinComparator)*
+      { return flat([ eq, flat(joins) ]) }
+
+  JoinComparator
+    = comp:Comparator eq:OpenEqualityCheck
+      { return [comp, eq]; }
+      / CompoundJoinComparator
+
+  CompoundJoinComparator
+    = comp:Comparator bracket f:OpenFormula bracket
+      { return [comp, f ] }
+
+  OpenEqualityCheck
+    = fr:FieldReference _? op:operator _? val:Value
+     { return { fieldReference: fr, comparator: op, value: val } }
+
+  Comparator
+   = _? c:'AND' _?
+   { return c; }
+   / _? c:'OR' _?
+   { return c; }
+
+  Word
+   = l:Letter+
+   { return l.join(""); }
+
+  Letter
+   = [a-zA-Z]
+
+  Value
+   = v:quotedValue / v:Word
+   { return v.join("") }
+   / v:number
+   { return parseInt(v.join("")) }
+
+  FieldReference
+    = characters:[A-Za-z0-9._]+ { return characters.join(""); }
+
+  number
+   = [0-9]+
+
+  quotedValue
+   = '"'val:[A-Za-z0-9.,* _-]*'"'
+   { return val.join(""); }
+
+  bracket
+   = (_? "("+ _? / _? ")"+ _? )
+
+  operator
+   = "=" / "!=" / "CONTAINS"
+
+  ws "Whitespace"
+   = [ \t]
+
+  _ "One or more whitespaces"
+   = ws+
+
+  nl "New line"
+   = "\\n"`;
+export default generate(conditionSource);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared/domain/case-flag/hmcts-service-detail.model.js

@@ -6,4 +6,4 @@ export class HmctsServiceDetail {
         this.service_id = 0;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG1jdHMtc2VydmljZS1kZXRhaWwubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2RvbWFpbi9jYXNlLWZsYWcvaG1jdHMtc2VydmljZS1kZXRhaWwubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQWtCO0lBQS9CO1FBU0UsZUFBVSxHQUFHLENBQUMsQ0FBQztJQUdqQixDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIERUTyB0byBwcm92aWRlIHR5cGluZyBvZiB0aGUgcmVzcG9uc2UgZnJvbSB0aGUgUmVmZXJlbmNlIERhdGEgTG9jYXRpb24gQVBJIGZvciBITUNUUyBzZXJ2aWNlIGRldGFpbHMuXG4gKi9cbmV4cG9ydCBjbGFzcyBIbWN0c1NlcnZpY2VEZXRhaWwge1xuICBidXNpbmVzc19hcmVhOiBzdHJpbmc7XG4gIGNjZF9jYXNlX3R5cGVzOiBzdHJpbmdbXTtcbiAgY2NkX3NlcnZpY2VfbmFtZTogc3RyaW5nO1xuICBqdXJpc2RpY3Rpb246IHN0cmluZztcbiAgbGFzdF91cGRhdGU/OiBzdHJpbmc7XG4gIG9yZ191bml0OiBzdHJpbmc7XG4gIHNlcnZpY2VfY29kZT86IHN0cmluZztcbiAgc2VydmljZV9kZXNjcmlwdGlvbj86IHN0cmluZztcbiAgc2VydmljZV9pZCA9IDA7XG4gIHNlcnZpY2Vfc2hvcnRfZGVzY3JpcHRpb24/OiBzdHJpbmc7XG4gIHN1Yl9idXNpbmVzc19hcmVhOiBzdHJpbmc7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG1jdHMtc2VydmljZS1kZXRhaWwubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL2RvbWFpbi9jYXNlLWZsYWcvaG1jdHMtc2VydmljZS1kZXRhaWwubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQWtCO0lBQS9CO1FBU1MsZUFBVSxHQUFHLENBQUMsQ0FBQztJQUd4QixDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIERUTyB0byBwcm92aWRlIHR5cGluZyBvZiB0aGUgcmVzcG9uc2UgZnJvbSB0aGUgUmVmZXJlbmNlIERhdGEgTG9jYXRpb24gQVBJIGZvciBITUNUUyBzZXJ2aWNlIGRldGFpbHMuXG4gKi9cbmV4cG9ydCBjbGFzcyBIbWN0c1NlcnZpY2VEZXRhaWwge1xuICBwdWJsaWMgYnVzaW5lc3NfYXJlYTogc3RyaW5nO1xuICBwdWJsaWMgY2NkX2Nhc2VfdHlwZXM6IHN0cmluZ1tdO1xuICBwdWJsaWMgY2NkX3NlcnZpY2VfbmFtZTogc3RyaW5nO1xuICBwdWJsaWMganVyaXNkaWN0aW9uOiBzdHJpbmc7XG4gIHB1YmxpYyBsYXN0X3VwZGF0ZT86IHN0cmluZztcbiAgcHVibGljIG9yZ191bml0OiBzdHJpbmc7XG4gIHB1YmxpYyBzZXJ2aWNlX2NvZGU/OiBzdHJpbmc7XG4gIHB1YmxpYyBzZXJ2aWNlX2Rlc2NyaXB0aW9uPzogc3RyaW5nO1xuICBwdWJsaWMgc2VydmljZV9pZCA9IDA7XG4gIHB1YmxpYyBzZXJ2aWNlX3Nob3J0X2Rlc2NyaXB0aW9uPzogc3RyaW5nO1xuICBwdWJsaWMgc3ViX2J1c2luZXNzX2FyZWE6IHN0cmluZztcbn1cbiJdfQ==

package/esm2015/lib/shared/services/case-flag/case-flag-refdata.service.js

@@ -49,13 +49,14 @@ export class CaseFlagRefdataService {
         return of(null);
     }
     /**
-     * Retrieves the HMCTS service details for a jurisdiction or service, including service code. (For example, the "SSCS"
-     * service has a corresponding service code of "BBA3".)
+     * 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
      */
-    getHmctsServiceDetails(serviceNames) {
+    getHmctsServiceDetailsByServiceName(serviceNames) {
         let url = this.appConfig.getLocationRefApiUrl();
         if (url) {
             url += '/orgServices';
@@ -66,10 +67,30 @@ export class CaseFlagRefdataService {
         }
         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 = 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FzZS1mbGFnLXJlZmRhdGEuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NjZC1jYXNlLXVpLXRvb2xraXQvc3JjL2xpYi9zaGFyZWQvc2VydmljZXMvY2FzZS1mbGFnL2Nhc2UtZmxhZy1yZWZkYXRhLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQWMsRUFBRSxFQUFFLFVBQVUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUNsRCxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDckMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFeEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLFNBQVMsQ0FBQzs7OztBQUl0QyxNQUFNLE9BQU8sc0JBQXNCO0lBQ2pDLFlBQ21CLElBQWlCLEVBQ2pCLFNBQTRCO1FBRDVCLFNBQUksR0FBSixJQUFJLENBQWE7UUFDakIsY0FBUyxHQUFULFNBQVMsQ0FBbUI7SUFDM0MsQ0FBQztJQUVMOzs7Ozs7O09BT0c7SUFDSSxtQkFBbUIsQ0FBQyxTQUFpQixFQUFFLFFBQThCLEVBQUUsYUFBdUI7UUFDbkcsSUFBSSxHQUFHLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyx5QkFBeUIsRUFBRSxDQUFDO1FBRXJELElBQUksR0FBRyxFQUFFO1lBQ1AsR0FBRyxHQUFHLEdBQUcsQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLFNBQVMsQ0FBQyxDQUFDO1lBQ3JDLElBQUksUUFBUSxFQUFFO2dCQUNaLEdBQUcsSUFBSSxjQUFjLFFBQVEsRUFBRSxDQUFDO2FBQ2pDO1lBQ0QsSUFBSSxhQUFhLElBQUksSUFBSSxFQUFFO2dCQUN6QiwrRkFBK0Y7Z0JBQy9GLEdBQUcsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsSUFBSSxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsSUFBSSxHQUFHLENBQUM7Z0JBQ2hELGFBQWEsQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLGtCQUFrQixDQUFDLENBQUMsQ0FBQyxHQUFHLElBQUksa0JBQWtCLENBQUM7YUFDdkU7WUFFRCxPQUFPLElBQUksQ0FBQyxJQUFJO2lCQUNiLEdBQUcsQ0FBQyxHQUFHLEVBQUUsRUFBQyxPQUFPLEVBQUUsTUFBTSxFQUFDLENBQUM7aUJBQzNCLElBQUk7WUFDSCxnSEFBZ0g7WUFDaEgsaUhBQWlIO1lBQ2pILG1CQUFtQjtZQUNuQixHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUU7Z0JBQ1QsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsV0FBVyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsTUFBTSxFQUFFO29CQUNqSCwwR0FBMEc7b0JBQzFHLDJCQUEyQjtvQkFDM0IsT0FBTyxVQUFVLENBQUMsSUFBSSxLQUFLLENBQUMsa0NBQWtDLENBQUMsQ0FBQyxDQUFDO2lCQUNsRTtnQkFDRCxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsV0FBVyxDQUFDO1lBQ25DLENBQUMsQ0FBQyxDQUNILENBQUM7U0FDTDtRQUVELE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2xCLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxzQkFBc0IsQ0FBQyxZQUFxQjtRQUNqRCxJQUFJLEdBQUcsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLG9CQUFvQixFQUFFLENBQUM7UUFFaEQsSUFBSSxHQUFHLEVBQUU7WUFDUCxHQUFHLElBQUksY0FBYyxDQUFDO1lBQ3RCLElBQUksWUFBWSxFQUFFO2dCQUNoQixHQUFHLElBQUksb0JBQW9CLFlBQVksRUFBRSxDQUFDO2FBQzNDO1lBRUQsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsRUFBQyxPQUFPLEVBQUUsTUFBTSxFQUFDLENBQUMsQ0FBQztTQUM5QztRQUVELE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2xCLENBQUM7OzRGQXBFVSxzQkFBc0I7OERBQXRCLHNCQUFzQixXQUF0QixzQkFBc0I7dUZBQXRCLHNCQUFzQjtjQURsQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgb2YsIHRocm93RXJyb3IgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IEFic3RyYWN0QXBwQ29uZmlnIH0gZnJvbSAnLi4vLi4vLi4vYXBwLmNvbmZpZyc7XG5pbXBvcnQgeyBGbGFnVHlwZSwgSG1jdHNTZXJ2aWNlRGV0YWlsIH0gZnJvbSAnLi4vLi4vZG9tYWluL2Nhc2UtZmxhZyc7XG5pbXBvcnQgeyBIdHRwU2VydmljZSB9IGZyb20gJy4uL2h0dHAnO1xuaW1wb3J0IHsgUmVmZGF0YUNhc2VGbGFnVHlwZSB9IGZyb20gJy4vcmVmZGF0YS1jYXNlLWZsYWctdHlwZS5lbnVtJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIENhc2VGbGFnUmVmZGF0YVNlcnZpY2Uge1xuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIHJlYWRvbmx5IGh0dHA6IEh0dHBTZXJ2aWNlLFxuICAgIHByaXZhdGUgcmVhZG9ubHkgYXBwQ29uZmlnOiBBYnN0cmFjdEFwcENvbmZpZ1xuICApIHsgfVxuXG4gIC8qKlxuICAgKiBSZXRyaWV2ZXMgdGhlIENhc2UgRmxhZyB0eXBlcyBmb3IgYW4gSE1DVFMgc2VydmljZS5cbiAgICpcbiAgICogQHBhcmFtIHNlcnZpY2VJZCBUaGUgSE1DVFMgU2VydmljZSBDb2RlIGZvciBhIGp1cmlzZGljdGlvbiBvciBzZXJ2aWNlLiAqKk5vdGU6KiogVGhpcyBpcyBfbm90XyB0aGUgc2VydmljZSBuYW1lXG4gICAqIEBwYXJhbSBmbGFnVHlwZSBgUEFSVFlgIGZvciBwYXJ0eS1sZXZlbCBmbGFnczsgYENBU0VgIGZvciBjYXNlLWxldmVsXG4gICAqIEBwYXJhbSB3ZWxzaFJlcXVpcmVkIGB0cnVlYCBpZiBXZWxzaCBsYW5ndWFnZSB2ZXJzaW9ucyBvZiBmbGFncyBhcmUgcmVxdWlyZWQ7IGBmYWxzZWAgb3RoZXJ3aXNlIChmdXR1cmUgZmVhdHVyZSlcbiAgICogQHJldHVybnMgQW4gYE9ic2VydmFibGVgIG9mIGFuIGFycmF5IG9mIGZsYWcgdHlwZXNcbiAgICovXG4gIHB1YmxpYyBnZXRDYXNlRmxhZ3NSZWZkYXRhKHNlcnZpY2VJZDogc3RyaW5nLCBmbGFnVHlwZT86IFJlZmRhdGFDYXNlRmxhZ1R5cGUsIHdlbHNoUmVxdWlyZWQ/OiBib29sZWFuKTogT2JzZXJ2YWJsZTxGbGFnVHlwZVtdPiB7XG4gICAgbGV0IHVybCA9IHRoaXMuYXBwQ29uZmlnLmdldENhc2VGbGFnc1JlZmRhdGFBcGlVcmwoKTtcblxuICAgIGlmICh1cmwpIHtcbiAgICAgIHVybCA9IHVybC5yZXBsYWNlKCc6c2lkJywgc2VydmljZUlkKTtcbiAgICAgIGlmIChmbGFnVHlwZSkge1xuICAgICAgICB1cmwgKz0gYD9mbGFnLXR5cGU9JHtmbGFnVHlwZX1gO1xuICAgICAgfVxuICAgICAgaWYgKHdlbHNoUmVxdWlyZWQgIT0gbnVsbCkge1xuICAgICAgICAvLyBDaGVjayBpZiBmbGFnLXR5cGUgaGFzIGJlZW4gYWRkZWQgdG8gdGhlIHF1ZXJ5IHN0cmluZzsgaWYgc28sIGFwcGVuZCB3ZWxzaC1yZXF1aXJlZCB3aXRoICcmJ1xuICAgICAgICB1cmwuaW5kZXhPZignPycpID4gLTEgPyB1cmwgKz0gJyYnIDogdXJsICs9ICc/JztcbiAgICAgICAgd2Vsc2hSZXF1aXJlZCA/IHVybCArPSAnd2Vsc2gtcmVxdWlyZWQ9WScgOiB1cmwgKz0gJ3dlbHNoLXJlcXVpcmVkPU4nO1xuICAgICAgfVxuXG4gICAgICByZXR1cm4gdGhpcy5odHRwXG4gICAgICAgIC5nZXQodXJsLCB7b2JzZXJ2ZTogJ2JvZHknfSlcbiAgICAgICAgLnBpcGUoXG4gICAgICAgICAgLy8gUmVmZXJlbmNlIERhdGEgQ29tbW9uIEFQSSByZXR1cm5zIGEgc2luZ2xlIG9iamVjdCB3aXRoIGEgXCJmbGFnc1wiIGFycmF5LCB3aGljaCBpdHNlbGYgY29udGFpbnMgYSBzaW5nbGUgb2JqZWN0XG4gICAgICAgICAgLy8gd2l0aCBhIFwiRmxhZ0RldGFpbHNcIiBhcnJheSwgd2hpY2ggY29udGFpbnMgYSBoaWVyYXJjaHkgb2YgZmxhZyB0eXBlcyBpbiBhbiBvYmplY3QgLSBvbmUgZWFjaCBmb3IgXCJQYXJ0eVwiIGZsYWdzXG4gICAgICAgICAgLy8gYW5kIFwiQ2FzZVwiIGZsYWdzXG4gICAgICAgICAgbWFwKGJvZHkgPT4ge1xuICAgICAgICAgICAgaWYgKCFib2R5IHx8ICFib2R5LmZsYWdzIHx8ICFib2R5LmZsYWdzLmxlbmd0aCB8fCAhYm9keS5mbGFnc1swXS5GbGFnRGV0YWlscyB8fCAhYm9keS5mbGFnc1swXS5GbGFnRGV0YWlscy5sZW5ndGgpIHtcbiAgICAgICAgICAgICAgLy8gTm90ZTogUmVmZXJlbmNlIERhdGEgQ29tbW9uIEFQSSBhcHBlYXJzIHRvIHJlc3BvbmQgd2l0aCBhIDQwNCBlcnJvciByYXRoZXIgdGhhbiBzZW5kIGFuIGVtcHR5IHJlc3BvbnNlLFxuICAgICAgICAgICAgICAvLyBzbyB0aGlzIG1heSBiZSByZWR1bmRhbnRcbiAgICAgICAgICAgICAgcmV0dXJuIHRocm93RXJyb3IobmV3IEVycm9yKCdObyBmbGFnIHR5cGVzIGNvdWxkIGJlIHJldHJpZXZlZCcpKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIHJldHVybiBib2R5LmZsYWdzWzBdLkZsYWdEZXRhaWxzO1xuICAgICAgICAgIH0pXG4gICAgICAgICk7XG4gICAgfVxuXG4gICAgcmV0dXJuIG9mKG51bGwpO1xuICB9XG5cbiAgLyoqXG4gICAqIFJldHJpZXZlcyB0aGUgSE1DVFMgc2VydmljZSBkZXRhaWxzIGZvciBhIGp1cmlzZGljdGlvbiBvciBzZXJ2aWNlLCBpbmNsdWRpbmcgc2VydmljZSBjb2RlLiAoRm9yIGV4YW1wbGUsIHRoZSBcIlNTQ1NcIlxuICAgKiBzZXJ2aWNlIGhhcyBhIGNvcnJlc3BvbmRpbmcgc2VydmljZSBjb2RlIG9mIFwiQkJBM1wiLilcbiAgICpcbiAgICogQHBhcmFtIHNlcnZpY2VOYW1lcyBUaGUgc2VydmljZSBuYW1lKHMpIHRvIGxvb2sgdXAsIGNvbW1hLXNlcGFyYXRlZCBpZiBtb3JlIHRoYW4gb25lXG4gICAqIEByZXR1cm5zIEFuIGBPYnNlcnZhYmxlYCBvZiBhbiBhcnJheSBvZiBzZXJ2aWNlIGRldGFpbHNcbiAgICovXG4gIHB1YmxpYyBnZXRIbWN0c1NlcnZpY2VEZXRhaWxzKHNlcnZpY2VOYW1lcz86IHN0cmluZyk6IE9ic2VydmFibGU8SG1jdHNTZXJ2aWNlRGV0YWlsW10+IHtcbiAgICBsZXQgdXJsID0gdGhpcy5hcHBDb25maWcuZ2V0TG9jYXRpb25SZWZBcGlVcmwoKTtcblxuICAgIGlmICh1cmwpIHtcbiAgICAgIHVybCArPSAnL29yZ1NlcnZpY2VzJztcbiAgICAgIGlmIChzZXJ2aWNlTmFtZXMpIHtcbiAgICAgICAgdXJsICs9IGA/Y2NkU2VydmljZU5hbWVzPSR7c2VydmljZU5hbWVzfWA7XG4gICAgICB9XG5cbiAgICAgIHJldHVybiB0aGlzLmh0dHAuZ2V0KHVybCwge29ic2VydmU6ICdib2R5J30pO1xuICAgIH1cblxuICAgIHJldHVybiBvZihudWxsKTtcbiAgfVxufVxuIl19
+//# 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 (future feature)\n   * @returns An `Observable` of an array of flag types\n   */\n  public getCaseFlagsRefdata(serviceId: string, flagType?: RefdataCaseFlagType, welshRequired?: 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 (welshRequired != null) {\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      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"]}