@sapui5/sap.suite.ui.generic.template 1.148.0 → 1.148.2

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

@@ -0,0 +1,325 @@
+sap.ui.define([
+    "sap/suite/ui/generic/template/genericUtilities/FeLogger",
+    "sap/suite/ui/generic/template/genericUtilities/FeError"
+], function(FeLogger, FeError) {
+    "use strict";
+
+    var sClassName = "lib.ai.EasyFill.EasyFillApplyHandler";
+    var oLogger = new FeLogger(sClassName).getLogger();
+
+    /**
+     * EasyFillApplyHandler
+     *
+     * Responsible for:
+    * 1. Applying AI-suggested field values from transient contexts back to the live ObjectPage context on Confirm.
+    * 2. Building and validating staged collection (table) row updates before allowing save.
+    * 3. Resetting the EasyFill dialog state (model, staged values, transient context) on cancel or clear.
+     */
+    return {
+
+        /**
+         * Applies all AI-suggested scalar field values from the transient context to the live ObjectPage context.
+         * Called when the user clicks "Confirm" in the EasyFill dialog.
+         *
+         *
+         * Only properties present in the updatable lookup map are written back.
+         * Collection (table) row values are copied from transient staging contexts to the
+         * live row contexts only here, so the ObjectPage table updates only after confirm.
+         * New row creation is NOT done here — the caller must call createPendingNewRows separately
+         * because it requires CRUDManager access (draft-aware) that ApplyHandler does not hold.
+         *
+         * @param {object} oTransientContextForEasyFill - the transient OData context holding AI-suggested values
+         * @param {object} oObjectPageContext - the live ObjectPage binding context to write values into
+         * @param {object} mUpdatableLookupMap - map of { fieldName: value } for fields that are updatable
+         * @param {object} oTableStagingState - table staging state { mStagedRows, mPendingNewRowContexts }
+         * @param {object} mCollectionState - collection tracking state
+         */
+        applyAndSave: function(oTransientContextForEasyFill, oObjectPageContext, mUpdatableLookupMap, oTableStagingState, mCollectionState) {
+            if (!oTransientContextForEasyFill || !oObjectPageContext) {
+                oLogger.warning("applyAndSave: missing transient or ObjectPage context — skipping apply");
+                return;
+            }
+
+            var oTransientObject = oTransientContextForEasyFill.getObject();
+            var iApplied = 0;
+
+            // Copy each AI-suggested property value from the transient context to the live OP context
+            for (var sProp in oTransientObject) {
+                if (sProp !== "__metadata" && mUpdatableLookupMap[sProp]) {
+                    oObjectPageContext.setProperty(sProp, oTransientObject[sProp]);
+                    iApplied++;
+                }
+            }
+
+            oLogger.debug("applyAndSave: applied " + iApplied + " field(s) to ObjectPage context");
+
+            var mCollectionUpdates = this.buildStagedCollectionUpdates(oTableStagingState, mCollectionState);
+            var iCollectionApplied = 0;
+
+            Object.keys(mCollectionUpdates).forEach(function(sCollectionName) {
+                var aRowUpdates = mCollectionUpdates[sCollectionName] || [];
+                aRowUpdates.forEach(function(oRowUpdate) {
+                    var oResolvedRow = this._resolveCollectionRowContext(sCollectionName, oRowUpdate, mCollectionState);
+                    if (!oResolvedRow || !oResolvedRow.context) {
+                        return;
+                    }
+
+                    Object.keys(oRowUpdate).forEach(function(sPropertyName) {
+                        if (sPropertyName === "_rowIndex" || sPropertyName === "_contextPath") {
+                            return;
+                        }
+                        oResolvedRow.context.setProperty(sPropertyName, oRowUpdate[sPropertyName]);
+                        iCollectionApplied++;
+                    });
+                }, this);
+            }, this);
+
+            oLogger.debug("applyAndSave: applied " + iCollectionApplied + " staged table value(s) to ObjectPage context");
+        },
+
+        /**
+         * Extracts user-reviewed values from the pending new-row transient contexts.
+         * Returns a map of { navProperty: predefinedValues } ready to pass to CRUDManager.addEntry.
+         * The caller is responsible for discarding the transient contexts afterwards.
+         *
+         * @param {object} oTableStagingState - table staging state { mPendingNewRowContexts }
+         * @param {object} mCollectionState - collection tracking state (mCollectionProperties)
+         * @returns {object} map of { navProperty: plainValuesObject }
+         */
+        extractPendingNewRowValues: function(oTableStagingState, mCollectionState) {
+            var mNewRowValues = Object.create(null);
+            Object.keys((oTableStagingState && oTableStagingState.mPendingNewRowContexts) || {}).forEach(function(sCollectionName) {
+                var aNewContexts = oTableStagingState.mPendingNewRowContexts[sCollectionName] || [];
+                if (!aNewContexts.length) {
+                    return;
+                }
+                var mCollectionPropertyMap = (mCollectionState && mCollectionState.mCollectionProperties &&
+                    mCollectionState.mCollectionProperties[sCollectionName]) || Object.create(null);
+
+                // Extract scalar values set by the user during the preview (first new row only — cap is 1)
+                var oNewContext = aNewContexts[0];
+                var oValues = Object.create(null);
+                Object.keys(mCollectionPropertyMap).forEach(function(sPropName) {
+                    var vValue = oNewContext.getProperty && oNewContext.getProperty(sPropName);
+                    if (vValue !== undefined && vValue !== null && typeof vValue !== "object") {
+                        oValues[sPropName] = vValue;
+                    }
+                });
+                mNewRowValues[sCollectionName] = oValues;
+                oLogger.debug("extractPendingNewRowValues: extracted " + Object.keys(oValues).length +
+                    " value(s) for new row in '" + sCollectionName + "'");
+            });
+            return mNewRowValues;
+        },
+
+        /**
+         * Builds a collection updates map from the staged transient row contexts.
+         * Only editable scalar properties whose staged value differs from the live row value are included.
+         *
+         * @param {object} oTableStagingState - table staging state { mStagedRows }
+         * @param {object} mCollectionState - collection tracking state
+         * @returns {object} map of { navProperty: [ rowUpdate ] }
+         */
+        buildStagedCollectionUpdates: function(oTableStagingState, mCollectionState) {
+            var mCollectionUpdates = Object.create(null);
+            var mStagedRowsByCollection = oTableStagingState && oTableStagingState.mStagedRows;
+
+            Object.keys(mStagedRowsByCollection || {}).forEach(function(sCollectionName) {
+                var aStagedRows = mStagedRowsByCollection[sCollectionName] || [];
+                var mCollectionPropertyMap = mCollectionState.mCollectionProperties[sCollectionName] || Object.create(null);
+
+                aStagedRows.forEach(function(oStagedRow) {
+                    var oRealContext = oStagedRow.realContext;
+                    var oTransientContext = oStagedRow.transientContext;
+                    if (!oRealContext || !oTransientContext) {
+                        return;
+                    }
+
+                    var oRealRowObject = oRealContext.getObject && oRealContext.getObject();
+                    var oRowUpdate = {
+                        _rowIndex: oStagedRow.rowIndex,
+                        _contextPath: oRealContext.getPath && oRealContext.getPath()
+                    };
+                    var bHasChanges = false;
+
+                    (oStagedRow.propertyNames || []).forEach(function(sPropertyName) {
+                        var oPropertyMeta = mCollectionPropertyMap[sPropertyName];
+                        if (!oPropertyMeta || !this._isEditableProperty(oPropertyMeta, oRealRowObject)) {
+                            return;
+                        }
+
+                        var vLiveValue = oRealContext.getProperty(sPropertyName);
+                        var vStagedValue = oTransientContext.getProperty(sPropertyName);
+                        if (!this._isSupportedStagedValue(vStagedValue)) {
+                            return;
+                        }
+
+                        if (!this._areValuesEqual(vLiveValue, vStagedValue)) {
+                            oRowUpdate[sPropertyName] = vStagedValue;
+                            bHasChanges = true;
+                        }
+                    }, this);
+
+                    if (bHasChanges) {
+                        if (!mCollectionUpdates[sCollectionName]) {
+                            mCollectionUpdates[sCollectionName] = [];
+                        }
+                        mCollectionUpdates[sCollectionName].push(oRowUpdate);
+                    }
+                }, this);
+            }, this);
+
+            return mCollectionUpdates;
+        },
+
+        /**
+         * Returns whether any staged collection row currently differs from the live ObjectPage rows,
+         * or whether any new rows are pending creation.
+         *
+         * @param {object} oTableStagingState - table staging state { mStagedRows, mPendingNewRowContexts }
+         * @param {object} mCollectionState - collection tracking state
+         * @returns {boolean}
+         */
+        hasStagedCollectionChanges: function(oTableStagingState, mCollectionState) {
+            var mCollectionUpdates = this.buildStagedCollectionUpdates(oTableStagingState, mCollectionState);
+            var bHasUpdates = Object.keys(mCollectionUpdates).some(function(sCollectionName) {
+                return (mCollectionUpdates[sCollectionName] || []).length > 0;
+            });
+            if (bHasUpdates) {
+                return true;
+            }
+            // Also return true if there are pending new row contexts
+            return Object.keys((oTableStagingState && oTableStagingState.mPendingNewRowContexts) || {}).some(function(sCollectionName) {
+                return ((oTableStagingState.mPendingNewRowContexts[sCollectionName]) || []).length > 0;
+            });
+        },
+
+        /**
+         * Resets the EasyFill dialog to its initial empty state.
+         * Clears the dialog model properties, destroys table preview items,
+         * and optionally clears the text area value.
+         *
+         * @param {boolean} bRemoveTextAreaValue - if true, also clears the user input text area
+         * @param {object} oDialogModel - the easyFillDialogModel JSONModel
+         * @param {object} oController - MVC controller (used to byId controls)
+         * @param {object} mCollectionUpdates - mutable collection updates map (cleared in place)
+         * @param {object} oEasyFillLayoutMode - EasyFillLayoutMode enum
+         * @param {function} fnRevertStagedUpdates - EasyFillTableRenderer.revertStagedCollectionUpdates
+         * @param {function} fnResetTransientContext - EasyFillFormRenderer.resetTransientContext
+         */
+        resetEasyFill: function(bRemoveTextAreaValue, oDialogModel, oController, mCollectionUpdates, oEasyFillLayoutMode, fnRevertStagedUpdates, fnResetTransientContext) {
+            // Remove dynamically-added table ObjectPageSections from the shared OPL
+            var sTableSectionMarker = "easyfillTableSection";
+            var oObjectPageLayout = oController.byId("EasyFillObjectPageLayout");
+            if (oObjectPageLayout) {
+                oObjectPageLayout.getSections().filter(function(oSection) {
+                    return oSection.getCustomData().some(function(oData) {
+                        return oData.getKey() === sTableSectionMarker;
+                    });
+                }).forEach(function(oSection) {
+                    oObjectPageLayout.removeSection(oSection);
+                    oSection.destroy();
+                });
+            }
+
+            // Revert any staged table row values back to original
+            fnRevertStagedUpdates();
+
+            // Reset the transient context (discard all staged scalar AI values)
+            fnResetTransientContext();
+
+            // Reset all dialog model properties to their initial state
+            oDialogModel.setProperty("/isFormVisible", false);
+            oDialogModel.setProperty("/isIllustrationVisible", true);
+            oDialogModel.setProperty("/isSaveEnabled", false);
+            oDialogModel.setProperty("/stateType", "Initial");
+            oDialogModel.setProperty("/feedbackEnabled", true);
+            oDialogModel.setProperty("/feedbackPressedUp", false);
+            oDialogModel.setProperty("/feedbackPressedDown", false);
+            oDialogModel.setProperty("/isFullScreen", true);
+            oDialogModel.setProperty("/hasTableUpdates", false);
+            oDialogModel.setProperty("/attemptedMultipleNewRows", false);
+            oDialogModel.setProperty("/easyFillMode", oEasyFillLayoutMode.CondensedMode);
+            oDialogModel.setProperty("/llmData", {});
+            oDialogModel.setProperty("/sections", []);
+            oDialogModel.setProperty("/updatableFields", {});
+            oDialogModel.setProperty("/nonUpdatableFields", {});
+            oDialogModel.setProperty("/hasNonUpdatableFields", false);
+
+            // Clear the mutable collection updates map in place
+            Object.keys(mCollectionUpdates).forEach(function(sKey) {
+                delete mCollectionUpdates[sKey];
+            });
+
+            if (bRemoveTextAreaValue) {
+                var oTextArea = oController.byId("EasyFillInputTextArea");
+                if (oTextArea) {
+                    oTextArea.setValue("");
+                }
+                oDialogModel.setProperty("/isEasyFillButtonEnabled", false);
+            }
+
+            oLogger.debug("resetEasyFill: dialog state reset" + (bRemoveTextAreaValue ? " (including text area)" : ""));
+        },
+
+        // ─── Private Helpers ─────────────────────────────────────────────────────
+
+        /**
+         * Resolves an OData row context for a collection row update.
+         * Prefers context path; falls back to row index.
+         * (Mirrors EasyFillTableRenderer._resolveCollectionRowContext to keep this module independent.)
+         *
+         * @param {string} sCollectionName
+         * @param {object} oRowUpdate
+         * @param {object} mCollectionState
+         * @returns {{ context, rowIndex }|null}
+         */
+        _resolveCollectionRowContext: function(sCollectionName, oRowUpdate, mCollectionState) {
+            var mByPath = mCollectionState.mCollectionRowContextsByPath[sCollectionName] || Object.create(null);
+            var sContextPath = oRowUpdate && oRowUpdate._contextPath;
+            if (typeof sContextPath === "string" && mByPath[sContextPath]) {
+                return mByPath[sContextPath];
+            }
+            var iRowIndex = oRowUpdate && oRowUpdate._rowIndex;
+            var aRowContexts = mCollectionState.mCollectionRowContexts[sCollectionName] || [];
+            if (typeof iRowIndex === "number" && aRowContexts[iRowIndex]) {
+                return { context: aRowContexts[iRowIndex], rowIndex: iRowIndex };
+            }
+            return null;
+        },
+
+        _isEditableProperty: function(oPropertyMeta, oRowObject) {
+            if (!oPropertyMeta) {
+                return false;
+            }
+            var sUpdatable = oPropertyMeta["sap:updatable"];
+            if (sUpdatable) {
+                return sUpdatable !== "false";
+            }
+            var oAnnotation = oPropertyMeta["com.sap.vocabularies.Common.v1.FieldControl"];
+            if (oAnnotation && oAnnotation["EnumMember"]) {
+                return oAnnotation["EnumMember"] !== "com.sap.vocabularies.Common.v1.FieldControlType/ReadOnly";
+            }
+            var sFieldControl = oPropertyMeta["sap:field-control"];
+            if (sFieldControl) {
+                var iFieldControlValue = oRowObject && oRowObject[sFieldControl];
+                return iFieldControlValue !== 1;
+            }
+            return true;
+        },
+
+        _isSupportedStagedValue: function(vValue) {
+            return vValue === null ||
+                vValue === undefined ||
+                typeof vValue !== "object" ||
+                vValue instanceof Date;
+        },
+
+        _areValuesEqual: function(vLeft, vRight) {
+            if (vLeft instanceof Date && vRight instanceof Date) {
+                return vLeft.getTime() === vRight.getTime();
+            }
+            return vLeft === vRight;
+        }
+    };
+});