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

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

@@ -0,0 +1,217 @@
+sap.ui.define([
+    "sap/ui/comp/smartform/GroupElement",
+    "sap/ui/comp/smartfield/SmartField",
+    "sap/m/Text",
+    "sap/ui/layout/form/ColumnElementData",
+    "sap/suite/ui/generic/template/genericUtilities/FeLogger",
+    "sap/suite/ui/generic/template/genericUtilities/FeError"
+], function(GroupElement, SmartField, Text, ColumnElementData, FeLogger, FeError) {
+    "use strict";
+
+    var sClassName = "lib.ai.EasyFill.EasyFillFormRenderer";
+    var oLogger = new FeLogger(sClassName).getLogger();
+
+    /**
+     * EasyFillFormRenderer
+     *
+     * Responsible for:
+     * 1. Programmatically populating SmartForm groups with SmartField controls based on LLM response data.
+     * 2. Managing the transient OData context used to stage AI-suggested values before the user confirms.
+     *
+     * Each SmartForm group in the EasyFill dialog receives:
+     * - An editable SmartField bound to the transient context (shows the AI-suggested value)
+     * - A read-only SmartField ("Previously:") bound to the original ObjectPage context (shows current value)
+     *
+     * The SmartForm shell containers (EasyFillUpdatableSmartForm, EasyFillNonUpdatableSmartForm) are
+     * created in XML fragments and populated here dynamically — no fields are declared in the XML.
+     */
+    return {
+
+        /**
+         * Populates a target SmartForm group with GroupElements for the given list of field names.
+         * For each field:
+         * - Creates an editable SmartField bound to the transient context (if updatable)
+         *   alongside a read-only "Previously:" SmartField bound to the original OP context.
+         * - Creates a display-only SmartField bound to the OP context (if non-updatable).
+         *
+         * This function is called asynchronously (via setTimeout) to allow the SmartForm DOM to render
+         * before GroupElements are injected.
+         *
+         * @param {string} sId - the CustomData "id" value identifying the target SmartForm group
+         * @param {Array<string>} aFields - array of property names to render as SmartFields
+         * @param {string} sEasyFillMode - current layout mode (Condensed / ObjectPage) — for future use
+         * @param {object} oController - MVC controller (used to byId the ObjectPageLayout)
+         * @param {object} oTransientContextForEasyFill - transient OData context for AI-suggested values
+         * @param {object} oObjectPageContext - original ObjectPage binding context (current values)
+         * @param {object} mUpdatableLookupMap - map of { fieldName: value } for updatable fields only
+         * @param {object} oLLMData - flat map of { fieldName: aiValue } from the LLM response
+         * @returns {boolean} always returns true (used as a formatter return value in XML)
+         */
+        populateSmartFields: function(sId, aFields, sEasyFillMode, oController, oTransientContextForEasyFill, oObjectPageContext, mUpdatableLookupMap, oLLMData) {
+            var oObjectPageLayout = oController.byId("EasyFillObjectPageLayout");
+            if (!oObjectPageLayout || !Array.isArray(aFields) || aFields.length === 0) {
+                return true;
+            }
+
+            // Defer injection until after the SmartForm has rendered into the DOM
+            setTimeout(function() {
+                var oTargetGroup = null;
+
+                // Walk the ObjectPageLayout section hierarchy to find the group
+                // matching the given CustomData "id" value
+                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) {
+                                    var oMatchedCustomData = oGroup.getCustomData().find(function(oData) {
+                                        return oData.getKey() === "id" && oData.getValue() === sId;
+                                    });
+                                    if (oMatchedCustomData) {
+                                        oTargetGroup = oGroup;
+                                    }
+                                });
+                            }
+                        });
+                    });
+                });
+
+                if (!oTargetGroup) {
+                    oLogger.warning("populateSmartFields: no group found with id '" + sId + "'");
+                    return;
+                }
+
+                // Clear any previously rendered GroupElements before re-populating
+                oTargetGroup.destroyGroupElements();
+
+                aFields.forEach(function(sKey) {
+                    var bIsEditable = mUpdatableLookupMap && !!mUpdatableLookupMap[sKey];
+
+                    var oGroupElement = new GroupElement({
+                        useHorizontalLayout: false
+                    });
+
+                    /**
+                     * Primary SmartField:
+                     * - If editable: bound to transient context, shows AI-suggested value
+                     * - If non-editable: bound to OP context, display-only
+                     */
+                    var oSmartField = new SmartField({
+                        value: "{" + sKey + "}",
+                        editable: bIsEditable,
+                        enabled: bIsEditable,
+                        contextEditable: bIsEditable,
+                        layoutData: new ColumnElementData({
+                            cellsSmall: 12,
+                            cellsLarge: 12
+                        }),
+                        editableChanged: function(oEvent) {
+                            // Prevent the SmartField from toggling its own editability;
+                            // editability is controlled exclusively by EasyFill logic
+                            if (oEvent.getParameter("editable") !== bIsEditable) {
+                                oEvent.getSource().setEditable(bIsEditable);
+                            }
+                        }
+                    });
+
+                    /**
+                     * "Previously:" SmartField (read-only):
+                     * - Only shown for editable fields to display the current OP value for comparison
+                     * - Bound to the original ObjectPage context
+                     */
+                    var oSmartFieldPrev = new SmartField({
+                        value: "{" + sKey + "}",
+                        editable: false,
+                        enabled: false,
+                        contextEditable: false,
+                        showLabel: false,
+                        visible: bIsEditable,
+                        layoutData: new ColumnElementData({
+                            cellsSmall: 9,
+                            cellsLarge: 10
+                        }),
+                        editableChanged: function(oEvent) {
+                            // Always keep the "previously" field read-only
+                            if (oEvent.getParameter("editable") !== false) {
+                                oEvent.getSource().setEditable(false);
+                            }
+                        }
+                    });
+
+                    if (bIsEditable) {
+                        // Editable fields: primary field uses transient context (AI value),
+                        // preview field uses original OP context (current value)
+                        oSmartField.setBindingContext(oTransientContextForEasyFill);
+                        oSmartFieldPrev.setBindingContext(oObjectPageContext);
+
+                        // Set the AI-suggested value on the transient context for this field
+                        oTransientContextForEasyFill.setProperty(sKey, oLLMData[sKey]);
+                    } else {
+                        // Non-editable fields: bound to the original OP context, display only
+                        oSmartField.setBindingContext(oObjectPageContext);
+                    }
+
+                    // Build the GroupElement: [label+primary SmartField] [Previously: label] [preview SmartField]
+                    oGroupElement.addElement(oSmartField); // SmartField provides the label
+                    oGroupElement.addElement(new Text({
+                        text: "Previously:",
+                        visible: bIsEditable,
+                        layoutData: new ColumnElementData({
+                            cellsSmall: 3,
+                            cellsLarge: 2
+                        })
+                    }));
+                    oGroupElement.addElement(oSmartFieldPrev);
+                    oTargetGroup.addGroupElement(oGroupElement);
+                });
+
+                oLogger.debug("populateSmartFields: populated " + aFields.length + " fields for group '" + sId + "'");
+            }, 0);
+
+            return true;
+        },
+
+        /**
+         * Creates a new transient OData context for staging AI-suggested values.
+         * If a previous transient context exists, it is reset first.
+         *
+         * The transient context is created using a dedicated deferred group ("EasyFillFETransientChanges")
+         * so that no batch request is triggered to the backend until the user confirms via the dialog.
+         *
+         * @param {object} oTransientContextForEasyFill - current transient context (may be null)
+         * @param {object} oObjectPageModel - the OData model of the ObjectPage
+         * @param {object} oController - MVC controller (used to get the entity set name)
+         * @returns {object} the new transient OData context
+         */
+        makeTransientContext: function(oTransientContextForEasyFill, oObjectPageModel, oController) {
+            // Reset any existing transient context before creating a new one
+            if (oTransientContextForEasyFill) {
+                this.resetTransientContext(oTransientContextForEasyFill, oObjectPageModel);
+            }
+
+            var sEntitySet = oController.getOwnerComponent().getEntitySet();
+            var oNewContext = oObjectPageModel.createEntry("/" + sEntitySet, {
+                groupId: "EasyFillFETransientChanges",
+                changeSetId: "EasyFillFETransientChanges"
+            });
+
+            oLogger.debug("makeTransientContext: created transient context for entity set '" + sEntitySet + "'");
+            return oNewContext;
+        },
+
+        /**
+         * Rolls back the transient context, discarding all staged AI values without triggering a backend call.
+         * Called on dialog cancel or when a new AI submission replaces the previous result.
+         *
+         * @param {object} oTransientContextForEasyFill - the transient context to reset
+         * @param {object} oObjectPageModel - the OData model of the ObjectPage
+         */
+        resetTransientContext: function(oTransientContextForEasyFill, oObjectPageModel) {
+            if (oTransientContextForEasyFill) {
+                // Reset changes for the transient context path only, without triggering side effects
+                oObjectPageModel.resetChanges([oTransientContextForEasyFill.getPath()], false, true);
+                oLogger.debug("resetTransientContext: transient context reset");
+            }
+        }
+    };
+});