@sapui5/sap.suite.ui.generic.template 1.148.1 → 1.148.3

package/src/sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillHandler.js

@@ -8,8 +8,7 @@ sap.ui.define([
     "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillFormRenderer",
     "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillTableRenderer",
     "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillApplyHandler",
-    "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillDialogController",
-    "sap/suite/ui/generic/template/js/AnnotationHelper"
+    "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillDialogController"
 ], function(
     BaseObject,
     extend,
@@ -20,8 +19,7 @@ sap.ui.define([
     EasyFillFormRenderer,
     EasyFillTableRenderer,
     EasyFillApplyHandler,
-    EasyFillDialogController,
-    GenericAnnotationHelper
+    EasyFillDialogController
 ) {
     "use strict";
 
@@ -63,12 +61,16 @@ sap.ui.define([
             mCollectionRowContexts: Object.create(null),
             mCollectionRowContextsByPath: Object.create(null),
             mCollectionProperties: Object.create(null),
-            mCollectionEntityTypes: Object.create(null)
+            mCollectionEntityTypes: Object.create(null),
+            mCollectionEntitySets: Object.create(null),
+            mCollectionAllowsCreation: Object.create(null)
         };
 
         var mCollectionUpdates = Object.create(null); // { navProperty: [ rowUpdate ] } from AI response
+        var mLastFieldMapping = null;                  // retained so table sections can be re-rendered on mode switch
         var oTableStagingState = {
-            mStagedRows: Object.create(null)
+            mStagedRows: Object.create(null),
+            mPendingNewRowContexts: Object.create(null)
         };
 
         // ─── Internal Helpers ────────────────────────────────────────────────────
@@ -106,11 +108,46 @@ sap.ui.define([
         function _buildDialogHandlers() {
             return {
                 // ── Layout mode toggle (Condensed ↔ ObjectPage view) ──────────────
+                // After the sections binding is refreshed, SmartForms for the new mode
+                // are repopulated asynchronously (setTimeout in populateSmartFields).
+                // _validateFieldsAndUpdateConfirmState is called here so that validation runs
+                // immediately on whatever SmartForms are currently in the DOM, and then
+                // again via fnOnFieldChange once the new SmartFields are rendered.
                 onSelectionChange: function(oEvent) {
+                    // Step 1: clean up table content injected for the CURRENT mode BEFORE the
+                    // model update. This ensures the OPL aggregation is free of manually-added
+                    // sections when the sections binding recreates controls for the new mode,
+                    // so getSections() in renderCollectionPreviews returns only bound sections.
+                    var oOpl = oController.byId("EasyFillObjectPageLayout");
+                    if (oOpl && mLastFieldMapping && Object.keys(mCollectionUpdates).length > 0) {
+                        EasyFillTableRenderer.removeTableSections(oOpl);
+                    }
+
+                    // Step 2: update model — this triggers the OPL sections binding to recreate
+                    // bound section controls for the new mode.
                     EasyFillDialogController.onSelectionChange(
                         oEvent, oController, oTemplateUtils, oRb,
                         EasyFillFieldCollector, EasyFillLayoutMode
                     );
+
+                    // Step 3: re-render table previews for the new mode.
+                    // _removeTableSections is skipped inside renderCollectionPreviews because
+                    // bReuseStaging=true, since cleanup was already done in step 1 above.
+                    if (mLastFieldMapping && Object.keys(mCollectionUpdates).length > 0) {
+                        EasyFillTableRenderer.renderCollectionPreviews(
+                            mCollectionUpdates,
+                            mLastFieldMapping,
+                            [],
+                            oController,
+                            oRb,
+                            mCollectionState,
+                            oTableStagingState,
+                            oObjectPageModel,
+                            _validateFieldsAndUpdateConfirmState,
+                            true  // bReuseStaging — also skips re-cleanup (already done above)
+                        );
+                    }
+                    _validateFieldsAndUpdateConfirmState();
                 },
 
                 // ── Feedback thumbs-up/down ───────────────────────────────────────
@@ -135,7 +172,16 @@ sap.ui.define([
                 },
 
                 // ── Confirm: apply AI values to the live OP context ───────────────
+                // The Confirm button is disabled reactively by _validateFieldsAndUpdateConfirmState
+                // whenever a SmartField value is invalid — no click-time check needed.
                 onSaveFromEasyFillDialog: async function() {
+                    // Capture staged collection updates BEFORE applyAndSave writes them to the live
+                    // contexts — after applyAndSave the staged values equal the live values and the map would be empty.
+                    var mStagedUpdates = EasyFillApplyHandler.buildStagedCollectionUpdates(oTableStagingState, mCollectionState);
+
+                    // Extract reviewed new-row values from staging contexts BEFORE reset discards them.
+                    var mNewRowValues = EasyFillApplyHandler.extractPendingNewRowValues(oTableStagingState, mCollectionState);
+
                     EasyFillApplyHandler.applyAndSave(
                         oTransientContextForEasyFill,
                         oObjectPageContext,
@@ -143,8 +189,17 @@ sap.ui.define([
                         oTableStagingState,
                         mCollectionState
                     );
+                    // Trigger side effects on the OP context for all changed SmartForm fields
+                    // before resetting the dialog (SmartFields must still be present)
+                    _activateSideEffects();
+                    // Trigger side effects for all modified table rows
+                    _activateSideEffectsForTable(mStagedUpdates);
                     _resetEasyFill(true);
                     EasyFillDialogController.closeDialog(oController);
+
+                    // Create the new rows via the standard CRUDManager (draft-aware, handles side effects)
+                    // This is done after dialog close so the user sees the OP immediately.
+                    await _createNewRows(mNewRowValues);
                 },
 
                 // ── Text area live change: enable/disable submit button ───────────
@@ -181,10 +236,33 @@ sap.ui.define([
                         oTransientContextForEasyFill,
                         oObjectPageContext,
                         mUpdatableLookupMap,
-                        oDialogModel().getProperty("/llmData")
+                        oDialogModel().getProperty("/llmData"),
+                        _validateFieldsAndUpdateConfirmState
                     );
                 },
 
+                // ── Section visibility: hide SmartForm sections with no fields ──────────────
+                hasSectionFields: function(aFields, aChildren) {
+                    if (Array.isArray(aFields) && aFields.length > 0) {
+                        return true;
+                    }
+
+                    function hasFieldsInNode(oNode) {
+                        if (!oNode) {
+                            return false;
+                        }
+                        if (Array.isArray(oNode.fields) && oNode.fields.length > 0) {
+                            return true;
+                        }
+                        if (Array.isArray(oNode.children)) {
+                            return oNode.children.some(hasFieldsInNode);
+                        }
+                        return false;
+                    }
+
+                    return Array.isArray(aChildren) && aChildren.some(hasFieldsInNode);
+                },
+
                 // ── Fullscreen toggle ─────────────────────────────────────────────
                 onToggleFullScreen: function() {
                     EasyFillDialogController.onToggleFullScreen(oController);
@@ -233,40 +311,61 @@ sap.ui.define([
 
             if (aiCallResult.success) {
                 // Split AI response into simple fields (SmartForm) and collection rows (SmartTable)
+                // Pass mCollectionState so the splitter can check which tables allow creation
                 var oSplitResult = EasyFillAIOrchestrator.splitAIResultByCollection(
-                    aiCallResult.data, mFieldMapping, EasyFillFieldCollector, oObjectPage
+                    aiCallResult.data, mFieldMapping, EasyFillFieldCollector, oObjectPage, mCollectionState
                 );
                 var simpleFields = oSplitResult.simpleFields;
                 var collectionFields = oSplitResult.collectionFields;
 
                 // Separate updatable from non-updatable fields
-                var oEntityType = oTemplateUtils.oCommonUtils.getMetaModelEntityType(
-                    oController.getOwnerComponent().getEntitySet()
-                );
+                var sEntitySetName = oController.getOwnerComponent().getEntitySet();
+                var oEntityType = oTemplateUtils.oCommonUtils.getMetaModelEntityType(sEntitySetName);
+                var oMetaModel = oObjectPageModel.getMetaModel();
+                var oEntitySet = oMetaModel.getODataEntitySet(sEntitySetName);
                 var oSplit = EasyFillFieldCollector.getUpdatableAndNonUpdatableFields(
-                    simpleFields, oEntityType, oObjectPageContext
+                    simpleFields, oEntityType, oObjectPageContext, oEntitySet
                 );
                 mUpdatableLookupMap = oSplit.updatableFields;
+                var mNonUpdatableFields = oSplit.nonUpdatableFields;
 
                 // Build section tree for selected view mode
                 var aData = (sSelectedKey === EasyFillLayoutMode.CondensedMode)
-                    ? EasyFillFieldCollector.getSectionsForCondensedView(simpleFields)
-                    : EasyFillFieldCollector.getSectionsForObjectPageView(oEntityType, simpleFields, oRb);
+                    ? EasyFillFieldCollector.getSectionsForCondensedView(simpleFields, mUpdatableLookupMap, mNonUpdatableFields)
+                    : EasyFillFieldCollector.getSectionsForObjectPageView(oEntityType, simpleFields, oRb, mNonUpdatableFields);
 
                 // Reset form (destroy previous SmartForm content + revert table staging)
-                // then create a fresh transient context for the new AI result
+                // then create a fresh transient context for the new AI result.
+                // Restore the user's chosen layout mode afterwards because _resetEasyFill
+                // unconditionally resets it to CondensedMode — without this, renderCollectionPreviews
+                // would see the wrong mode and embed table sections inside the SmartForm SubSection
+                // instead of adding them as standalone OPL sections (OP mode) or vice-versa.
                 _resetEasyFill();
+                oModel.setProperty("/easyFillMode", sSelectedKey);
                 oTransientContextForEasyFill = EasyFillFormRenderer.makeTransientContext(
                     null, oObjectPageModel, oController
                 );
 
-                // Update dialog model with section data and AI result
-                oModel.setProperty("/sections", aData);
+                // Update dialog model with section data and AI result.
+                // llmData must be set BEFORE sections so that when the sections binding fires
+                // and triggers the populateSmartFields formatter synchronously, the AI-suggested
+                // values are already available and can be written to the transient context.
                 oModel.setProperty("/llmData", simpleFields);
+                oModel.setProperty("/updatableFields", mUpdatableLookupMap);
+                oModel.setProperty("/nonUpdatableFields", mNonUpdatableFields);
+                oModel.setProperty("/sections", aData);
+                oModel.setProperty("/hasNonUpdatableFields", Object.keys(mNonUpdatableFields).length > 0);
+
+                // Show warning if AI attempted to add multiple new rows but only one was accepted
+                oModel.setProperty("/attemptedMultipleNewRows", oSplitResult.attemptedMultipleNewRows === true);
 
                 // Process collection/table updates
                 mCollectionUpdates = collectionFields;
-                var bHasTableUpdates = Object.keys(mCollectionUpdates).length > 0;
+                mLastFieldMapping = mFieldMapping;
+                var mRejectedNewRows = oSplitResult.collectionsWithRejectedNewRows || {};
+                // hasTableUpdates is true when there are accepted updates OR rejected-only tables to show
+                var bHasTableUpdates = Object.keys(mCollectionUpdates).length > 0 ||
+                    Object.keys(mRejectedNewRows).length > 0;
                 oModel.setProperty("/hasTableUpdates", bHasTableUpdates);
 
                 // Render collection previews into the table preview container
@@ -279,12 +378,12 @@ sap.ui.define([
                     mCollectionState,
                     oTableStagingState,
                     oObjectPageModel,
-                    function() {
-                        _refreshTableValidationAndSaveState().catch(Function.prototype);
-                    }
+                    _validateFieldsAndUpdateConfirmState,
+                    false,
+                    mRejectedNewRows
                 );
 
-                await _refreshTableValidationAndSaveState();
+                _validateFieldsAndUpdateConfirmState();
 
                 var iTotalFields = Object.keys(oSplit.updatableFields).length + Object.keys(oSplit.nonUpdatableFields).length;
                 if (iTotalFields === 0 && !bHasTableUpdates) {
@@ -293,42 +392,155 @@ sap.ui.define([
                 }
 
                 oModel.setProperty("/isIllustrationVisible", false);
-                oModel.setProperty("/isFormVisible", iTotalFields > 0);
+                oModel.setProperty("/isFormVisible", iTotalFields > 0 || bHasTableUpdates);
             } else {
                 // AI call failed — show error illustration
-                EasyFillApplyHandler.applyTableValidationState([], oModel, oRb);
                 oModel.setProperty("/stateType", "Error");
             }
         }
 
-        async function _refreshTableValidationAndSaveState() {
-            var oModel = oDialogModel();
-            var mStagedCollectionUpdates = EasyFillApplyHandler.buildStagedCollectionUpdates(
-                oTableStagingState,
-                mCollectionState
-            );
-            var aTableValidationErrors = await EasyFillApplyHandler.validateCollectionUpdatesAgainstValueHelp(
-                mStagedCollectionUpdates,
-                mCollectionState,
-                oObjectPageModel,
-                oRb,
-                EasyFillFieldCollector,
-                GenericAnnotationHelper
-            );
-            EasyFillApplyHandler.applyTableValidationState(aTableValidationErrors, oModel, oRb);
+        /**
+         * Runs SmartForm.check() on every SmartForm in the EasyFill ObjectPageLayout.
+         * Returns true if all SmartForms pass validation (or none exist yet).
+         * As a side effect, check() visually marks invalid fields in the dialog.
+         *
+         * SmartForm.check() returns either:
+         *   - string[]          (synchronous validationMode) — field IDs with errors
+         *   - Promise<Object[]> (asynchronous validationMode) — resolves with field objects with errors
+         * Both are normalised via Promise.resolve() so the caller can always await the result.
+         *
+         * @returns {Promise<boolean>} resolves to true when all SmartForms have zero errors
+         */
+        async function _checkSmartFormsValidity() {
+            var oObjectPageLayout = oController.byId("EasyFillObjectPageLayout");
+            if (!oObjectPageLayout) {
+                return true;
+            }
 
+            // Collect one Promise<errorArray> per SmartForm found in the layout
+            var aCheckPromises = [];
+            oObjectPageLayout.getSections().forEach(function(oSection) {
+                oSection.getSubSections().forEach(function(oSubSection) {
+                    oSubSection.getBlocks().forEach(function(oBlock) {
+                        var aSmartFormCandidates = [];
+                        if (oBlock.isA("sap.ui.comp.smartform.SmartForm")) {
+                            aSmartFormCandidates.push(oBlock);
+                        } else if (typeof oBlock.getItems === "function") {
+                            // In condensed mode the SmartForm is nested inside a wrapper VBox;
+                            // look one level deeper to find it (mirrors EasyFillFormRenderer).
+                            oBlock.getItems().forEach(function(oItem) {
+                                if (oItem.isA("sap.ui.comp.smartform.SmartForm")) {
+                                    aSmartFormCandidates.push(oItem);
+                                }
+                            });
+                        }
+                        aSmartFormCandidates.forEach(function(oSmartForm) {
+                            // .catch(() => []) absorbs internal SmartField metadata-promise rejections
+                            // that fire when SmartFields are destroyed during a mode switch.
+                            aCheckPromises.push(
+                                Promise.resolve(oSmartForm.check()).catch(function() { return []; })
+                            );
+                        });
+                    });
+                });
+            });
+
+            // Resolve all checks in parallel; valid only when every SmartForm has no errors
+            var aResults = await Promise.all(aCheckPromises);
+            return aResults.every(function(aErrors) {
+                return Array.isArray(aErrors) && aErrors.length === 0;
+            });
+        }
+
+        /**
+         * Re-computes isSaveEnabled from the combined SmartForm and table SmartField validity
+         * flag. Called as the single source of truth for the Confirm button state.
+         *
+         * @param {boolean} bAllFieldsValid - true when both SmartForm and table SmartField checks pass
+         */
+        function _computeSaveEnabled(bAllFieldsValid) {
             var bHasScalarChanges = Object.keys(mUpdatableLookupMap || {}).length > 0;
-            var bHasTableChanges = EasyFillApplyHandler.hasStagedCollectionChanges(
-                oTableStagingState,
-                mCollectionState
-            );
+            var bHasTableChanges = EasyFillApplyHandler.hasStagedCollectionChanges(oTableStagingState, mCollectionState);
+            var bHasChanges = bHasScalarChanges || bHasTableChanges;
+            oDialogModel().setProperty("/isSaveEnabled", bAllFieldsValid && bHasChanges);
+        }
 
-            oModel.setProperty(
-                "/isSaveEnabled",
-                bHasScalarChanges || (bHasTableChanges && aTableValidationErrors.length === 0)
-            );
+        /**
+         * Runs SmartField.checkValuesValidity() on every editable table SmartField.
+         * Returns true if all fields pass (or no table exists yet).
+         *
+         * checkValuesValidity() returns a Promise<boolean> (true = valid).
+         *
+         * @returns {Promise<boolean>} resolves to true when all table SmartFields are valid
+         */
+        async function _checkTableSmartFieldsValidity() {
+            var sMarker = "easyfillTableSection";
+            var oObjectPageLayout = oController.byId("EasyFillObjectPageLayout");
+            if (!oObjectPageLayout) {
+                return true;
+            }
+
+            var aCheckPromises = [];
+
+            function scanTableForSmartFields(oTable) {
+                if (!oTable.isA("sap.m.Table") || !oTable.getVisible()) { return; }
+                oTable.getItems().forEach(function(oListItem) {
+                    if (!oListItem.isA("sap.m.ColumnListItem")) { return; }
+                    oListItem.getCells().forEach(function(oCell) {
+                        if (!oCell.isA("sap.ui.comp.smartfield.SmartField") || !oCell.getEditable()) { return; }
+                        var bValueStateOk = oCell.getValueState() !== "Error";
+                        aCheckPromises.push(
+                            Promise.resolve(oCell.checkValuesValidity()).then(function(bValid) {
+                                return bValueStateOk && bValid !== false;
+                            })
+                        );
+                    });
+                });
+            }
 
-            return aTableValidationErrors;
+            function scanVBox(oVBox) {
+                oVBox.getItems().forEach(function(oItem) { scanTableForSmartFields(oItem); });
+            }
+
+            oObjectPageLayout.getSections().forEach(function(oSection) {
+                var bIsTableSection = oSection.getCustomData().some(function(oData) {
+                    return oData.getKey() === sMarker;
+                });
+
+                oSection.getSubSections().forEach(function(oSubSection) {
+                    oSubSection.getBlocks().forEach(function(oBlock) {
+                        if (!oBlock.isA("sap.m.VBox")) { return; }
+                        var bIsMarkedBlock = oBlock.getCustomData().some(function(oData) {
+                            return oData.getKey() === sMarker;
+                        });
+                        // Scan VBoxes that are either:
+                        // (a) directly marked (condensed mode: injected into Filled Fields SubSection)
+                        // (b) inside a marked standalone section (OP mode)
+                        if (bIsMarkedBlock || bIsTableSection) {
+                            scanVBox(oBlock);
+                        }
+                    });
+                });
+            });
+
+            var aResults = await Promise.all(aCheckPromises);
+            return aResults.every(function(bValid) { return bValid === true; });
+        }
+
+        /**
+         * Called after every SmartField change event (both form and table) and once after each
+         * group/table is populated. Validates all SmartForms and all table SmartFields and
+         * updates the Confirm button enabled state.
+         */
+        function _validateFieldsAndUpdateConfirmState() {
+            setTimeout(function() {
+                Promise.all([
+                    _checkSmartFormsValidity(),
+                    _checkTableSmartFieldsValidity()
+                ]).then(function(aResults) {
+                    _computeSaveEnabled(aResults[0] && aResults[1]);
+                }).catch(Function.prototype);
+            }, 0);
         }
 
         /**
@@ -338,6 +550,7 @@ sap.ui.define([
          * @param {boolean} [bRemoveTextAreaValue=false] - if true, also clears the text area input
          */
         function _resetEasyFill(bRemoveTextAreaValue) {
+            mLastFieldMapping = null;
             EasyFillApplyHandler.resetEasyFill(
                 !!bRemoveTextAreaValue,
                 oDialogModel(),
@@ -354,6 +567,127 @@ sap.ui.define([
             );
         }
 
+        /**
+         * Activates side effects for all editable SmartFields in the EasyFill SmartForm.
+         * Called after applyAndSave so that side effects are triggered on the original
+         * ObjectPage context (not the transient context used while the dialog was open).
+         *
+         * Collects field group IDs from the inner controls of every editable SmartField,
+         * updates the view's CustomData for each field group to reference the OP context,
+         * then registers the group change and triggers field-group validation on the view.
+         */
+        function _activateSideEffects() {
+            var oObjectPageLayout = oController.byId("EasyFillObjectPageLayout");
+            if (!oObjectPageLayout) {
+                return;
+            }
+
+            // Collect all editable SmartFields from the EasyFill dialog SmartForms
+            var aEditableFields = [];
+            oObjectPageLayout.getSections().forEach(function(oSection) {
+                oSection.getSubSections().forEach(function(oSubSection) {
+                    oSubSection.getBlocks().forEach(function(oBlock) {
+                        if (oBlock.isA("sap.ui.comp.smartform.SmartForm")) {
+                            oBlock.getGroups().forEach(function(oGroup) {
+                                oGroup.getGroupElements().forEach(function(oGroupElement) {
+                                    oGroupElement.getElements().forEach(function(oElement) {
+                                        if (oElement.isA && oElement.isA("sap.ui.comp.smartfield.SmartField") && oElement.getEditable()) {
+                                            aEditableFields.push(oElement);
+                                        }
+                                    });
+                                });
+                            });
+                        }
+                    });
+                });
+            });
+
+            // Making a Set so that duplicate field group IDs are not passed
+            var aFieldGroupIdSet = new Set();
+            aEditableFields.forEach(function(oSmartField) {
+                // SideEffect would be invoked only for the editable controls inside the SmartField
+                var aEditableInnerFields = oSmartField.getInnerControls().filter(function(oControl) {
+                    return oControl.getEditable();
+                });
+                aEditableInnerFields.forEach(function(oControl) {
+                    var aControlFieldGroupId = oControl.getFieldGroupIds();
+                    if (aControlFieldGroupId.length > 0) {
+                        aControlFieldGroupId.forEach(function(sFieldGroupId) {
+                            aFieldGroupIdSet.add(sFieldGroupId);
+                        });
+                    }
+                });
+            });
+
+            var oView = oController.getView();
+
+            aFieldGroupIdSet.forEach(function(sFieldGroupId) {
+                var oID = oView.data(sFieldGroupId);
+
+                /**
+                 * Currently, the SmartFields are created using the TransientContext, which means both
+                 * "context" and "contextObject" refer to the TransientContext instance.
+                 *
+                 * However, we need to use the original OP context so that side effects are triggered
+                 * on the original OP context when the user saves data from the EasyFill dialog back to OP.
+                 *
+                 * Therefore, we update the "context" and "contextObject" to reference the original OP context.
+                 */
+                if (oID) {
+                    oID["context"] = oObjectPageContext.getPath();
+                    oID["contextObject"] = oObjectPageContext;
+                    oView.data(sFieldGroupId, oID);
+
+                    // To make sure that all the fields side effect would be triggered
+                    var sSideEffectQualifier = oTemplateUtils.oServices.oApplicationController._getSideEffectsQualifier(oID.name);
+                    oTemplateUtils.oServices.oApplicationController.registerGroupChange(sSideEffectQualifier);
+                }
+            });
+
+            oView.triggerValidateFieldGroup([...aFieldGroupIdSet]);
+        }
+
+        /**
+         * Activates side effects for all modified table (collection) rows after applyAndSave.
+         * For each collection row that had AI-suggested value changes applied, triggers
+         * executeSideEffects on the real row context with the list of changed property names.
+         *
+         * Must be called with mStagedUpdates captured BEFORE applyAndSave, because after
+         * applyAndSave the staged values equal the live values so buildStagedCollectionUpdates
+         * would return an empty map.
+         *
+         * @param {object} mStagedUpdates - pre-computed collection updates: { navProperty: [ rowUpdate ] }
+         */
+        function _activateSideEffectsForTable(mStagedUpdates) {
+            if (!mStagedUpdates || !Object.keys(mStagedUpdates).length) {
+                return;
+            }
+
+            Object.keys(mStagedUpdates).forEach(function(sCollectionName) {
+                var aRowUpdates = mStagedUpdates[sCollectionName] || [];
+                aRowUpdates.forEach(function(oRowUpdate) {
+                    var oResolvedRow = EasyFillApplyHandler._resolveCollectionRowContext(sCollectionName, oRowUpdate, mCollectionState);
+                    if (!oResolvedRow || !oResolvedRow.context) {
+                        return;
+                    }
+
+                    // Collect the names of changed properties (exclude internal metadata fields)
+                    var aChangedProperties = Object.keys(oRowUpdate).filter(function(sKey) {
+                        return sKey !== "_rowIndex" && sKey !== "_contextPath";
+                    });
+
+                    if (!aChangedProperties.length) {
+                        return;
+                    }
+
+                    oTemplateUtils.oServices.oApplicationController.executeSideEffects(
+                        oResolvedRow.context,
+                        aChangedProperties
+                    );
+                });
+            });
+        }
+
         /**
          * Convenience accessor for the easyFillDialogModel JSONModel.
          * @returns {sap.ui.model.json.JSONModel}
@@ -362,6 +696,50 @@ sap.ui.define([
             return oController.getView().getModel("easyFillDialogModel");
         }
 
+        function _findSmartTableForNavProperty(aSmartTables, sNavProperty) {
+            return aSmartTables.find(function(oTable) {
+                var oHandler = oTemplateUtils.oServices.oPresentationControlHandlerFactory.getPresentationControlHandler(oTable);
+                if (!oHandler) { return false; }
+                var sPath = oHandler.getBindingPath && oHandler.getBindingPath();
+                return sPath && sPath.split("/").pop() === sNavProperty;
+            });
+        }
+
+        /**
+         * Creates new table rows via CommonEventHandlers.addEntry (draft-aware) with navigation
+         * suppressed so the user stays on the ObjectPage.
+         * Using CommonEventHandlers.addEntry (bSuppressNavigation=true) instead of calling
+         * CRUDManager.addEntry directly ensures the SmartTable binding is refreshed and side
+         * effects are executed after the row is created — without that refresh the ObjectPage
+         * table would not show the newly created row.
+         *
+         * @param {object} mNewRowValues - map of { navProperty: plainValuesObject }
+         * @returns {Promise<void>}
+         */
+        async function _createNewRows(mNewRowValues) {
+            if (!mNewRowValues || !Object.keys(mNewRowValues).length) {
+                return;
+            }
+            var aSmartTables = EasyFillFieldCollector.getObjectPageSmartTables(oObjectPage);
+            var aNavProperties = Object.keys(mNewRowValues);
+
+            for (var i = 0; i < aNavProperties.length; i++) {
+                var sNavProp = aNavProperties[i];
+                var oSmartTable = _findSmartTableForNavProperty(aSmartTables, sNavProp);
+                if (!oSmartTable) {
+                    continue;
+                }
+                try {
+                    // bSuppressNavigation=true: stay on the OP (don't navigate to the new sub-item).
+                    // bIgnoreTableRefresh not passed (undefined/falsy): the SmartTable binding is
+                    // refreshed and side effects are executed so the new row becomes visible.
+                    await oTemplateUtils.oCommonEventHandlers.addEntry(oSmartTable, true, undefined, mNewRowValues[sNavProp]);
+                } catch (e) {
+                    // addEntry handles its own error messaging via CommonEventHandlers/CRUDManager
+                }
+            }
+        }
+
         // ─── Public API ──────────────────────────────────────────────────────────
 
         return {