@sapui5/sap.ushell_abap 1.152.1 → 1.154.0

package/src/main/js/sap/ushell_abap/components/tiles/action/ActionTile.controller.js

@@ -0,0 +1,189 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+
+sap.ui.define([
+    "sap/ui/core/mvc/Controller",
+    "sap/ushell/components/tiles/utils",
+    "sap/ui/model/json/JSONModel",
+    "sap/base/Log",
+    "sap/ushell/utils/LaunchpadError"
+], (Controller, tileUtils, JSONModel, Log, LaunchpadError) => {
+    "use strict";
+
+    return Controller.extend("sap.ushell_abap.components.tiles.action.ActionTile", {
+        onInit: function () {
+            const oView = this.getView();
+            const oViewData = oView.getViewData();
+            const oResourceModel = tileUtils.getResourceBundleModel();
+            const oTileApi = oViewData.chip; // instance
+            const oConfig = tileUtils.getActionConfiguration(oTileApi);
+            const that = this;
+
+            function formatDisplayText (sSemanticObject, sSemanticAction) {
+                const oBundle = tileUtils.getResourceBundle();
+                const sResult = `${oBundle.getText("configuration.semantic_object")}:\n${sSemanticObject}\n\n${
+                    oBundle.getText("configuration.semantic_action")}:\n${sSemanticAction}`;
+                return sResult;
+            }
+
+            oView.setModel(oResourceModel, "i18n");
+            const oModel = new JSONModel({
+                config: oConfig,
+                displayText: formatDisplayText(oConfig.semantic_object, oConfig.semantic_action)
+            });
+            oView.setModel(oModel);
+
+            // implement configurationUi contract: setup configuration UI
+            if (oTileApi.configurationUi.isEnabled()) {
+                // attach configuration UI provider, which is essentially a components.tiles.action.Configuration
+                oTileApi.configurationUi.setAsyncUiProvider(() => {
+                    return tileUtils.getConfigurationUi(
+                        that.getView(),
+                        "sap.ushell_abap.components.tiles.action.Configuration"
+                    ).then((oConfigurationUi) => {
+                        oTileApi.configurationUi.attachCancel(that.onCancelConfiguration.bind(null, oConfigurationUi));
+                        oTileApi.configurationUi.attachSave(that.onSaveConfiguration.bind(null, oConfigurationUi, formatDisplayText));
+                        return oConfigurationUi;
+                    });
+                });
+                oView.byId("actionTile").setTooltip(tileUtils.getResourceBundle().getText("edit_configuration.tooltip"));
+            }
+        },
+
+        onPress: function (oEvent) {
+            // trigger to show the configuration UI if the tile is pressed in Admin mode
+            const oTileApi = this.getView().getViewData().chip;
+            if (oTileApi.configurationUi.isEnabled()) {
+                oTileApi.configurationUi.display();
+            }
+        },
+
+        // configuration save handler
+        // The target mapping tile is enhanced with mapping_signature and supported form_factors properties.
+        onSaveConfiguration: async function (oConfigurationView, fnFormatDisplayText) {
+            let oModel = oConfigurationView.getModel();
+            // tile model placed into configuration model by getConfigurationUi
+            const oTileModel = oModel.getProperty("/tileModel");
+            const oTileApi = oConfigurationView.getViewData().chip;
+
+            // If the input fields icon, semantic object and action are failing the input validations, then through an error message requesting the
+            // user to enter/correct those fields
+            const bReject = tileUtils.checkTMInputOnSaveConfig(oConfigurationView);
+            if (bReject) {
+                throw new Error("mandatory_fields_missing");
+            }
+            // Before saving the model data, check if Mapping signature table contains duplicate parameter names
+            // in this case the save will fail and all the data will be lost as this is the designer behavior.
+            const oBundle = tileUtils.getResourceBundle();
+            if (tileUtils.tableHasDuplicateParameterNames(oModel.getProperty("/config/rows"))) {
+                throw new Error(oBundle.getText("configuration.signature.uniqueParamMessage.text"));
+            } else if (!tileUtils.tableHasInvalidSapPrelaunchOperationValue(oModel.getProperty("/config/rows"))) {
+                const sSapPrelaunchOperationsTemplate = JSON.stringify([{
+                    type: "split",
+                    source: "p1",
+                    target: ["p2", "p3"]
+                }, {
+                    type: "merge",
+                    source: ["p4", "p5"],
+                    target: "p6"
+                }]);
+                throw new Error(oBundle.getText("configuration.signature.invalidSapPrelaunchOperationsMessage.text", [sSapPrelaunchOperationsTemplate]));
+            }
+            // only if the data is valid proceed with the save operation
+            const oSaveDeferred = Promise.withResolvers();
+            // Decide according to special flag if the setting in form factor are default
+            // if so , the configuration should not be saved - this is crucial for the backend checks
+            const oFormFactor = oModel.getProperty("/config/formFactorConfigDefault") ? undefined : tileUtils.buildFormFactorsObject(oModel);
+            const sMappingSignature = tileUtils.getMappingSignatureString(oModel.getProperty("/config/rows"), oModel.getProperty("/config/isUnknownAllowed"));
+            const oMappingSignature = tileUtils.getMappingSignature(oModel.getProperty("/config/rows"), oModel.getProperty("/config/isUnknownAllowed"));
+            // get the configuration to save from the model
+            const configToSave = {
+                semantic_object: (oModel.getProperty("/config/semantic_object") || "").trim(),
+                semantic_action: (oModel.getProperty("/config/semantic_action") || "").trim(),
+                display_title_text: (oModel.getProperty("/config/display_title_text") || "").trim(),
+                url: (oModel.getProperty("/config/url") || "").trim(),
+                ui5_component: (oModel.getProperty("/config/ui5_component") || "").trim(),
+                navigation_provider: (oModel.getProperty("/config/navigation_provider") || "").trim(),
+                navigation_provider_role: (oModel.getProperty("/config/navigation_provider_role") || "").trim(),
+                navigation_provider_instance: (oModel.getProperty("/config/navigation_provider_instance") || "").trim(),
+                target_application_id: (oModel.getProperty("/config/target_application_id") || "").trim(),
+                target_application_alias: (oModel.getProperty("/config/target_application_alias") || "").trim(),
+                transaction: {
+                    code: (oModel.getProperty("/config/transaction/code") || "").trim()
+                },
+                web_dynpro: {
+                    application: (oModel.getProperty("/config/web_dynpro/application") || "").trim(),
+                    configuration: (oModel.getProperty("/config/web_dynpro/configuration") || "").trim()
+                },
+                target_system_alias: (oModel.getProperty("/config/target_system_alias") || "").trim(),
+                display_info_text: (oModel.getProperty("/config/display_info_text") || "").trim(),
+                form_factors: oFormFactor, // retrieve a structure describing form factor's mode (from application or admin selection) + form
+                // factors values.
+                mapping_signature: sMappingSignature,
+                signature: oMappingSignature
+            };
+            // use bag in order to store translatable properties
+            const tilePropertiesBag = oTileApi.bag.getBag("tileProperties");
+            tilePropertiesBag.setText("display_title_text", configToSave.display_title_text);
+
+            // use configuration contract to write parameter values
+            oTileApi.writeConfiguration.setParameterValues({
+                tileConfiguration: JSON.stringify(configToSave)
+            },
+            // success handler
+            () => {
+                const oConfigurationConfig = tileUtils.getActionConfiguration(oTileApi, false);
+                const oTileConfig = tileUtils.getActionConfiguration(oTileApi, true);
+                // switching the model under the tile -> keep the tile model
+                oModel = new JSONModel({
+                    config: oConfigurationConfig,
+                    tileModel: oTileModel
+                });
+                oConfigurationView.setModel(oModel);
+                // update model (no merge)
+                oTileModel.setData({
+                    config: oTileConfig,
+                    displayText: fnFormatDisplayText(oTileConfig.semantic_object, oTileConfig.semantic_action)
+                }, false);
+                // Added for new LPD_CUST implementation
+                tilePropertiesBag.save(
+                    // success handler
+                    () => {
+                        Log.debug("property bag 'tileProperties' saved successfully");
+                        oSaveDeferred.resolve();
+                    // fnFailure
+                    }, (mErrorMessages, mErrorInfo) => {
+                        const sFirstFailedBag = Object.keys(mErrorMessages)[0];
+
+                        const oError = new LaunchpadError(`Bag save failed: ${mErrorMessages[sFirstFailedBag]}`, {
+                            info: mErrorInfo[sFirstFailedBag],
+                            otherMessages: mErrorMessages,
+                            otherInfo: mErrorInfo
+                        });
+                        Log.error("property bag 'tileProperties' save failed", oError, "sap.ushell_abap.components.tiles.action.ActionTile.controller");
+                        oSaveDeferred.reject(oError);
+                    }
+                );
+            }, (sErrorMessage) => { // error handler
+                Log.error(`property bag 'tileProperties' save failed: ${sErrorMessage}`, null, "sap.ushell_abap.components.tiles.action.ActionTile.controller");
+                oSaveDeferred.reject(new Error(sErrorMessage));
+            });
+
+            return oSaveDeferred.promise;
+        },
+
+        // configuration cancel handler
+        onCancelConfiguration: function (oConfigurationView) {
+            // reload old configuration and display
+            const oViewData = oConfigurationView.getViewData();
+            const oModel = oConfigurationView.getModel();
+            // tile model placed into configuration model by getConfigurationUi
+            const oTileModel = oModel.getProperty("/tileModel");
+            const oTileApi = oViewData.chip;
+            const oCurrentConfig = tileUtils.getActionConfiguration(oTileApi, false);
+            oConfigurationView.getModel().setData({
+                config: oCurrentConfig,
+                tileModel: oTileModel
+            }, false);
+        }
+    });
+});

package/src/main/js/sap/ushell_abap/components/tiles/action/ActionTile.view.xml

@@ -0,0 +1,13 @@
+<View
+    xmlns="sap.ui.core.mvc"
+    xmlns:ushell="sap.ushell.ui.tile"
+    controllerName="sap.ushell_abap.components.tiles.action.ActionTile"
+    height="100%"
+    width="100%">
+    <ushell:TileBase
+        id="actionTile"
+        title="{i18n>tile.display.action_chip}"
+        subtitle="{/displayText}"
+        icon="sap-icon://action"
+        press="onPress" />
+</View>

package/src/main/js/sap/ushell_abap/components/tiles/action/Configuration.controller.js

@@ -0,0 +1,193 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+
+sap.ui.define([
+    "sap/ui/core/Element",
+    "sap/ui/core/mvc/Controller",
+    "sap/ushell/components/tiles/utils",
+    "sap/ui/core/library",
+    "sap/m/MessageBox"
+], (Element, Controller, tileUtils, coreLibrary, MessageBox) => {
+    "use strict";
+
+    // shortcut for sap.ui.core.ValueState
+    const ValueState = coreLibrary.ValueState;
+
+    return Controller.extend("sap.ushell_abap.components.tiles.action.Configuration", {
+        sEnterValuePlaceHolder: "",
+        sDuplicateErrorMsg: "",
+        sDuplicateErrorTitle: "",
+        sInvalidParmMsg: "",
+
+        aDefaultObjects: [
+            {
+                obj: "",
+                name: ""
+            }, {
+                obj: "*",
+                name: "*"
+            }
+        ],
+
+        onConfigurationInputChange: function (oControlEvent) {
+            tileUtils.checkTMInput(this.getView(), oControlEvent);
+        },
+        onInit: function () {
+            const oView = this.getView();
+            const oSemanticObjectSelector = oView.byId("semantic_objectInput");
+            const oRoleSelector = oView.byId("navigation_provider_roleInput");
+            const oInstanceSelector = oView.byId("navigation_provider_instanceInput");
+            const oAliasSelector = oView.byId("target_application_aliasInput");
+            const oActionSelector = oView.byId("semantic_actionInput");
+            const oTargetTypeSelector = oView.byId("targetTypeInput");
+            const oResourceModel = tileUtils.getResourceBundleModel();
+
+            oView.setModel(oResourceModel, "i18n");
+            oView.setViewName("sap.ushell.components.tiles.action.Configuration");
+            // initialize semantic object input field
+            tileUtils.createSemanticObjectModel(this, oSemanticObjectSelector, this.aDefaultObjects);
+            tileUtils.createRoleModel(this, oRoleSelector, oInstanceSelector);
+            tileUtils.createAliasModel(this, oAliasSelector);
+            tileUtils.createActionModel(this, oActionSelector);
+            tileUtils.createNavigationProviderModel(this, oTargetTypeSelector);
+            // make sure that the chose object is written back to the configuration
+            oSemanticObjectSelector.attachChange((oControlEvent) => {
+                const sValue = oControlEvent.getSource().getValue();
+                oView.getModel().setProperty("/config/semantic_object", sValue);
+            });
+            oRoleSelector.attachChange((oControlEvent) => {
+                const sValue = oControlEvent.getSource().getValue();
+                oView.getModel().setProperty("/config/navigation_provider_role", sValue);
+                tileUtils.updateAliasModel(oView, oAliasSelector);
+            });
+            oInstanceSelector.attachChange((oControlEvent) => {
+                const sValue = oControlEvent.getSource().getValue();
+                oView.getModel().setProperty("/config/navigation_provider_instance", sValue);
+            });
+            oAliasSelector.attachChange((oControlEvent) => {
+                const sValue = oControlEvent.getSource().getValue();
+                oView.getModel().setProperty("/config/target_application_alias", sValue);
+            });
+
+            const oBundle = tileUtils.getResourceBundle();
+            this.sEnterValuePlaceHolder = oBundle.getText("configuration.signature.table.valueFieldLbl");
+            this.sDuplicateErrorMsg = oBundle.getText("configuration.signature.uniqueParamMessage.text");
+            this.sDuplicateErrorTitle = oBundle.getText("configuration.signature.uniqueParamMessage.title");
+            this.sInvalidParmMsg = oBundle.getText("configuration.signature.invalidParamMessage.text");
+        },
+
+        // This function applies table logic for the mapping signature structure according to the Mandatory check-box:
+        // if mandatory is unselected: Value and isRegularExpression fields should be disabled and vice versa...
+        handleMandatoryChange: function (oMandatoryCheckBox) {
+            const sId = oMandatoryCheckBox.getParameter("id");
+            const aParentCells = Element.getElementById(sId).getParent().getCells();
+
+            const bIsMandatory = oMandatoryCheckBox.getParameter("selected");
+
+            if (bIsMandatory) {
+                aParentCells[2].setEnabled(true); // Value field
+                aParentCells[2].setPlaceholder(this.sEnterValuePlaceHolder);
+                aParentCells[4].setEnabled(false); // DefaultValue field
+                aParentCells[4].setValue("");
+                aParentCells[4].setPlaceholder("");
+                aParentCells[3].setEnabled(true); // IsRegularExpression check-box field
+            } else {
+                aParentCells[2].setEnabled(false); // Value field
+                aParentCells[2].setValue("");
+                aParentCells[2].setPlaceholder(""); // Were requested that a disabled text field will not show the Enter Value
+                aParentCells[4].setEnabled(true); // DefaultValue field
+                aParentCells[4].setPlaceholder(this.sEnterValuePlaceHolder);
+                aParentCells[3].setEnabled(false); // IsRegularExpression check-box field
+                aParentCells[3].setSelected(false);
+            }
+        },
+
+        addRow: function () {
+            const oView = this.getView();
+            const oModel = oView.getModel();
+            const rows = oModel.getProperty("/config/rows");
+
+            // Init a row template for adding new empty row to the params table (mapping signature)
+            const newParamRow = tileUtils.getEmptyRowObj();
+            rows.push(newParamRow);
+            oModel.setProperty("/config/rows", rows);
+        },
+
+        deleteRow: function () {
+            const oView = this.getView();
+            const oModel = oView.getModel();
+            const rows = oModel.getProperty("/config/rows");
+
+            const table = oView.byId("mappingSignatureTable");
+            const aSelectedItemsIndexes = table.getSelectedIndices();
+            const aSortedDescending = aSelectedItemsIndexes.sort((a, b) => {
+                return b - a;
+            }).slice();
+
+            for (let i = 0; i < aSortedDescending.length; i++) {
+                table.removeSelectionInterval(aSortedDescending[i], aSortedDescending[i]);// Make sure to turn off the selection or it will pass to
+                // the next row.
+                rows.splice(aSortedDescending[i], 1); // There is a major assumption here that the index in the model is identical to the index in
+                // the table !!!
+            }
+            oModel.setProperty("/config/rows", rows);
+        },
+        // Will be called on change event of the name column in Parameters table.
+        // 2 parameters cannot have the same name. (in case the user decide to ignore the error message, there is a second validation on the save)
+        checkDuplicateNames: function (changeEvent) {
+            const oModel = this.getView().getModel();
+            const rows = oModel.getProperty("/config/rows");
+            const nameCol = Element.getElementById(changeEvent.getParameter("id"));
+            const sNewValue = changeEvent.getParameter("newValue");
+
+            if (sNewValue !== "" && !(/^[\w-/]+$/.test(sNewValue))) {
+                nameCol.setValueState(ValueState.Error); MessageBox.alert(this.sInvalidParmMsg, this.focusNameField.bind(nameCol), this.sDuplicateErrorTitle);
+            }
+            if (tileUtils.tableHasDuplicateParameterNames(rows)) {
+                nameCol.setValueState(ValueState.Error); MessageBox.alert(this.sDuplicateErrorMsg, this.focusNameField.bind(nameCol), this.sDuplicateErrorTitle);
+            } else {
+                nameCol.setValueState(ValueState.None);
+            }
+        },
+        // a callback function for the duplicate error MessageBox
+        focusNameField: function () {
+            this.focus();
+        },
+
+        // forward value helper request to utils
+        onValueHelpRequest: function (oEvent) {
+            // Third parameter is to differentiate whether it's Tile Actions icon field or general icon field. If it's true, then it's tile actions
+            // icon field, else general icon field.
+            tileUtils.objectSelectOnValueHelpRequest(this, oEvent, false);
+        },
+        onActionValueHelpRequest: function (oEvent) {
+            tileUtils.actionSelectOnValueHelpRequest(this, oEvent);
+        },
+        onRoleValueHelpRequest: function (oEvent) {
+            tileUtils.roleSelectOnValueHelpRequest(this, oEvent);
+        },
+        onInstanceValueHelpRequest: function (oEvent) {
+            tileUtils.instanceSelectOnValueHelpRequest(this, oEvent);
+        },
+        instanceSuggest: function (oEvent) {
+            tileUtils.instanceSuggest(this, oEvent);
+        },
+        aliasSuggest: function (oEvent) {
+            tileUtils.aliasSuggest(this, oEvent);
+        },
+        onAliasValueHelpRequest: function (oEvent) {
+            tileUtils.applicationAliasSelectOnValueHelpRequest(this, oEvent);
+        },
+        onFormFactorChange: function () {
+            const oModel = this.getView().getModel();
+            oModel.setProperty("/config/formFactorConfigDefault", false);
+        },
+
+        // Will be called on change event of the application type radio buttons.
+        onApplicationTypeChange: function (oEvent) {
+            const oParameter = oEvent.getParameters();
+            if (oParameter.selectedItem) {
+                tileUtils.displayApplicationTypeFields(oParameter.selectedItem.getKey(), this.getView());
+            }
+        }
+    });
+});