Update Additional Components for Funding Workbench

global class FundingWorkbenchApexUtil implements System.Callable {

    // Minimal constants needed for this method + error reporting
    private static final String RESULT_KEY = 'result';
    private static final String SIZE_KEY   = 'size';
    private static final String FOUND_KEY  = 'found';
    private static final String APEX_INVOCATION_ERROR = 'ApexInvocationErrorDetails';

    global FundingWorkbenchApexUtil() {}

    // --- REQUIRED by System.Callable pattern used in the original ---
    global static Object call(String action, Map<String, Object> args) {
        Map<String, Object> input  = (Map<String, Object>) args.get('input');
        Map<String, Object> output = (Map<String, Object>) args.get('output');
        return invokeMethod(action, input, output);
    }

    // --- Minimal dispatcher: keep only what's needed ---
    public static Object invokeMethod(String methodName,
                                      Map<String, Object> input,
                                      Map<String, Object> output) {
        String errorDetails;

        try {
            switch on methodName {
                when 'formatAssociatedParties' {
                    return formatAssociatedParties(input, output);
                }
                when else {
                    errorDetails = 'Invalid methodname';
                }
            }
        } catch (Exception ex) {
            errorDetails = 'Error Occurred : ' + ex.getMessage();
        }

        if (errorDetails != null) {
            output.put(APEX_INVOCATION_ERROR, errorDetails);
        }
        return output;
    }

    /**
     * Normalizes AssociatedParties into:
     * [{ "label": "...", "value": "..." }, ...]
     *
     * Supports:
     * 1) List<Object> of Map<String,Object> with keys label/value
     * 2) String like:
     *    "[{label=Application General, value=13Z...},[{label=Rachel, value=0x...}, {label=Mike, value=0x...}]]"
     */
    private static Object formatAssociatedParties(Map<String, Object> input,
                                                 Map<String, Object> output) {
        List<Map<String, Object>> result = new List<Map<String, Object>>();
        Object raw = (input == null) ? null : input.get('AssociatedParties');

        if (raw == null) {
            output.put(RESULT_KEY, result);
            output.put(SIZE_KEY, 0);
            output.put(FOUND_KEY, false);
            return null;
        }

        // Case 1: Already list of objects
        if (raw instanceof List<Object>) {
            for (Object o : (List<Object>) raw) {
                if (o == null) continue;

                if (o instanceof Map<String, Object>) {
                    Map<String, Object> row = (Map<String, Object>) o;
                    String label = String.valueOf(row.get('label'));
                    String value = String.valueOf(row.get('value'));

                    if (!String.isBlank(label) && !String.isBlank(value)) {
                        result.add(new Map<String, Object>{
                            'label' => label,
                            'value' => value
                        });
                    }
                }
            }
        }
        // Case 2: String (may be nested / have spaces)
        else if (raw instanceof String) {
            String s = ((String) raw).trim();
            if (!String.isBlank(s)) {
                // Extract every label/value pair anywhere in the string.
                Pattern p = Pattern.compile(
                    'label\\s*=\\s*([^,\\]\\}]+)\\s*,\\s*value\\s*=\\s*([^\\]\\}\\,\\s]+)'
                );
                Matcher m = p.matcher(s);

                while (m.find()) {
                    String label = m.group(1).trim();
                    String value = m.group(2).trim();

                    // strip any trailing brackets that sneak into the last token
                    while (value.endsWith(']')) {
                        value = value.left(value.length() - 1).trim();
                    }

                    if (!String.isBlank(label) && !String.isBlank(value)) {
                        result.add(new Map<String, Object>{
                            'label' => label,
                            'value' => value
                        });
                    }
                }
            }
        }

        output.put(RESULT_KEY, result);
        output.put(SIZE_KEY, result.size());
        output.put(FOUND_KEY, !result.isEmpty());
        return null;
    }
}

• IF(%UploadFileStep:SelectDocumentCategoryAndType:DocumentInformation:selectedDocumentTypeId% == NULL, %documentTypeValue%, %UploadFileStep:SelectDocumentCategoryAndType:DocumentInformation:selectedDocumentTypeId%)