Issue Multi-Root Insurance Policy Action

This action is available in API version 66.0 and later.

Supported REST HTTP Methods

URI

/services/data/v66.0/actions/standard/issueMultiRootInsurancePolicy

Formats

JSON, XML

HTTP Methods

POST

Authentication

Authorization: Bearertoken

Inputs

Outputs

Example

POST

This sample request is for the Issue Multi-Root Insurance Policy action.

1{
2  "inputs": [
3    {
4      "issueMultiRootPolicyInputRep": {
5        "contextId": "c98a08a0a9725b7a7d42c35d02e49d80c77a5aae4ea687b0bf09a7997d2af3d3",
6        "insurancePolicy": {
7          "policyName": "Test Auto Ins policy Via REST",
8          "policyNumber": "PLC5678987",
9          "effectiveFromDate": "2024-01-01",
10          "effectiveToDate": "2024-12-31",
11          "referencePolicyNumber": "1011"
12        },
13        "transactionRecord": {
14          "name": "Sold Policy Transaction"
15        },
16        "additionalInput": [
17          {
18            "instanceKey": "AutoBundle2",
19            "additionalFieldsList": [
20              {
21                "key": "AssetDescription__c",
22                "value": "Test_AssetDescription__c"
23              },
24              {
25                "key": "SourceSystem",
26                "value": "Test_SourceSystem"
27              }
28            ]
29          },
30          {
31            "instanceKey": "AutoDriver",
32            "additionalFieldsList": [
33              {
34                "key": "ParticipantName",
35                "value": "Test_ParticipantName"
36              },
37              {
38                "key": "Participant_Hometown__c",
39                "value": "Test_Participant_Hometown__c"
40              }
41            ]
42          },
43          {
44            "instanceKey": "AutoRoot",
45            "additionalFieldsList": [
46              {
47                "key": "Primary_Policy_Holder__c",
48                "value": "Test_Primary_Policy_Holder__c"
49              },
50              {
51                "key": "PolicyDescription",
52                "value": "Test_PolicyDescription"
53              }
54            ]
55          },
56          {
57            "instanceKey": "AutoBundle2_AutoComp1",
58            "additionalFieldsList": [
59              {
60                "key": "Coverage_Description__c",
61                "value": "Test_Coverage_Description__c"
62              },
63              {
64                "key": "Description",
65                "value": "Test_Description"
66              }
67            ]
68          }
69        ]
70      }
71    }
72  ]
73}

This is a sample code to call the Issue Multi-Root Insurance Policy action from Apex.

1public with sharing class MultiRootPolicyIssuanceInvocable {
2    
3    /**
4     * Execute Multi-Root Policy Issuance with parameters map
5     * Usage: MultiRootPolicyIssuanceInvocable.executeMultiRootIssuance(paramsMap);
6     * 
7     * @param params Map of parameters:
8     *   - contextId (String, REQUIRED)
9     *   - policyName (String, optional)
10     *   - policyNumber (String, optional)
11     *   - referencePolicyNumber (String, optional)
12     *   - effectiveFromDate (String, optional)
13     *   - effectiveToDate (String, optional)
14     *   - transactionName (String, optional)
15     *   - additionalFields (Map<String, Map<String, String>>, optional)
16     */
17    public static void executeMultiRootIssuance(Map<String, Object> params) {
18        // Extract and validate contextId (REQUIRED)
19        String contextId = (String) params.get('contextId');
20        if (String.isBlank(contextId)) {
21            System.debug('ERROR: contextId is required');
22            return;
23        }
24        
25        // Multi-Root Issue Policy IA - Create the standard Invocable Action
26        Invocable.Action action = Invocable.Action.createStandardAction('issueMultiRootInsurancePolicy');
27        
28        // Instantiate the IA input object for Multi-Root Policy Issuance
29        // IMPORTANT: Use IssueMultiRootPolicyInputRep, NOT IssuePolicyIAInputRep
30        ConnectApi.IssueMultiRootPolicyInputRep policyInput = 
31            new ConnectApi.IssueMultiRootPolicyInputRep();
32        
33        // Set context ID (REQUIRED)
34        policyInput.contextId = contextId;
35        
36        // Extract optional parameters
37        String policyName = (String) params.get('policyName');
38        String policyNumber = (String) params.get('policyNumber');
39        String referencePolicyNumber = (String) params.get('referencePolicyNumber');
40        String effectiveFromDate = (String) params.get('effectiveFromDate');
41        String effectiveToDate = (String) params.get('effectiveToDate');
42        String transactionName = (String) params.get('transactionName');
43        Map<String, Map<String, String>> additionalFields = 
44            (Map<String, Map<String, String>>) params.get('additionalFields');
45        
46        // Populate Insurance Policy details (using IA classes) - all optional
47        if (!String.isBlank(policyName) || !String.isBlank(policyNumber) || 
48            !String.isBlank(referencePolicyNumber) || !String.isBlank(effectiveFromDate) || 
49            !String.isBlank(effectiveToDate)) {
50            
51            ConnectApi.InsPolicyIAInputRep insurancePolicy = 
52                new ConnectApi.InsPolicyIAInputRep();
53            
54            if (!String.isBlank(policyName)) {
55                insurancePolicy.policyName = policyName;
56            }
57            if (!String.isBlank(policyNumber)) {
58                insurancePolicy.policyNumber = policyNumber;
59            }
60            if (!String.isBlank(referencePolicyNumber)) {
61                insurancePolicy.referencePolicyNumber = referencePolicyNumber;
62            }
63            if (!String.isBlank(effectiveFromDate)) {
64                insurancePolicy.effectiveFromDate = effectiveFromDate;
65            }
66            if (!String.isBlank(effectiveToDate)) {
67                insurancePolicy.effectiveToDate = effectiveToDate;
68            }
69            
70            policyInput.insurancePolicy = insurancePolicy;
71        }
72        
73        // Populate Transaction record (using IA transaction representation) - optional
74        if (!String.isBlank(transactionName)) {
75            ConnectApi.InsPolicyTrxnIAInputRep transactionRecord = 
76                new ConnectApi.InsPolicyTrxnIAInputRep();
77            transactionRecord.name = transactionName;
78            policyInput.transactionRecord = transactionRecord;
79        }
80        
81        // Populate additional input for multi-root policies - optional
82        if (additionalFields != null && !additionalFields.isEmpty()) {
83            List<ConnectApi.InsPolicyAddlInputIARep> additionalInputList = new List<ConnectApi.InsPolicyAddlInputIARep>();
84            
85            for (String instanceKey : additionalFields.keySet()) {
86                ConnectApi.InsPolicyAddlInputIARep additionalInput = 
87                    new ConnectApi.InsPolicyAddlInputIARep();
88                
89                // Set instance key (e.g., "AutoSilver", "FamilyHealth")
90                additionalInput.instanceKey = instanceKey;
91                
92                // Build additional fields list for this instance
93                Map<String, String> fieldsMap = additionalFields.get(instanceKey);
94                if (fieldsMap != null && !fieldsMap.isEmpty()) {
95                    List<ConnectApi.AdditionalFieldIARep> fieldsList = new List<ConnectApi.AdditionalFieldIARep>();
96                    
97                    for (String fieldKey : fieldsMap.keySet()) {
98                        ConnectApi.AdditionalFieldIARep field = new ConnectApi.AdditionalFieldIARep();
99                        field.key = fieldKey;
100                        field.value = fieldsMap.get(fieldKey);
101                        fieldsList.add(field);
102                    }
103                    
104                    additionalInput.additionalFieldsList = fieldsList;
105                }
106                
107                additionalInputList.add(additionalInput);
108            }
109            
110            policyInput.additionalInput = additionalInputList;
111        }
112        
113        // Set invocation parameters
114        // IMPORTANT: Parameter name is issueMultiRootPolicyInputRep (camelCase)
115        action.setInvocationParameter('issueMultiRootPolicyInputRep', policyInput);
116        
117        System.debug('Starting Multi-Root Policy Issuance Invocable Action (issueMultiRootInsurancePolicy)...');
118        System.debug('Context ID: ' + contextId);
119        if (!String.isBlank(policyName)) {
120            System.debug('Policy Name: ' + policyName);
121        }
122        
123        try {
124            // Invoke the action
125            List<Invocable.Action.Result> results = action.invoke();
126            
127            System.debug('Multi-Root Policy Issuance IA result = ' + results);
128            
129            // Process results
130            for (Invocable.Action.Result result : results) {
131                if (result.isSuccess()) {
132                    System.debug('SUCCESS: Multi-Root Policy Issuance completed successfully!');
133                    Object outputValue = result.getOutputParameters().get('jobIdentifier');
134                    if (outputValue != null) {
135                        System.debug('Job Identifier: ' + outputValue);
136                    } else {
137                        System.debug('Multi-Root Policy Issuance job started - result: ' + result.getOutputParameters());
138                    }
139                } else {
140                    System.debug('ERROR: Multi-Root Policy Issuance failed');
141                    System.debug('Error Details: ' + result.getErrors());
142                }
143            }
144            
145        } catch (Exception e) {
146            System.debug('EXCEPTION in Multi-Root Policy Issuance Invocable Action: ' + e.getMessage());
147            System.debug('Stack Trace: ' + e.getStackTraceString());
148        }
149    }
150}
151
152
153/*
154 * USAGE EXAMPLE:
155 * Copy and paste this code into Developer Console Execute Anonymous Window
156 */
157Map<String, Object> params = new Map<String, Object>();
158params.put('contextId', <your-context-id-here>);
159params.put('policyName', 'James Multi-Root Policy');
160params.put('policyNumber', 'James Multi-Root Policy');
161params.put('referencePolicyNumber', 'James1234');
162params.put('effectiveFromDate', '2026-01-01');
163params.put('effectiveToDate', '2026-10-31');
164params.put('transactionName', 'Sold Policy Transaction');
165
166// Build additional fields configuration
167Map<String, Map<String, String>> additionalFields = new Map<String, Map<String, String>>();
168
169// Configuration for AutoSilver instance
170Map<String, String> autoFields = new Map<String, String>();
171autoFields.put('PolicyName', 'James Auto Policy');
172autoFields.put('Name', 'James Auto Policy');
173additionalFields.put(<your-instanceKey-goes-here>, autoFields);
174
175// Configuration for FamilyHealth instance
176Map<String, String> healthFields = new Map<String, String>();
177healthFields.put('PolicyName', 'James Medical Policy');
178healthFields.put('Name', 'James Medical Policy');
179additionalFields.put(<your-instanceKey-goes-here>, healthFields);
180
181params.put('additionalFields', additionalFields);
182
183MultiRootPolicyIssuanceInvocable.executeMultiRootIssuance(params);

This sample response is for the Issue Multi-Root Insurance Policy action.

1[
2  {
3    "actionName": "issueMultiRootInsurancePolicy",
4    "errors": null,
5    "invocationId": null,
6    "isSuccess": true,
7    "outcome": null,
8    "outputValues": {
9      "jobIdentifier": "55SG000000PgSH4A0"
10    },
11    "sortOrder": -1,
12    "version": 1
13  }
14]