@sapui5/sap.fe.core 1.99.0 → 1.100.0

package/src/sap/fe/core/converters/controls/Common/table/StandardActions.ts

@@ -16,13 +16,21 @@ import {
 	not,
 	notEqual,
 	or,
-	greaterThan
+	greaterThan,
+	formatResult
 } from "sap/fe/core/helpers/BindingExpression";
-import { CreationMode, NavigationSettingsConfiguration, TemplateType, ViewPathConfiguration } from "../../../ManifestSettings";
+import { CreationMode, TemplateType, ViewPathConfiguration } from "../../../ManifestSettings";
 import { singletonPathVisitor, UI } from "../../../helpers/BindingHelper";
 import { PropertyAnnotationValue } from "@sap-ux/vocabularies-types";
 import { getTargetObjectPath, isPathDeletable, isPathInsertable, isPathUpdatable } from "sap/fe/core/templating/DataModelPathHelper";
 import { TableControlConfiguration } from "../Table";
+import tableFormatters from "sap/fe/core/formatters/TableFormatter";
+
+enum AnnotationHiddenProperty {
+	CreateHidden = "CreateHidden",
+	DeleteHidden = "DeleteHidden",
+	UpdateHidden = "UpdateHidden"
+}
 
 export type StandardActionConfigType = {
 	isTemplated?: BindingExpression<boolean>;
@@ -32,7 +40,7 @@ export type StandardActionConfigType = {
 
 type ExpressionRestrictionsType = {
 	expression: Expression<boolean>;
-	isOnlyCurrentEntityExpression: boolean;
+	navigationExpression: Expression<boolean>;
 };
 type StandardActionsRestrictionsType = Record<string, ExpressionRestrictionsType>;
 
@@ -43,7 +51,7 @@ export type StandardActionsContext = {
 		"delete": Expression<boolean>;
 		update: Expression<boolean>;
 	};
-	isExternalCreateConfigured: boolean;
+	creationMode: CreationMode;
 	isDraftOrStickySupported: boolean;
 	isViewWithMultipleVisualizations: boolean;
 	newAction?: {
@@ -58,26 +66,25 @@ export type StandardActionsContext = {
  * Generates the context for the standard actions.
  *
  * @param {ConverterContext} converterContext
- * @param {NavigationSettingsConfiguration} navigationSettings
+ * @param {NavigationSettingsConfiguration} creationMode
  * @param {TableControlConfiguration} tableManifestConfiguration
  * @param {ViewPathConfiguration} viewConfiguration
  * @returns  The context for table actions
  */
-
 export function generateStandardActionsContext(
 	converterContext: ConverterContext,
-	navigationSettings: NavigationSettingsConfiguration,
+	creationMode: CreationMode,
 	tableManifestConfiguration: TableControlConfiguration,
 	viewConfiguration?: ViewPathConfiguration
 ): StandardActionsContext {
 	return {
 		collectionPath: getTargetObjectPath(converterContext.getDataModelObjectPath()),
 		hiddenAnnotation: {
-			create: isActionAnnotatedHidden(converterContext, "CreateHidden"),
-			"delete": isActionAnnotatedHidden(converterContext, "DeleteHidden"),
-			update: isActionAnnotatedHidden(converterContext, "UpdateHidden")
+			create: isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.CreateHidden),
+			"delete": isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.DeleteHidden),
+			update: isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.UpdateHidden)
 		},
-		isExternalCreateConfigured: isExternalCreateConfigured(navigationSettings),
+		creationMode: creationMode,
 		isDraftOrStickySupported: isDraftOrStickySupported(converterContext),
 		isViewWithMultipleVisualizations: viewConfiguration
 			? converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration)
@@ -88,17 +95,6 @@ export function generateStandardActionsContext(
 	};
 }
 
-/**
- * Checks if an external created is configured for the navigation.
- *
- * @param {NavigationSettingsConfiguration} navigationSettings
- * @returns {boolean}
- */
-export function isExternalCreateConfigured(navigationSettings: NavigationSettingsConfiguration): boolean {
-	const navigation = navigationSettings?.create;
-	return (navigation && navigation.outbound && navigation.outboundDetail) !== undefined;
-}
-
 /**
  * Checks if draft is supported.
  *
@@ -163,22 +159,27 @@ export function getNewAction(converterContext: ConverterContext): any {
  *
  * @param {ConverterContext} converterContext
  * @param {string} sAnnotationTerm
+ * @param {boolean} bWithNavigationPath
  * @returns {Expression<boolean>}
  */
-export function isActionAnnotatedHidden(converterContext: ConverterContext, sAnnotationTerm: string): Expression<boolean> {
+export function isActionAnnotatedHidden(
+	converterContext: ConverterContext,
+	sAnnotationTerm: string,
+	bWithNavigationPath = true
+): Expression<boolean> {
 	const currentEntitySet = converterContext.getEntitySet();
 	const dataModelObjectPath = converterContext.getDataModelObjectPath();
 	// Consider only the last level of navigation. The others are already considered in the element binding of the page.
 	const visitedNavigationPaths =
-		dataModelObjectPath.navigationProperties.length > 0
+		dataModelObjectPath.navigationProperties.length > 0 && bWithNavigationPath
 			? [dataModelObjectPath.navigationProperties[dataModelObjectPath.navigationProperties.length - 1].name]
 			: [];
+	const actionAnnotationValue =
+		((currentEntitySet?.annotations.UI as any)?.[sAnnotationTerm] as PropertyAnnotationValue<boolean>) || false;
+
 	return currentEntitySet
-		? annotationExpression(
-				((currentEntitySet?.annotations.UI as any)?.[sAnnotationTerm] as PropertyAnnotationValue<boolean>) || false,
-				visitedNavigationPaths,
-				undefined,
-				(path: string) => singletonPathVisitor(path, converterContext, visitedNavigationPaths)
+		? annotationExpression(actionAnnotationValue, visitedNavigationPaths, undefined, (path: string) =>
+				singletonPathVisitor(path, converterContext.getConvertedTypes(), visitedNavigationPaths)
 		  )
 		: constant(false);
 }
@@ -209,9 +210,22 @@ export function getRestrictions(converterContext: ConverterContext): StandardAct
 	restrictionsDef.forEach(function(def) {
 		const defFunction = def["function"];
 		result[def.key] = {
-			expression: defFunction.apply(null, [dataModelObjectPath]),
-			isOnlyCurrentEntityExpression: !!(defFunction.apply(null, [dataModelObjectPath, undefined, true]) as any)
-				?.currentEntityRestriction
+			expression: defFunction.apply(null, [
+				dataModelObjectPath,
+				{
+					pathVisitor: (path: string, navigationPaths: string[]) =>
+						singletonPathVisitor(path, converterContext.getConvertedTypes(), navigationPaths)
+				}
+			]),
+			navigationExpression: defFunction.apply(null, [
+				dataModelObjectPath,
+				{
+					ignoreTargetCollection: true,
+					authorizeUnresolvable: true,
+					pathVisitor: (path: string, navigationPaths: string[]) =>
+						singletonPathVisitor(path, converterContext.getConvertedTypes(), navigationPaths)
+				}
+			])
 		};
 	});
 	return result;
@@ -230,7 +244,7 @@ export function getInsertUpdateActionsTemplating(
 	isDraftOrSticky: boolean,
 	isCreateAlwaysHidden: boolean
 ): boolean {
-	return (isDraftOrSticky || standardActionsContext.isExternalCreateConfigured) && !isCreateAlwaysHidden;
+	return (isDraftOrSticky || standardActionsContext.creationMode === CreationMode.External) && !isCreateAlwaysHidden;
 }
 
 /**
@@ -272,6 +286,24 @@ export function getStandardActionDelete(
 	};
 }
 
+/**
+ * @param converterContext
+ * @param standardActionsContext
+ * @returns StandardActionConfigType
+ */
+export function getCreationRow(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext
+): StandardActionConfigType {
+	const creationRowVisibility = getCreateVisibility(converterContext, standardActionsContext, true);
+
+	return {
+		isTemplated: compileBinding(getCreateTemplating(standardActionsContext, creationRowVisibility, true)),
+		visible: compileBinding(creationRowVisibility),
+		enabled: compileBinding(getCreationRowEnablement(converterContext, standardActionsContext, creationRowVisibility))
+	};
+}
+
 /**
  * Gets the binding expressions for the properties of the action Paste.
  *
@@ -319,39 +351,26 @@ export function getStandardActionMassEdit(
  *
  * @param {StandardActionsContext} standardActionsContext
  * @param {Expression<boolean>} createVisibility
+ * @param {boolean} isForCreationRow
  * @returns {Expression<boolean> }
  */
 export function getCreateTemplating(
 	standardActionsContext: StandardActionsContext,
-	createVisibility: Expression<boolean>
+	createVisibility: Expression<boolean>,
+	isForCreationRow = false
 ): Expression<boolean> {
-	const isCreationRow = standardActionsContext.tableManifestConfiguration.creationMode === CreationMode.CreationRow;
-	const newAction = standardActionsContext.newAction;
-	const isInsertable = standardActionsContext.restrictions.isInsertable.expression;
-
 	//Templating of Create Button is not done:
-	// 	 - If Button is never visible or CreationMode is on CreationRow
-	//   - Otherwise If new action is configured and never available
-	//	 - Otherwise If delete restrictions coming from NavigationRestrictions are constantly false
-	//   - Otherwise If there is no external create action
-	//	 - Otherwise if there is delete restrictions on the current entitySet set to false
+	// 	 - If Button is never visible(covered the External create button, new Action)
+	//	 - or CreationMode is on CreationRow for Create Button
+	//	 - or CreationMode is not on CreationRow for CreationRow Button
 
-	return ifElse(
-		or(and(isConstant(createVisibility), equal(createVisibility, false)), isCreationRow),
-		false,
-		ifElse(
-			and(isConstant(newAction?.available), equal(newAction?.available, false)),
-			false,
-			ifElse(
-				and(not(standardActionsContext.restrictions.isInsertable.isOnlyCurrentEntityExpression), isConstant(isInsertable)),
-				isInsertable,
-				ifElse(
-					standardActionsContext.isExternalCreateConfigured,
-					true,
-					not(and(isConstant(isInsertable), equal(isInsertable, constant(false))))
-				)
-			)
-		)
+	return and(
+		//XNOR gate
+		or(
+			and(isForCreationRow, standardActionsContext.creationMode === CreationMode.CreationRow),
+			and(!isForCreationRow, standardActionsContext.creationMode !== CreationMode.CreationRow)
+		),
+		or(not(isConstant(createVisibility)), createVisibility)
 	);
 }
 
@@ -362,7 +381,7 @@ export function getCreateTemplating(
  * @returns {Expression<boolean> }
  */
 export function getDefaultTemplating(actionVisibility: Expression<boolean>): Expression<boolean> {
-	return not(and(isConstant(actionVisibility), equal(actionVisibility, false)));
+	return or(not(isConstant(actionVisibility)), actionVisibility);
 }
 
 /**
@@ -370,14 +389,18 @@ export function getDefaultTemplating(actionVisibility: Expression<boolean>): Exp
  *
  * @param {ConverterContext} converterContext
  * @param {StandardActionsContext} standardActionsContext
+ * @param {boolean} isForCreationRow
  * @returns {Expression<boolean> }
  */
 export function getCreateVisibility(
 	converterContext: ConverterContext,
-	standardActionsContext: StandardActionsContext
+	standardActionsContext: StandardActionsContext,
+	isForCreationRow = false
 ): Expression<boolean> {
 	const isInsertable = standardActionsContext.restrictions.isInsertable.expression;
-	const isCreateHidden = standardActionsContext.hiddenAnnotation.create;
+	const isCreateHidden = isForCreationRow
+		? isActionAnnotatedHidden(converterContext, AnnotationHiddenProperty.CreateHidden, false)
+		: standardActionsContext.hiddenAnnotation.create;
 	const newAction = standardActionsContext.newAction;
 
 	//Create Button is visible:
@@ -391,12 +414,8 @@ export function getCreateVisibility(
 	// 	 	- Otherwise
 	// 	  	 - This depends on the value of the the UI.IsEditable
 	return ifElse(
-		standardActionsContext.isExternalCreateConfigured,
-		ifElse(
-			converterContext.getTemplateType() === TemplateType.ListReport,
-			not(isCreateHidden),
-			and(not(isCreateHidden), UI.IsEditable)
-		),
+		standardActionsContext.creationMode === CreationMode.External,
+		and(not(isCreateHidden), or(converterContext.getTemplateType() === TemplateType.ListReport, UI.IsEditable)),
 		ifElse(
 			or(
 				and(isConstant(newAction?.available), equal(newAction?.available, false)),
@@ -408,7 +427,7 @@ export function getCreateVisibility(
 			false,
 			ifElse(
 				converterContext.getTemplateType() === TemplateType.ListReport,
-				ifElse(isBinding(isCreateHidden), not(isCreateHidden), true),
+				or(not(isBinding(isCreateHidden)), not(isCreateHidden)),
 				and(not(isCreateHidden), UI.IsEditable)
 			)
 		)
@@ -454,7 +473,7 @@ export function getDeleteVisibility(
 				ifElse(
 					converterContext.getTemplateType() !== TemplateType.ListReport,
 					and(not(isDeleteHidden), equal(bindingExpression("/editMode", "ui"), "Editable")),
-					ifElse(isBinding(isDeleteHidden), not(isDeleteHidden), true)
+					not(and(isBinding(isDeleteHidden), isDeleteHidden))
 				)
 			)
 		)
@@ -479,15 +498,12 @@ export function getPasteVisibility(
 	// If Create is visible, enablePaste is not disabled into manifest and we are on OP/blocks outside Fiori elements templates
 	// Then button will be visible according to insertable restrictions and create visibility
 	// Otherwise it's not visible
-	return ifElse(
-		and(
-			notEqual(standardActionsContext.tableManifestConfiguration.enablePaste, false),
-			createVisibility,
-			isInsertUpdateActionsTemplated
-		),
-		[TemplateType.ListReport, TemplateType.AnalyticalListPage].indexOf(converterContext.getTemplateType()) === -1 &&
-			standardActionsContext.restrictions.isInsertable.expression,
-		false
+	return and(
+		notEqual(standardActionsContext.tableManifestConfiguration.enablePaste, false),
+		createVisibility,
+		isInsertUpdateActionsTemplated,
+		[TemplateType.ListReport, TemplateType.AnalyticalListPage].indexOf(converterContext.getTemplateType()) === -1,
+		standardActionsContext.restrictions.isInsertable.expression
 	);
 }
 
@@ -516,10 +532,59 @@ export function getMassEditVisibility(
 	//		- and the selectionMode is relevant
 	//	Then MassEdit is always visible in LR or dynamically visible in OP according to ui>Editable and hiddenAnnotation
 	//  Button is hidden for all other cases
-	return ifElse(
-		and(not(and(isConstant(pathUpdatableExpression), equal(pathUpdatableExpression, false))), bMassEditEnabledInManifest),
-		and(templateBindingExpression, not(isUpdateHidden)),
-		false
+	return and(
+		not(and(isConstant(pathUpdatableExpression), equal(pathUpdatableExpression, false))),
+		bMassEditEnabledInManifest,
+		templateBindingExpression,
+		not(isUpdateHidden)
+	);
+}
+
+/**
+ * Gets the binding expression for the property enabled of the creationRow.
+ *
+ * @param {ConverterContext} converterContext
+ * @param {StandardActionsContext} standardActionsContext
+ * @param {Expression<boolean>} creationRowVisibility
+ * @returns {Expression<boolean> }
+ */
+export function getCreationRowEnablement(
+	converterContext: ConverterContext,
+	standardActionsContext: StandardActionsContext,
+	creationRowVisibility: Expression<boolean>
+): Expression<boolean> {
+	const restrictionsInsertable = isPathInsertable(converterContext.getDataModelObjectPath(), {
+		ignoreTargetCollection: true,
+		authorizeUnresolvable: true,
+		pathVisitor: (path: string, navigationPaths: string[]) => {
+			if (path.indexOf("/") === 0) {
+				path = singletonPathVisitor(path, converterContext.getConvertedTypes(), navigationPaths);
+				return path;
+			}
+			const navigationProperties = converterContext.getDataModelObjectPath().navigationProperties;
+			if (navigationProperties) {
+				const partner = navigationProperties[navigationProperties.length - 1].partner;
+				if (partner) {
+					path = `${partner}/${path}`;
+				}
+			}
+			return path;
+		}
+	});
+	const isInsertable =
+		restrictionsInsertable._type === "Unresolvable"
+			? isPathInsertable(converterContext.getDataModelObjectPath(), {
+					pathVisitor: (path: string) => singletonPathVisitor(path, converterContext.getConvertedTypes(), [])
+			  })
+			: restrictionsInsertable;
+
+	return and(
+		creationRowVisibility,
+		isInsertable,
+		or(
+			!standardActionsContext.tableManifestConfiguration.disableAddRowButtonForEmptyData,
+			formatResult([bindingExpression("creationRowFieldValidity", "internal")], tableFormatters.validateCreationRowFields)
+		)
 	);
 }
 
@@ -540,13 +605,11 @@ export function getCreateEnablement(
 	const CollectionType = converterContext.resolveAbsolutePath<any>(standardActionsContext.collectionPath).target?._type;
 	return and(
 		createVisibility,
-		ifElse(
+		or(
 			CollectionType === "EntitySet",
-			true,
-			ifElse(
-				converterContext.getTemplateType() !== TemplateType.ObjectPage,
+			and(
 				isInsertable,
-				and(isInsertable, equal(bindingExpression("/editMode", "ui"), "Editable"))
+				or(converterContext.getTemplateType() !== TemplateType.ObjectPage, equal(bindingExpression("/editMode", "ui"), "Editable"))
 			)
 		)
 	);
@@ -567,7 +630,7 @@ export function getDeleteEnablement(
 ): Expression<boolean> {
 	const isDeletable = standardActionsContext.restrictions.isDeletable.expression;
 	const isOnlyDynamicOnCurrentEntity =
-		standardActionsContext.restrictions.isDeletable.isOnlyCurrentEntityExpression && !isConstant(isDeletable);
+		!isConstant(isDeletable) && standardActionsContext.restrictions.isDeletable.navigationExpression._type === "Unresolvable";
 	const numberOfSelectedContexts = bindingExpression("numberOfSelectedContexts", "internal");
 	const numberOfDeletableContexts = bindingExpression("deletableContexts", "internal");
 	const numberOfUnSavedContexts = bindingExpression("unSavedContexts", "internal");
@@ -576,13 +639,12 @@ export function getDeleteEnablement(
 		deleteVisibility,
 		ifElse(
 			or(converterContext.getTemplateType() !== TemplateType.ObjectPage, isOnlyDynamicOnCurrentEntity),
-			ifElse(
+			and(
 				or(
 					and(notEqual(numberOfDeletableContexts, undefined), greaterThan(length(numberOfDeletableContexts), 0)),
 					and(notEqual(numberOfUnSavedContexts, undefined), greaterThan(length(numberOfUnSavedContexts), 0))
 				),
-				bindingExpression("deleteEnabled", "internal"),
-				false
+				bindingExpression("deleteEnabled", "internal")
 			),
 			and(notEqual(numberOfSelectedContexts, 0), isDeletable)
 		)
@@ -615,7 +677,8 @@ export function getMassEditEnablement(
 ): Expression<boolean> {
 	const pathUpdatableExpression = standardActionsContext.restrictions.isUpdatable.expression;
 	const isOnlyDynamicOnCurrentEntity: any =
-		standardActionsContext.restrictions.isUpdatable.isOnlyCurrentEntityExpression && !isConstant(pathUpdatableExpression);
+		!isConstant(pathUpdatableExpression) &&
+		standardActionsContext.restrictions.isUpdatable.navigationExpression._type === "Unresolvable";
 	const numberOfSelectedContexts = greaterOrEqual(bindingExpression("numberOfSelectedContexts", "internal"), 1);
 	const numberOfUpdatableContexts = greaterOrEqual(length(bindingExpression("updatableContexts", "internal")), 1);
 	const bIsDraftSupported = isDraftSupported(converterContext);