After upgrading to scx-2111, our custom event handler extension stopped processing custom fields during event registration. The handler worked flawlessly in scx-2105, but now custom fields like ‘dietary_preferences’ and ‘accessibility_needs’ are not being captured.
Our event handler extension:
public void handleEventRegistration(Event event) {
String dietary = event.getCustomField("dietary_preferences");
String accessibility = event.getCustomField("accessibility_needs");
saveToDatabase(dietary, accessibility);
}
The standard fields (name, email, registration date) process correctly, but all custom field values return null. We’ve verified the custom fields exist in the event model and are populated in the UI. The upgrade impact seems to have changed how custom field mapping works in event handler extensions. Has anyone successfully migrated custom event handlers to scx-2111?
The scx-2111 release changed the custom field access API. You can’t use getCustomField() directly anymore. Check the release notes - there’s a new method called getExtensionField() or something similar. The field mapping structure was redesigned for better performance.
The upgrade impact in scx-2111 fundamentally changed how event handler extensions access custom fields. Here’s the complete solution addressing all three focus areas:
Event Handler Extension Update:
The API for accessing custom fields changed. Replace your current code:
public void handleEventRegistration(Event event) {
EventExtension ext = event.getExtensionData();
String dietary = ext.getFieldValue("custom.dietary_preferences");
String accessibility = ext.getFieldValue("custom.accessibility_needs");
saveToDatabase(dietary, accessibility);
}
Note the ‘custom.’ namespace prefix - this is now required in scx-2111.
Custom Field Mapping Configuration:
Update your extension configuration XML to declare field access:
<eventHandler name="RegistrationHandler">
<fieldAccessList>
<field>custom.dietary_preferences</field>
<field>custom.accessibility_needs</field>
</fieldAccessList>
</eventHandler>
Upgrade Impact Mitigation:
- Verify custom field definitions have ‘persistable=true’ and ‘handlerAccessible=true’ attributes
- Update field definitions to include the new ‘extensionScope’ attribute set to ‘EVENT_PROCESSING’
- Re-register your event handler with the updated configuration
- Clear the extension cache: Admin Console → Extensions → Clear Cache
- Test with both new registrations and historical data migration
Field Mapping Troubleshooting:
If fields still return null after these changes:
- Check that field technical names match exactly (case-sensitive)
- Verify the event model version in your handler matches scx-2111 schema
- Review logs for ‘FieldAccessDeniedException’ - indicates missing configuration
- Ensure your handler is registered for the POST_REGISTRATION event phase, not PRE_REGISTRATION
The core issue is that scx-2111 introduced stricter security and performance controls around custom field access. By explicitly declaring which fields your handler needs and using the new extension data API, you’ll restore full functionality. We’ve successfully migrated 8 custom event handlers using this approach with zero data loss.
I had the exact same problem. The solution involves updating both your handler code and the configuration. First, verify that your custom fields are defined with the correct scope in the event model. Then update your handler to use the new API methods introduced in scx-2111.
We encountered this during our upgrade testing. The issue is twofold: first, the API changed as others mentioned, but second, there’s also a change in how custom field data is serialized during event processing. Make sure your custom fields are marked as ‘persistable’ in the field definition. In scx-2111, non-persistable custom fields aren’t available in event handlers by default.
Check your event handler registration in the extension configuration. In scx-2111, you need to explicitly declare which custom fields your handler will access. There’s a new ‘fieldAccessList’ property in the handler configuration XML. Without this declaration, the runtime won’t map the custom fields to your handler context.