在 Red Hat Process Automation Manager 中开发决策服务

流程

1. 在 VS Code IDE 中，选择 Extensions 菜单选项，并搜索 Red Hat Business Automation Bundle for DMN、Tist 和 test 场景文件支持。

   对于 DMN 或 the 文件支持，您也可以搜索单独的 DMN Editor 或 Tailoring Editor 扩展。

2. 当 Red Hat Business Automation Bundle 扩展出现在 VS Code 中时，选择它并单击 Install。
3. 对于最佳 VS Code 编辑器行为，请在完成扩展安装后，重新加载或关闭和重新启动 VS Code 实例。

流程

1. 使用以下方法之一安装独立编辑器：

   手动下载每个 JavaScript 文件 ：对于此方法，请按照以下步骤执行：

   1. 下载 JavaScript 文件。
   2. 将下载的 Javascript 文件添加到托管应用程序中。

   3. 将以下 &lt ;script& gt; 标签添加到 HTML 页面中：

      DMN 编辑器的 HTML 页面的脚本标签

      <script src="https://<YOUR_PAGE>/dmn/index.js"></script>

      您的 HTML 页面的脚本标签

      <script src="https://<YOUR_PAGE>/bpmn/index.js"></script>

   使用 NPM 软件包 ：对于这个方法，请按照以下步骤执行：

   1. 在您的 package.json 文件中添加 NPM 软件包：

      添加 NPM 软件包

      npm install @kie-tools/kie-editors-standalone

   2. 将每个编辑器库导入到您的 TypeScript 文件中：

      导入每个编辑器

      import * as DmnEditor from "@kie-tools/kie-editors-standalone/dist/dmn"
      import * as BpmnEditor from "@kie-tools/kie-editors-standalone/dist/bpmn"

2. 安装独立编辑器后，使用提供的编辑器 API 打开所需的编辑器，如下例所示来打开 DMN 编辑器。每个编辑器的 API 相同。

   打开 DMN 独立编辑器

   const editor = DmnEditor.open({
     container: document.getElementById("dmn-editor-container"),
     initialContent: Promise.resolve(""),
     readOnly: false,
     origin: "",
     resources: new Map([
       [
         "MyIncludedModel.dmn",
         {
           contentType: "text",
           content: Promise.resolve("")
         }
       ]
     ])
   });

   在编辑器 API 中使用以下参数：

   表 2.1. 参数示例

   参数	描述
   container	附加编辑器的 HTML 元素。
   initialContent	承诺 DMN 模型内容。这个参数可以为空，如下例所示： Promise.resolve("") Promise.resolve("<DIAGRAM_CONTENT_DIRECTLY_HERE>") fetch("MyDmnModel.dmn").then(content ⇒ content.text())
   ReadOnly （可选）	允许您在编辑器中允许更改。设置为 false （默认）以允许编辑器中的只读模式的内容编辑和 true。
   原始 （可选）	存储库的来源。默认值为 window.location.origin。
   资源 （可选）	编辑器的资源映射。例如，此参数用于为 DMN 编辑器提供包含的型号，或为 the 编辑器提供工作项目定义。映射中的每个条目都包含一个资源名称，以及一个由 content-type (text 或 binary) 和 content (与 initialContent 参数类似) 组成的对象。

   返回的对象包含操作编辑器所需的方法。

   表 2.2. 返回的对象方法

   方法	描述
   getContent(): Promise<string>	返回包含编辑器内容的承诺。
   setContent(path: string, content: string): void	设置编辑器的内容。
   getPreview(): Promise<string>	返回包含当前图的 SVG 字符串的承诺。
   subscribeToContentChanges （callback: (isDirty: boolean) void void: (isDirty: boolean) void void	设置在编辑器中内容更改时调用的回调，并返回相同的回调来取消订阅。
   unsubscribeToContentChanges (callback: (isDirty: boolean) rhcs void): void	当内容在编辑器中更改时，取消订阅传递的回调。
   markAsSaved(): void	重置编辑器状态，表示保存编辑器中的内容。另外，它还激活与内容更改相关的订阅回调。
   undo(): void	撤销编辑器中的最后更改。另外，它还激活与内容更改相关的订阅回调。
   redo(): void	在编辑器中更改最后的未撤消更改。另外，它还激活与内容更改相关的订阅回调。
   close(): void	关闭编辑器。
   getElementPosition (selector: string): Promise<Rect>	提供当元素位于 canvas 或视频组件内时扩展标准查询选择器的替代选择。选择器 参数必须遵循 < PROVIDER>:::<SELECT > 格式，如 Canvas:::MySquare 或 Video:::PresenterHand。此方法返回一个代表元素位置的 Rect。
   envelopeApi: MessageBusClientApi<KogitoEditorEnvelopeApi>	这是一个高级编辑器 API。有关高级编辑器 API 的更多信息，请参阅 MessageBusClientApi 和 KogitoEditorEnvelopeApi。

流程

1. 在 Business Central 中，前往 Menu → Design → Projects，点项目名称并选择要修改的 DMN 文件。

2. 在 DMN 设计器 canvas 中，选择您要定义的决定节点或商业知识模型节点，并点击 Edit 图标打开 DMN 框的表达式设计器：

   图 6.11. 打开新决策节点复选框表达式

   

   图 6.12. 打开新的商业知识模型已选中表达式

   

   默认情况下，所有商业知识模型都被定义为带有字面意义的 FEEL 表达式、外部 JAVA 或 PMML 函数的嵌套上下文表达式，或任何类型的嵌套式表达式。

   对于决策节点，您可以点击未定义表来选择要使用的已框表达式类型，如方框式的字面表达式、方框式上下文表达式、决策表或其他 DMN 框的表达式。

   图 6.13. 为决策节点选择逻辑类型

   

   对于业务知识模型节点，您单击左上角的功能单元以选择功能类型，或者右键单击功能价值单元，选择 Clear，然后选择另一个类型的方框。

   图 6.14. 为业务知识模型选择功能或其他逻辑类型

   

3. 在本例中，使用决策节点并选择 Decision Table 作为已选的表达式类型。

   DMN 中的图标表是按表格格式显示一个或多个规则的可视化表示。每个规则均由表中的一行组成，包括针对该特定行定义条件（输入）和结果（输出）的列。

4. 单击 input 列标题，以定义输入条件的名称和数据类型。例如，将输入列命名为 Inventory Score.FICO，数字 数据类型。此列指定数字得分值或贷款的范围。

5. 单击 output 列标题，以定义输出值的名称和数据类型。例如，将输出列命名为 Score Rating and the Data Type 选项，单击 Manage 来转至 Data Types 页面，您可以在其中创建一个分数评级为约束。

   图 6.15. 管理列标题值的数据类型

   

6. 在 Data Types 页面上，点 New Data Type 添加新数据类型或点击 Import Data Object 从您要用作 DMN 数据类型的项目中导入现有数据对象。

   如果您从项目中导入数据对象作为 DMN 数据类型，然后更新该对象，您必须重新导入数据对象作为 DMN 数据类型，以在 DMN 模型中应用更改。

   在本例中，单击 New Data Type 并创建 credit _Score_R ating 数据类型 作为字符串 ：

   图 6.16. 添加新数据类型

   

7. 点 Add Constraints，从下拉列表中选择 Enumeration，并添加以下限制：

   • "Excellent"
   • "Good"
   • "Fair"
   • "Poor"
   • "bad"

   图 6.17. 在新数据类型中添加限制

   

   要更改数据类型约束顺序，您可以点击约束行的左侧，并根据需要拖动行：

   图 6.18. 拖动约束以更改约束顺序

   

   有关指定数据类型的约束类型和语法要求的详情，请查看 Decision Model 和 Notation 规格。

8. 点 OK 保存约束，然后点数据类型右侧的检查标记保存数据类型。
9. 返回到 credit Score Rating 决策表，单击 credit Score Rating 列标题，并将数据类型设置为这个新的自定义数据类型。

10. 使用 credit Score.FICO 输入列来定义贡献分数或值范围，并使用 credit Score Rating 列指定在 credit _Score_Rating 数据类型中定义的相应等级 之一。

    右键点击任意值单元插入或删除行(rules)或列(clauses)。

    图 6.19. 得分评级的决策节点决策表

    

11. 在定义所有规则后，单击决策表的左上角，以定义规则 Hit Policy 和 Builtin Aggregator （仅限 COLLECT hit 策略）。

    hit policy 决定在决定表中的多个规则与提供的输入值匹配时如何到达结果。内置的聚合器决定如何使用 COLLECT hit 策略来聚合规则值。

    图 6.20. 定义决策表点击策略

    

    以下示例是更加复杂的决策表，该表格决定 loans 金级资格，作为同一 loan prequalification 决策模型中包括的决定节点：

    图 6.21. loan prequalification 的决策表

    

流程

1. 在 Business Central 中，前往 Menu → Design → Projects，点项目名称并选择要修改的 DMN 文件。
2. 在 DMN 设计器 Canvas 中，选择您要定义数据类型的决策节点或商业知识模型，并点击 Edit 图标打开 DMN 框式表达式设计程序。

3. 如果已选中的表达式适用于尚未定义的决定节点，请单击 undefined 表来选择要使用的已选框表达式类型，如方框式的字面表达式、关闭上下文表达式、决策表或其他 DMN 框式表达式。

   图 6.24. 为决策节点选择逻辑类型

   

4. 点表标头、列标题或参数字段的单元（取决于您要定义数据类型的表达式类型），然后单击 Manage 以进入可以创建自定义数据类型的 Data Types 页面。

   图 6.25. 管理列标题值的数据类型

   

   您还可以通过选择 DMN 设计器右上角的 Properties 图标，为特定决策节点或业务知识模型节点设置和管理自定义数据类型：

   图 6.26. 在决策需求图中管理数据类型(DRD)属性

   

   您在 box 表达式中为指定单元定义的数据类型决定了您在该关联表、列或已框表达式中使用的数据的结构。

   在这个示例中，DMN 决策表 的贡献列 Score Rating 定义了一组自定义分数等级，以以适用度的贡献分数为基础。

5. 在 Data Types 页面上，点 New Data Type 添加新数据类型或点击 Import Data Object 从您要用作 DMN 数据类型的项目中导入现有数据对象。

   如果您从项目中导入数据对象作为 DMN 数据类型，然后更新该对象，您必须重新导入数据对象作为 DMN 数据类型，以在 DMN 模型中应用更改。

   在本例中，单击 New Data Type 并创建 credit _Score_R ating 数据类型 作为字符串 ：

   图 6.27. 添加新数据类型

   

   如果数据类型需要项目列表，请启用 List 设置。

6. 点 Add Constraints，从下拉列表中选择 Enumeration，并添加以下限制：

   • "Excellent"
   • "Good"
   • "Fair"
   • "Poor"
   • "bad"

   图 6.28. 在新数据类型中添加限制

   

   要更改数据类型约束顺序，您可以点击约束行的左侧，并根据需要拖动行：

   图 6.29. 拖动约束以更改约束顺序

   

   有关指定数据类型的约束类型和语法要求的详情，请查看 Decision Model 和 Notation 规格。

7. 点 OK 保存约束，然后点数据类型右侧的检查标记保存数据类型。

8. 返回 贡献度级别 决策表，点 credit Score Rating 列标题，将数据类型设置为此新的自定义数据类型，并使用您指定的评级限制定义该列的规则值。

   图 6.30. 得分评级的决策表

   

   在这种情况的 DMN 决策模型中，贡献性 决策流至以下需要自定义数据类型 的 Loan Pre qualification 决策：

   图 6.31. loan prequalification 的决策表

   

9. 继续本例，返回 Data Types 窗口，单击 New Data Type，然后创建一个 Loan_Qualification 数据类型作为没有限制的 Structure。

   保存新的结构化数据类型时，会显示第一个子字段，以便您开始在此父数据类型中定义嵌套数据字段。您可以在框中的表达式中使用这些子字段与父结构化数据类型相关联，如嵌套列标题，或在上下文或功能表达式中嵌套表参数。

   对于其他子字段，请选择 Loan_Qualification 数据类型旁边的添加图标：

   图 6.32. 使用嵌套字段添加新的结构化数据类型

   

10. 在本例中，在结构化 Loan_Qualification 数据类型下，添加一个带有 "Qualified" 和" Not Qualified" enumeration 约束的 Qualification 字段，以及没有限制的 Reason 字段。另外，添加简单的 Back_End_Ratio 和 Front_End_Ratio 数据类型（包括 "Sufficient" e Insufficient" enumeration 约束）。

    点击您创建的每种数据类型右侧的检查标记保存更改。

    图 6.33. 使用限制添加嵌套数据类型

    

    要更改数据类型的顺序或嵌套，您可以点击数据类型行的左侧，并根据需要拖动行：

    图 6.34. 拖动数据类型以更改数据类型顺序或嵌套

    

11. 返回各个列的决策表，单击列标题单元格，将数据类型设置为新的对应的自定义数据类型，然后根据需要定义列所需的规则值，并提供您指定的限制（如果适用）。

    图 6.35. loan prequalification 的决策表

    

流程

1. 在 Business Central 中，导航到您的 DMN 项目并在项目中创建或导入 DMN 文件。
2. 打开新的或导入的 DMN 文件，以在 DMN 设计器中查看 DRD，并开始使用左侧工具栏中的 DMN 节点设计或修改 DRD。

3. 对于您要在一个独立的嵌套 DRD 中定义的 DMN 节点，选择该节点，点 DRD Actions 图标，然后从可用选项中选择。

   图 6.49. DRD 操作图标

   

   可用的选项如下：

   • 创建 ：使用这个选项创建嵌套的 DRD，您可以在其中单独定义所选节点的 DMN 组件和图表。
   • 将 添加到: 如果您已经创建了嵌套的 DRD，则使用这个选项将所选节点添加到现有 DRD。
   • 删除: 如果您选择的节点已在嵌套的 DRD 中，使用这个选项从那个嵌套的 DRD 中删除节点。

   在 DMN 决策模型中创建嵌套的 DRD 后，新的 DRD 在单独的 DRD 菜单中选择，可用的 DRD 和组件将在 Decision Navigator 左侧菜单中列出。您可以使用 Decision Navigator 菜单来重命名或删除嵌套的 DRD。

   图 6.50. 在 Decision Navigator 菜单中重命名新的嵌套 DRD

   
4. 在新的嵌套的 DRD 中，像平常一样，为 DMN 模型中所有必要组件设计流和逻辑。

5. 继续为您的决策模型添加并定义任何其他嵌套的 DRD，并保存完整的 DMN 文件。

   例如，以下 loan prequalification 决策模型的 DRD 包含了适用于任何嵌套的 DRD 的模型的所有 DMN 组件。这个示例依赖 DRD 来执行所有组件和逻辑，从而产生一个大型而复杂的图表。

   图 6.51. loan prequalification single DRD

   

   另外，按照此流程中的步骤，您可以将此示例 DRD 划分为多个嵌套的 DRD 来更好地组织决策要求，如下例所示：

   图 6.52. loan prequalification 多嵌套 DRD

   

   图 6.53. 前端比例 DRD 概述

   

   图 6.54. DRD 用于前端比例

   

   图 6.55. 贡献评级 DRD 概述

   

   图 6.56. 得分评级的 DRD

   

   图 6.57. 后端比例 DRD 概述

   

   图 6.58. DRD 作为后端比例

   

流程

1. 在客户端应用程序中，将以下依赖项添加到 Java 项目的相关类路径中：

   <!-- Required for the DMN runtime API -->
   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-dmn-core</artifactId>
     <version>${rhpam.version}</version>
   </dependency>
   
   <!-- Required if not using classpath KIE container -->
   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-ci</artifactId>
     <version>${rhpam.version}</version>
   </dependency>

   & lt;version > 是项目中当前使用的 Red Hat Process Automation Manager 的 Maven 工件版本（例如 7.67.0.Final-redhat-00024）。

   注意

   考虑将 Red Hat Business Automation 材料清单(BOM)依赖项添加到项目 pom.xml 文件，而不是为每个依赖项指定 Red Hat Process Automation Manager < version >。Red Hat Business Automation BOM 适用于 Red Hat Decision Manager 和 Red Hat Process Automation Manager。添加 BOM 文件时，项目中包含来自提供的 Maven 存储库的正确依赖项版本。

   BOM 依赖项示例：

   <dependency>
     <groupId>com.redhat.ba</groupId>
     <artifactId>ba-platform-bom</artifactId>
     <version>7.13.5.redhat-00002</version>
     <scope>import</scope>
     <type>pom</type>
   </dependency>

   有关 Red Hat Business Automation BOM 的更多信息，请参阅 RHPAM 产品与 maven 库版本之间的映射是什么？

2. 从 类路径 或 ReleaseId 创建 KIE 容器：

   KieServices kieServices = KieServices.Factory.get();
   
   ReleaseId releaseId = kieServices.newReleaseId( "org.acme", "my-kjar", "1.0.0" );
   KieContainer kieContainer = kieServices.newKieContainer( releaseId );

   备选选项：

   KieServices kieServices = KieServices.Factory.get();
   
   KieContainer kieContainer = kieServices.getKieClasspathContainer();

3. 使用模型 命名空间和 modelName 从 KIE 容器获取 DMNRuntime 并对 DMN 模型的引用：

   DMNRuntime dmnRuntime = KieRuntimeFactory.of(kieContainer.getKieBase()).get(DMNRuntime.class);
   
   String namespace = "http://www.redhat.com/_c7328033-c355-43cd-b616-0aceef80e52a";
   String modelName = "dmn-movieticket-ageclassification";
   
   DMNModel dmnModel = dmnRuntime.getModel(namespace, modelName);

4. 为所需模型执行决策服务：

   DMNContext dmnContext = dmnRuntime.newContext();  1
   
   for (Integer age : Arrays.asList(1,12,13,64,65,66)) {
       dmnContext.set("Age", age);  2
       DMNResult dmnResult =
           dmnRuntime.evaluateAll(dmnModel, dmnContext);  3
   
       for (DMNDecisionResult dr : dmnResult.getDecisionResults()) {  4
           log.info("Age: " + age + ", " +
                    "Decision: '" + dr.getDecisionName() + "', " +
                    "Result: " + dr.getResult());
     }
   }

   1

   实例化新的 DMN 上下文，作为模型评估的输入。请注意，本例多次通过 Age 类决策进行循环。

   2

   为输入 DMN 上下文分配输入变量。

   3

   评估 DMN 模型中定义的所有 DMN 决策。

   4

   每个评估可能会产生一个或多个结果，从而创建循环。

   这个示例输出如下：

   Age 1 Decision 'AgeClassification' : Child
   Age 12 Decision 'AgeClassification' : Child
   Age 13 Decision 'AgeClassification' : Adult
   Age 64 Decision 'AgeClassification' : Adult
   Age 65 Decision 'AgeClassification' : Senior
   Age 66 Decision 'AgeClassification' : Senior

   如果之前未编译 DMN 模型作为可执行模型以便更有效的执行，您可以在执行 DMN 模型时启用以下属性：

   -Dorg.kie.dmn.compiler.execmodel=true

流程

1. 在客户端应用程序中，将以下依赖项添加到 Java 项目的相关类路径中：

   <!-- Required for the KIE Server Java client API -->
   <dependency>
     <groupId>org.kie.server</groupId>
     <artifactId>kie-server-client</artifactId>
     <version>${rhpam.version}</version>
   </dependency>

   & lt;version > 是项目中当前使用的 Red Hat Process Automation Manager 的 Maven 工件版本（例如 7.67.0.Final-redhat-00024）。

   注意

   考虑将 Red Hat Business Automation 材料清单(BOM)依赖项添加到项目 pom.xml 文件，而不是为每个依赖项指定 Red Hat Process Automation Manager < version >。Red Hat Business Automation BOM 适用于 Red Hat Decision Manager 和 Red Hat Process Automation Manager。添加 BOM 文件时，项目中包含来自提供的 Maven 存储库的正确依赖项版本。

   BOM 依赖项示例：

   <dependency>
     <groupId>com.redhat.ba</groupId>
     <artifactId>ba-platform-bom</artifactId>
     <version>7.13.5.redhat-00002</version>
     <scope>import</scope>
     <type>pom</type>
   </dependency>

   有关 Red Hat Business Automation BOM 的更多信息，请参阅 RHPAM 产品与 maven 库版本之间的映射是什么？

2. 使用适当的连接信息实例化 KieServicesClient 实例。

   例如：

   KieServicesConfiguration conf =
       KieServicesFactory.newRestConfiguration(URL, USER, PASSWORD); 1
   
   conf.setMarshallingFormat(MarshallingFormat.JSON);  2
   
   KieServicesClient kieServicesClient = KieServicesFactory.newKieServicesClient(conf);

   1

   连接信息：

   • URL 示例 ：http://localhost:8080/kie-server/services/rest/server
   • 该凭据应当引用具有 kie-server 角色的用户。

   2

   Marshalling 格式是一个 org.kie.server.api.marshalling.MarshallingFormat 的实例。它控制消息是 JSON 还是 XML。Marshalling 格式的选项为 JSON、JAXB 或 XSTREAM。

3. 通过调用 KIE 服务器 Java 客户端上的方法 getServicesClient（） 从连接到相关 KIE 服务器 Java 客户端的 KIE 服务器 Java 客户端获取 DMNServicesClient Client：

   DMNServicesClient dmnClient = kieServicesClient.getServicesClient(DMNServicesClient.class );

   dmnClient 现在可在 KIE 服务器上执行决策服务。

4. 为所需模型执行决策服务。

   例如：

   for (Integer age : Arrays.asList(1,12,13,64,65,66)) {
       DMNContext dmnContext = dmnClient.newContext(); 1
       dmnContext.set("Age", age);  2
       ServiceResponse<DMNResult> serverResp =   3
           dmnClient.evaluateAll($kieContainerId,
                                 $modelNamespace,
                                 $modelName,
                                 dmnContext);
   
       DMNResult dmnResult = serverResp.getResult();  4
       for (DMNDecisionResult dr : dmnResult.getDecisionResults()) {
           log.info("Age: " + age + ", " +
                    "Decision: '" + dr.getDecisionName() + "', " +
                    "Result: " + dr.getResult());
       }
   }

   1

   实例化新的 DMN 上下文，作为模型评估的输入。请注意，本例多次通过 Age 类决策进行循环。

   2

   为输入 DMN 上下文分配输入变量。

   3

   评估 DMN 模型中定义的所有 DMN 决策：

   • $kieContainerId 是部署了包含 DMN 模型的 KJAR 的容器的 ID
   • $modelNamespace 是型号的命名空间。
   • $modelName 是模型的名称。

   4

   DMN Result 对象可从服务器响应中获得。

   此时，dmnResult 包含所评估的 DMN 模型中的所有决定结果。

   您还可以使用 DMNServicesClient 的替代方法，在模型中仅执行特定的 DMN 决策。

   注意

   如果 KIE 容器仅包含一个 DMN 模型，您可以省略 $modelNamespace 和 $modelName，因为 KIE Server API 会默认选择它。

流程

1. 确定用于访问 KIE 服务器 REST API 端点的基础 URL。这需要了解以下值（使用默认本地部署值作为示例）：

   • 主机（本地主机）
   • 端口(8080)
   • 根上下文(kie-server)
   • 基本 REST 路径(services/rest/)

   本地部署中的基本 URL 示例：

   http://localhost:8080/kie-server/services/rest/

2. 确定用户身份验证要求。

   当在 KIE 服务器配置中直接定义用户时，使用 HTTP 基本身份验证并需要用户名和密码。成功请求需要该用户具有 kie-server 角色。

   以下示例演示了如何在 curl 请求中添加凭证：

   curl -u username:password <request>

   如果使用 Red Hat Single Sign-On 配置 KIE 服务器，则请求必须包含 bearer 令牌：

   curl -H "Authorization: bearer $TOKEN" <request>

3. 指定请求和响应的格式。REST API 端点同时使用 JSON 和 XML 格式，并使用请求标头来设置：

   JSON

   curl -H "accept: application/json" -H "content-type: application/json"

   XML

   curl -H "accept: application/xml" -H "content-type: application/xml"

4. 可选：查询容器以获取部署的决策模型列表：

   [GET] server/containers/{containerId}/dmn

   curl 请求示例：

   curl -u krisv:krisv -H "accept: application/xml" -X GET "http://localhost:8080/kie-server/services/rest/server/containers/MovieDMNContainer/dmn"

   XML 输出示例：

   <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
   <response type="SUCCESS" msg="OK models successfully retrieved from container 'MovieDMNContainer'">
       <dmn-model-info-list>
           <model>
               <model-namespace>http://www.redhat.com/_c7328033-c355-43cd-b616-0aceef80e52a</model-namespace>
               <model-name>dmn-movieticket-ageclassification</model-name>
               <model-id>_99</model-id>
               <decisions>
                   <dmn-decision-info>
                       <decision-id>_3</decision-id>
                       <decision-name>AgeClassification</decision-name>
                   </dmn-decision-info>
               </decisions>
           </model>
       </dmn-model-info-list>
   </response>

   JSON 输出示例：

   {
     "type" : "SUCCESS",
     "msg" : "OK models successfully retrieved from container 'MovieDMNContainer'",
     "result" : {
       "dmn-model-info-list" : {
         "models" : [ {
           "model-namespace" : "http://www.redhat.com/_c7328033-c355-43cd-b616-0aceef80e52a",
           "model-name" : "dmn-movieticket-ageclassification",
           "model-id" : "_99",
           "decisions" : [ {
             "decision-id" : "_3",
             "decision-name" : "AgeClassification"
           } ]
         } ]
       }
     }
   }

5. 执行模型：

   [POST] server/containers/{containerId}/dmn

   curl 请求示例：

   curl -u krisv:krisv -H "accept: application/json" -H "content-type: application/json" -X POST "http://localhost:8080/kie-server/services/rest/server/containers/MovieDMNContainer/dmn" -d "{ \"model-namespace\" : \"http://www.redhat.com/_c7328033-c355-43cd-b616-0aceef80e52a\", \"model-name\" : \"dmn-movieticket-ageclassification\", \"decision-name\" : [ ], \"decision-id\" : [ ], \"dmn-context\" : {\"Age\" : 66}}"

   JSON 请求示例：

   {
     "model-namespace" : "http://www.redhat.com/_c7328033-c355-43cd-b616-0aceef80e52a",
     "model-name" : "dmn-movieticket-ageclassification",
     "decision-name" : [ ],
     "decision-id" : [ ],
     "dmn-context" : {"Age" : 66}
   }

   XML 请求示例（JAXB 格式）：

   <?xml version="1.0" encoding="UTF-8"?>
   <dmn-evaluation-context>
       <model-namespace>http://www.redhat.com/_c7328033-c355-43cd-b616-0aceef80e52a</model-namespace>
       <model-name>dmn-movieticket-ageclassification</model-name>
       <dmn-context xsi:type="jaxbListWrapper" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
           <type>MAP</type>
           <element xsi:type="jaxbStringObjectPair" key="Age">
               <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">66</value>
           </element>
       </dmn-context>
   </dmn-evaluation-context>

   注意

   无论请求格式如何，请求都需要以下元素：

   • 型号命名空间
   • 型号名称
   • 包含输入值的上下文对象

   JSON 响应示例：

   {
     "type" : "SUCCESS",
     "msg" : "OK from container 'MovieDMNContainer'",
     "result" : {
       "dmn-evaluation-result" : {
         "messages" : [ ],
         "model-namespace" : "http://www.redhat.com/_c7328033-c355-43cd-b616-0aceef80e52a",
         "model-name" : "dmn-movieticket-ageclassification",
         "decision-name" : [ ],
         "dmn-context" : {
           "Age" : 66,
           "AgeClassification" : "Senior"
         },
         "decision-results" : {
           "_3" : {
             "messages" : [ ],
             "decision-id" : "_3",
             "decision-name" : "AgeClassification",
             "result" : "Senior",
             "status" : "SUCCEEDED"
           }
         }
       }
     }
   }

   XML（JAXB 格式）响应示例：

   <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
   <response type="SUCCESS" msg="OK from container 'MovieDMNContainer'">
         <dmn-evaluation-result>
               <model-namespace>http://www.redhat.com/_c7328033-c355-43cd-b616-0aceef80e52a</model-namespace>
               <model-name>dmn-movieticket-ageclassification</model-name>
               <dmn-context xsi:type="jaxbListWrapper" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
                     <type>MAP</type>
                     <element xsi:type="jaxbStringObjectPair" key="Age">
                           <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">66</value>
                     </element>
                     <element xsi:type="jaxbStringObjectPair" key="AgeClassification">
                           <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">Senior</value>
                     </element>
               </dmn-context>
               <messages/>
               <decisionResults>
                     <entry>
                           <key>_3</key>
                           <value>
                                 <decision-id>_3</decision-id>
                                 <decision-name>AgeClassification</decision-name>
                                 <result xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Senior</result>
                                 <messages/>
                                 <status>SUCCEEDED</status>
                           </value>
                     </entry>
               </decisionResults>
         </dmn-evaluation-result>
   </response>

流程

1. 在客户端应用程序中，将以下依赖项添加到 Java 项目的相关类路径中：

   <!-- Required for the PMML compiler -->
   <dependency>
     <groupId>org.drools</groupId>
     <artifactId>kie-pmml-dependencies</artifactId>
     <version>${rhpam.version}</version>
   </dependency>
   
   <!-- Required for the KIE public API -->
   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-api</artifactId>
     <version>${rhpam.version}</version>
   </dependencies>
   
   <!-- Required if not using classpath KIE container -->
   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-ci</artifactId>
     <version>${rhpam.version}</version>
   </dependency>

   & lt;version > 是项目中当前使用的 Red Hat Process Automation Manager 的 Maven 工件版本（例如 7.67.0.Final-redhat-00024）。

   注意

   考虑将 Red Hat Business Automation 材料清单(BOM)依赖项添加到项目 pom.xml 文件，而不是为每个依赖项指定 Red Hat Process Automation Manager < version >。Red Hat Business Automation BOM 适用于 Red Hat Decision Manager 和 Red Hat Process Automation Manager。添加 BOM 文件时，项目中包含来自提供的 Maven 存储库的正确依赖项版本。

   BOM 依赖项示例：

   <dependency>
     <groupId>com.redhat.ba</groupId>
     <artifactId>ba-platform-bom</artifactId>
     <version>7.13.5.redhat-00002</version>
     <scope>import</scope>
     <type>pom</type>
   </dependency>

   有关 Red Hat Business Automation BOM 的更多信息，请参阅 RHPAM 产品与 maven 库版本之间的映射是什么？

2. 从 类路径 或 ReleaseId 创建 KIE 容器：

   KieServices kieServices = KieServices.Factory.get();
   
   ReleaseId releaseId = kieServices.newReleaseId( "org.acme", "my-kjar", "1.0.0" );
   KieContainer kieContainer = kieServices.newKieContainer( releaseId );

   备选选项：

   KieServices kieServices = KieServices.Factory.get();
   
   KieContainer kieContainer = kieServices.getKieClasspathContainer();

3. 创建用于执行模型的 PMMLRuntime 实例：

   PMMLRuntime pmmlRuntime = KieRuntimeFactory.of(kieContainer.getKieBase()).get(PMMLRuntime.class);

4. 创建一个 PMMLRequestData 类实例，将 PMML 模型应用到数据集：

   PMMLRequestData pmmlRequestData = new PMMLRequestData({correlation_id}, {model_name});
   pmmlRequestData.addRequestParam({parameter_name}, {parameter_value})
   ...

5. 创建包含输入数据的 PMMLContext 类的实例：

   PMMLContext pmmlContext = new PMMLContextImpl(pmmlRequestData);

6. 在使用您创建的所需的 PMML 类实例执行 PMML 模型时，检索 PMML4Result ：

   PMML4Result pmml4Result = pmmlRuntime.evaluate({model_name}, pmmlContext);

流程

1. 在客户端应用程序中，将以下依赖项添加到 Java 项目的相关类路径中：

   <!-- Required for the PMML compiler -->
   <dependency>
     <groupId>org.drools</groupId>
     <artifactId>kie-pmml</artifactId>
     <version>${rhpam.version}</version>
   </dependency>
   
   <!-- Required for the KIE public API -->
   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-api</artifactId>
     <version>${rhpam.version}</version>
   </dependencies>
   
   <!-- Required if not using classpath KIE container -->
   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-ci</artifactId>
     <version>${rhpam.version}</version>
   </dependency>

   & lt;version > 是项目中当前使用的 Red Hat Process Automation Manager 的 Maven 工件版本（例如 7.67.0.Final-redhat-00024）。

   注意

   考虑将 Red Hat Business Automation 材料清单(BOM)依赖项添加到项目 pom.xml 文件，而不是为每个依赖项指定 Red Hat Process Automation Manager < version >。Red Hat Business Automation BOM 适用于 Red Hat Decision Manager 和 Red Hat Process Automation Manager。添加 BOM 文件时，项目中包含来自提供的 Maven 存储库的正确依赖项版本。

   BOM 依赖项示例：

   <dependency>
     <groupId>com.redhat.ba</groupId>
     <artifactId>ba-platform-bom</artifactId>
     <version>7.13.5.redhat-00002</version>
     <scope>import</scope>
     <type>pom</type>
   </dependency>

   有关 Red Hat Business Automation BOM 的更多信息，请参阅 RHPAM 产品与 maven 库版本之间的映射是什么？

   重要

   要使用传统实施，请确保将 kie-pmml-ement ation 系统属性设置为 legacy。

2. 从 类路径 或 ReleaseId 创建 KIE 容器：

   KieServices kieServices = KieServices.Factory.get();
   
   ReleaseId releaseId = kieServices.newReleaseId( "org.acme", "my-kjar", "1.0.0" );
   KieContainer kieContainer = kieServices.newKieContainer( releaseId );

   备选选项：

   KieServices kieServices = KieServices.Factory.get();
   
   KieContainer kieContainer = kieServices.getKieClasspathContainer();

3. 创建 PMMLRequestData 类的实例，它将您的 PMML 模型应用于一组数据：

   public class PMMLRequestData {
       private String correlationId; 1
       private String modelName; 2
       private String source; 3
       private List<ParameterInfo<?>> requestParams; 4
       ...
   }

   1

   标识与特定请求或结果关联的数据

   2

   应该应用到请求数据的模型名称

   3

   由内部生成的 PMMLRequestData 对象用来识别生成请求的片段

   4

   发送输入数据点的默认机制

4. 创建 PMML4Result 类的实例，其中包含将 PMML 的规则应用到输入数据的输出信息：

   public class PMML4Result {
       private String correlationId;
       private String segmentationId; 1
       private String segmentId; 2
       private int segmentIndex; 3
       private String resultCode; 4
       private Map<String, Object> resultVariables; 5
       ...
   }

   1

   当模型类型为 MiningModel 时使用。segmentationId 用于区分多个分段。

   2

   与 segmentationId 结合使用来识别生成结果的片段。

   3

   用于维护网段的顺序。

   4

   用于确定模型是否已成功应用，其中 OK 指示成功。

   5

   包含结果变量的名称及其关联的值。

   除了普通的 getter 方法外，M PMML4Result 类还支持以下方法直接检索结果变量的值：

   public <T> Optional<T> getResultValue(String objName, String objField, Class<T> clazz, Object...params)
   
   public Object getResultValue(String objName, String objField, Object...params)

5. 创建 ParameterInfo 类的实例，作为作为 PMMLRequestData 类一部分的基本数据类型对象的打包程序：

   public class ParameterInfo<T> { 1
       private String correlationId;
       private String name; 2
       private String capitalizedName;
       private Class<T> type; 3
       private T value; 4
       ...
   }

   1

   参数化类来处理许多不同的类型

   2

   预期作为型号输入的变量名称

   3

   是变量的实际类型的类

   4

   变量的实际值

6. 根据您创建的所需的 PMML 类实例执行 PMML 模型：

   public void executeModel(KieBase kbase,
                            Map<String,Object> variables,
                            String modelName,
                            String correlationId,
                            String modelPkgName) {
       RuleUnitExecutor executor = RuleUnitExecutor.create().bind(kbase);
       PMMLRequestData request = new PMMLRequestData(correlationId, modelName);
       PMML4Result resultHolder = new PMML4Result(correlationId);
       variables.entrySet().forEach( es -> {
           request.addRequestParam(es.getKey(), es.getValue());
       });
   
       DataSource<PMMLRequestData> requestData = executor.newDataSource("request");
       DataSource<PMML4Result> resultData = executor.newDataSource("results");
       DataSource<PMMLData> internalData = executor.newDataSource("pmmlData");
   
       requestData.insert(request);
       resultData.insert(resultHolder);
   
       List<String> possiblePackageNames = calculatePossiblePackageNames(modelName,
                                                                       modelPkgName);
       Class<? extends RuleUnit> ruleUnitClass = getStartingRuleUnit("RuleUnitIndicator",
                                                                   (InternalKnowledgeBase)kbase,
                                                                   possiblePackageNames);
   
       if (ruleUnitClass != null) {
           executor.run(ruleUnitClass);
           if ( "OK".equals(resultHolder.getResultCode()) ) {
             // extract result variables here
           }
       }
   }
   
   protected Class<? extends RuleUnit> getStartingRuleUnit(String startingRule, InternalKnowledgeBase ikb, List<String> possiblePackages) {
       RuleUnitRegistry unitRegistry = ikb.getRuleUnitRegistry();
       Map<String,InternalKnowledgePackage> pkgs = ikb.getPackagesMap();
       RuleImpl ruleImpl = null;
       for (String pkgName: possiblePackages) {
         if (pkgs.containsKey(pkgName)) {
             InternalKnowledgePackage pkg = pkgs.get(pkgName);
             ruleImpl = pkg.getRule(startingRule);
             if (ruleImpl != null) {
                 RuleUnitDescr descr = unitRegistry.getRuleUnitFor(ruleImpl).orElse(null);
                 if (descr != null) {
                     return descr.getRuleUnitClass();
                 }
             }
         }
       }
       return null;
   }
   
   protected List<String> calculatePossiblePackageNames(String modelId, String...knownPackageNames) {
       List<String> packageNames = new ArrayList<>();
       String javaModelId = modelId.replaceAll("\\s","");
       if (knownPackageNames != null && knownPackageNames.length > 0) {
           for (String knownPkgName: knownPackageNames) {
               packageNames.add(knownPkgName + "." + javaModelId);
           }
       }
       String basePkgName = PMML4UnitImpl.DEFAULT_ROOT_PACKAGE+"."+javaModelId;
       packageNames.add(basePkgName);
       return packageNames;
   }

   规则由 RuleUnitExecutor 类执行。RuleUnitExecutor 类将创建 KIE 会话并将所需的 DataSource 对象添加到这些会话，然后基于 RuleUnit 来执行规则，后者作为参数传递到 run（） 方法。calculatePossiblePackageNames 和 getStartingRuleUnit 方法决定了传递给 run（） 方法的 RuleUnit 类的完全限定名称。

流程

1. 在客户端应用程序中，将以下依赖项添加到 Java 项目的相关类路径中：

   传统实现示例

   <!-- Required for the PMML compiler -->
   <dependency>
     <groupId>org.drools</groupId>
     <artifactId>kie-pmml</artifactId>
     <version>${rhpam.version}</version>
   </dependency>
   
   <!-- Required for the KIE public API -->
   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-api</artifactId>
     <version>${rhpam.version}</version>
   </dependencies>
   
   <!-- Required for the KIE Server Java client API -->
   <dependency>
     <groupId>org.kie.server</groupId>
     <artifactId>kie-server-client</artifactId>
     <version>${rhpam.version}</version>
   </dependency>
   
   <!-- Required if not using classpath KIE container -->
   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-ci</artifactId>
     <version>${rhpam.version}</version>
   </dependency>

   重要

   要使用传统实施，请确保将 kie-pmml-ement ation 系统属性设置为 legacy。

   信任实施示例

   <!-- Required for the PMML compiler -->
   <dependency>
     <groupId>org.drools</groupId>
     <artifactId>kie-pmml-dependencies</artifactId>
     <version>${rhpam.version}</version>
   </dependency>
   
   <!-- Required for the KIE public API -->
   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-api</artifactId>
     <version>${rhpam.version}</version>
   </dependencies>
   
   <!-- Required for the KIE Server Java client API -->
   <dependency>
     <groupId>org.kie.server</groupId>
     <artifactId>kie-server-client</artifactId>
     <version>${rhpam.version}</version>
   </dependency>
   
   <!-- Required if not using classpath KIE container -->
   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-ci</artifactId>
     <version>${rhpam.version}</version>
   </dependency>

   & lt;version > 是项目中当前使用的 Red Hat Process Automation Manager 的 Maven 工件版本（例如 7.67.0.Final-redhat-00024）。

   注意

   考虑将 Red Hat Business Automation 材料清单(BOM)依赖项添加到项目 pom.xml 文件，而不是为每个依赖项指定 Red Hat Process Automation Manager < version >。Red Hat Business Automation BOM 适用于 Red Hat Decision Manager 和 Red Hat Process Automation Manager。添加 BOM 文件时，项目中包含来自提供的 Maven 存储库的正确依赖项版本。

   BOM 依赖项示例：

   <dependency>
     <groupId>com.redhat.ba</groupId>
     <artifactId>ba-platform-bom</artifactId>
     <version>7.13.5.redhat-00002</version>
     <scope>import</scope>
     <type>pom</type>
   </dependency>

   有关 Red Hat Business Automation BOM 的更多信息，请参阅 RHPAM 产品与 maven 库版本之间的映射是什么？

2. 从 类路径 或 ReleaseId 创建 KIE 容器：

   KieServices kieServices = KieServices.Factory.get();
   
   ReleaseId releaseId = kieServices.newReleaseId( "org.acme", "my-kjar", "1.0.0" );
   KieContainer kieContainer = kieServices.newKieContainer( releaseId );

   备选选项：

   KieServices kieServices = KieServices.Factory.get();
   
   KieContainer kieContainer = kieServices.getKieClasspathContainer();

3. 创建一个类来向 KIE 服务器发送请求并接收响应：

   public class ApplyScorecardModel {
     private static final ReleaseId releaseId =
             new ReleaseId("org.acme","my-kjar","1.0.0");
     private static final String containerId = "SampleModelContainer";
     private static KieCommands commandFactory;
     private static ClassLoader kjarClassLoader; 1
     private RuleServicesClient serviceClient; 2
   
     // Attributes specific to your class instance
     private String rankedFirstCode;
     private Double score;
   
     // Initialization of non-final static attributes
     static {
       commandFactory = KieServices.Factory.get().getCommands();
   
       // Specifications for kjarClassLoader, if used
       KieMavenRepository kmp = KieMavenRepository.getMavenRepository();
       File artifactFile = kmp.resolveArtifact(releaseId).getFile();
       if (artifactFile != null) {
         URL urls[] = new URL[1];
         try {
           urls[0] = artifactFile.toURI().toURL();
           classLoader = new KieURLClassLoader(urls,PMML4Result.class.getClassLoader());
         } catch (MalformedURLException e) {
           logger.error("Error getting classLoader for "+containerId);
           logger.error(e.getMessage());
         }
       } else {
         logger.warn("Did not find the artifact file for "+releaseId.toString());
       }
     }
   
     public ApplyScorecardModel(KieServicesConfiguration kieConfig) {
       KieServicesClient clientFactory = KieServicesFactory.newKieServicesClient(kieConfig);
       serviceClient = clientFactory.getServicesClient(RuleServicesClient.class);
     }
     ...
     // Getters and setters
     ...
   
     // Method for executing the PMML model on KIE Server
     public void applyModel(String occupation, int age) {
       PMMLRequestData input = new PMMLRequestData("1234","SampleModelName"); 3
       input.addRequestParam(new ParameterInfo("1234","occupation",String.class,occupation));
       input.addRequestParam(new ParameterInfo("1234","age",Integer.class,age));
   
       CommandFactoryServiceImpl cf = (CommandFactoryServiceImpl)commandFactory;
       ApplyPmmlModelCommand command = (ApplyPmmlModelCommand) cf.newApplyPmmlModel(request); 4
   
       ServiceResponse<ExecutionResults> results =
           ruleClient.executeCommandsWithResults(CONTAINER_ID, command); 5
   
       if (results != null) {  6
         PMML4Result resultHolder = (PMML4Result)results.getResult().getValue("results");
         if (resultHolder != null && "OK".equals(resultHolder.getResultCode())) {
           this.score = resultHolder.getResultValue("ScoreCard","score",Double.class).get();
           Map<String,Object> rankingMap =
                (Map<String,Object>)resultHolder.getResultValue("ScoreCard","ranking");
           if (rankingMap != null && !rankingMap.isEmpty()) {
             this.rankedFirstCode = rankingMap.keySet().iterator().next();
           }
         }
       }
     }
   }

   1

   如果您没有在客户端项目依赖项中包含 KJAR，请定义类加载程序

   2

   标识配置设置中定义的服务客户端，包括 KIE 服务器 REST API 访问凭证

   3

   初始化 PMMLRequestData 对象

   4

   创建 ApplyPmmlModelCommand的实例

   5

   使用服务客户端发送命令

   6

   检索执行的 PMML 模型的结果

4. 执行类实例，以将 PMML 调用请求发送到 KIE 服务器。

   或者，也可以使用 JMS 和 REST 接口将 ApplyPmmlModelCommand 命令发送到 KIE 服务器。对于 REST 请求，您可以使用 ApplyPmmlModelCommand 命令作为 JSON、JAXB 或 XStream 请求格式的 POST 请求。

   POST 端点示例

   http://localhost:8080/kie-server/services/rest/server/containers/instances/SampleModelContainer

   JSON 请求正文示例

   {
     "commands": [ {
         "apply-pmml-model-command": {
           "outIdentifier": null,
           "packageName": null,
           "hasMining": false,
           "requestData": {
             "correlationId": "123",
             "modelName": "SimpleScorecard",
             "source": null,
             "requestParams": [
               {
                 "correlationId": "123",
                 "name": "param1",
                 "type": "java.lang.Double",
                 "value": "10.0"
               },
               {
                 "correlationId": "123",
                 "name": "param2",
                 "type": "java.lang.Double",
                 "value": "15.0"
               }
             ]
           }
         }
       }
     ]
   }

   使用端点和正文的 curl 请求示例

   curl -X POST "http://localhost:8080/kie-server/services/rest/server/containers/instances/SampleModelContainer" -H "accept: application/json" -H "content-type: application/json" -d "{ \"commands\": [ { \"apply-pmml-model-command\": { \"outIdentifier\": null, \"packageName\": null, \"hasMining\": false, \"requestData\": { \"correlationId\": \"123\", \"modelName\": \"SimpleScorecard\", \"source\": null, \"requestParams\": [ { \"correlationId\": \"123\", \"name\": \"param1\", \"type\": \"java.lang.Double\", \"value\": \"10.0\" }, { \"correlationId\": \"123\", \"name\": \"param2\", \"type\": \"java.lang.Double\", \"value\": \"15.0\" } ] } } } ]}"

   JSON 响应示例

   {
     "results" : [ {
       "value" : {"org.kie.api.pmml.DoubleFieldOutput":{
     "value" : 40.8,
     "correlationId" : "123",
     "segmentationId" : null,
     "segmentId" : null,
     "name" : "OverallScore",
     "displayValue" : "OverallScore",
     "weight" : 1.0
   }},
       "key" : "OverallScore"
     }, {
       "value" : {"org.kie.api.pmml.PMML4Result":{
     "resultVariables" : {
       "OverallScore" : {
         "value" : 40.8,
         "correlationId" : "123",
         "segmentationId" : null,
         "segmentId" : null,
         "name" : "OverallScore",
         "displayValue" : "OverallScore",
         "weight" : 1.0
       },
       "ScoreCard" : {
         "modelName" : "SimpleScorecard",
         "score" : 40.8,
         "holder" : {
           "modelName" : "SimpleScorecard",
           "correlationId" : "123",
           "voverallScore" : null,
           "moverallScore" : true,
           "vparam1" : 10.0,
           "mparam1" : false,
           "vparam2" : 15.0,
           "mparam2" : false
         },
         "enableRC" : true,
         "pointsBelow" : true,
         "ranking" : {
           "reasonCh1" : 5.0,
           "reasonCh2" : -6.0
         }
       }
     },
     "correlationId" : "123",
     "segmentationId" : null,
     "segmentId" : null,
     "segmentIndex" : 0,
     "resultCode" : "OK",
     "resultObjectName" : null
   }},
       "key" : "results"
     } ],
     "facts" : [ ]
   }