@sap/open.fe 1.94.0

package/packages/sap.fe.core/src/sap/fe/core/converters/controls/Common/DataVisualization.ts

@@ -0,0 +1,296 @@
+import {
+	Chart,
+	ChartDefinitionTypeTypes,
+	EntityType,
+	LineItem,
+	PresentationVariantTypeTypes,
+	SelectionPresentationVariantTypeTypes,
+	SelectionVariantTypeTypes,
+	UIAnnotationTerms
+} from "@sap-ux/vocabularies-types";
+
+import { createDefaultTableVisualization, createTableVisualization, TableVisualization } from "./Table";
+import { ChartVisualization, createChartVisualization } from "./Chart";
+import { IssueType, IssueSeverity, IssueCategory } from "sap/fe/core/converters/helpers/IssueManager";
+import ConverterContext from "../../ConverterContext";
+import { TemplateType, ViewPathConfiguration } from "../../ManifestSettings";
+
+export type DataVisualizationAnnotations =
+	| LineItem
+	| Chart
+	| PresentationVariantTypeTypes
+	| SelectionVariantTypeTypes
+	| SelectionPresentationVariantTypeTypes;
+// | ChartDefinitionTypeTypes;
+
+export type ActualVisualizationAnnotations = LineItem | ChartDefinitionTypeTypes;
+
+type VisualizationAndPath = {
+	visualization: ActualVisualizationAnnotations;
+	annotationPath: string;
+	selectionVariantPath?: string;
+	converterContext: ConverterContext;
+};
+
+export type DataVisualizationDefinition = {
+	visualizations: (TableVisualization | ChartVisualization)[];
+	annotationPath: string;
+};
+
+const getVisualizationsFromPresentationVariant = function(
+	presentationVariantAnnotation: PresentationVariantTypeTypes,
+	visualizationPath: string,
+	converterContext: ConverterContext,
+	viewConfiguration?: ViewPathConfiguration
+): VisualizationAndPath[] {
+	const visualizationAnnotations: VisualizationAndPath[] = [];
+	const visualizations = presentationVariantAnnotation.Visualizations || [];
+	const baseVisualizationPath = visualizationPath.split("@")[0];
+	if (visualizations) {
+		// Only allow one line item / chart
+		let hasLineItem = false;
+		let hasChart = false;
+		let hasVisualization = false; // used to allow only first visualization in OP
+		visualizations.forEach(visualization => {
+			switch (visualization.$target.term) {
+				case UIAnnotationTerms.LineItem:
+					if (!hasLineItem) {
+						if (!(converterContext.getTemplateType() === TemplateType.ObjectPage && hasVisualization)) {
+							visualizationAnnotations.push({
+								visualization: visualization.$target as ActualVisualizationAnnotations,
+								annotationPath: `${baseVisualizationPath}${visualization.value}`,
+								converterContext: converterContext
+							});
+							hasLineItem = true;
+							hasVisualization = true;
+						}
+					}
+					break;
+				case UIAnnotationTerms.Chart:
+					if (
+						!hasChart &&
+						((viewConfiguration &&
+							converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration) &&
+							converterContext.getTemplateType() === TemplateType.ListReport) ||
+							(converterContext.getTemplateType() === TemplateType.AnalyticalListPage &&
+								!converterContext.getManifestWrapper().getViewConfiguration()) ||
+							(converterContext.getTemplateType() === TemplateType.ObjectPage && !hasVisualization))
+					) {
+						visualizationAnnotations.push({
+							visualization: visualization.$target as ActualVisualizationAnnotations,
+							annotationPath: `${baseVisualizationPath}${visualization.value}`,
+							converterContext: converterContext
+						});
+						hasChart = true;
+						hasVisualization = true;
+					}
+					break;
+				default:
+					break;
+			}
+		});
+	}
+	return visualizationAnnotations;
+};
+
+export function getSelectionPresentationVariant(
+	entityType: EntityType,
+	annotationPath: string | undefined,
+	converterContext: ConverterContext
+): any {
+	if (annotationPath) {
+		const resolvedTarget = converterContext.getEntityTypeAnnotation(annotationPath);
+		const selectionPresentationVariant = resolvedTarget.annotation as SelectionPresentationVariantTypeTypes;
+		if (selectionPresentationVariant) {
+			if (selectionPresentationVariant.term === UIAnnotationTerms.SelectionPresentationVariant) {
+				return selectionPresentationVariant;
+			}
+		} else {
+			throw new Error("Annotation Path for the SPV mentioned in the manifest is not found, Please add the SPV in the annotation");
+		}
+	} else {
+		return entityType.annotations?.UI?.SelectionPresentationVariant;
+	}
+}
+
+export function isSelectionPresentationCompliant(
+	SelectionPresentationVariant: SelectionPresentationVariantTypeTypes,
+	bIsALP: Boolean
+): Boolean | undefined {
+	const presentationVariant = SelectionPresentationVariant && SelectionPresentationVariant.PresentationVariant;
+	if (presentationVariant) {
+		return isPresentationCompliant(presentationVariant, bIsALP);
+	} else {
+		throw new Error("Presentation Variant is not present in the SPV annotation");
+	}
+}
+
+export function isPresentationCompliant(presentationVariant: PresentationVariantTypeTypes, bIsALP?: Boolean): Boolean {
+	let bHasTable = false,
+		bHasChart = false;
+	if (bIsALP) {
+		if (presentationVariant && presentationVariant.Visualizations) {
+			const aVisualizations = presentationVariant.Visualizations;
+			aVisualizations.map(oVisualization => {
+				if (oVisualization.$target.term === UIAnnotationTerms.LineItem) {
+					bHasTable = true;
+				}
+				if (oVisualization.$target.term === UIAnnotationTerms.Chart) {
+					bHasChart = true;
+				}
+			});
+		}
+		return bHasChart && bHasTable;
+	} else {
+		return (
+			presentationVariant &&
+			presentationVariant.Visualizations &&
+			!!presentationVariant.Visualizations.find(visualization => {
+				return visualization.$target.term === UIAnnotationTerms.LineItem;
+			})
+		);
+	}
+}
+
+export function getDefaultLineItem(entityType: EntityType): LineItem | undefined {
+	return entityType.annotations.UI?.LineItem;
+}
+export function getDefaultChart(entityType: EntityType): Chart | undefined {
+	return entityType.annotations.UI?.Chart;
+}
+export function getDefaultPresentationVariant(entityType: EntityType): PresentationVariantTypeTypes | undefined {
+	return entityType.annotations?.UI?.PresentationVariant;
+}
+
+export function getDefaultSelectionVariant(entityType: EntityType): SelectionVariantTypeTypes | undefined {
+	return entityType.annotations?.UI?.SelectionVariant;
+}
+
+export function getSelectionVariant(entityType: EntityType, converterContext: ConverterContext): SelectionVariantTypeTypes | undefined {
+	const annotationPath = converterContext.getManifestWrapper().getDefaultTemplateAnnotationPath();
+	const selectionPresentationVariant = getSelectionPresentationVariant(entityType, annotationPath, converterContext);
+	let selectionVariant;
+	if (selectionPresentationVariant) {
+		const selectionVariant = selectionPresentationVariant.SelectionVariant;
+		if (selectionVariant) {
+			return selectionVariant;
+		}
+	} else {
+		selectionVariant = getDefaultSelectionVariant(entityType);
+		return selectionVariant;
+	}
+}
+
+export function getDataVisualizationConfiguration(
+	visualizationPath: string,
+	isCondensedTableLayoutCompliant: boolean,
+	converterContext: ConverterContext,
+	viewConfiguration?: ViewPathConfiguration,
+	doNotCheckApplySupported?: boolean
+): DataVisualizationDefinition {
+	const resolvedTarget = converterContext.getEntityTypeAnnotation(visualizationPath);
+	const visualization = resolvedTarget.annotation as DataVisualizationAnnotations;
+	converterContext = resolvedTarget.converterContext;
+	let visualizationAnnotations: VisualizationAndPath[] = [];
+	let presentationVariantAnnotation: PresentationVariantTypeTypes;
+	let presentationPath: string = "";
+	let chartVisualization, tableVisualization;
+	const sTerm = visualization?.term;
+	if (sTerm) {
+		switch (sTerm) {
+			case UIAnnotationTerms.LineItem:
+			case UIAnnotationTerms.Chart:
+				visualizationAnnotations.push({
+					visualization: visualization as ActualVisualizationAnnotations,
+					annotationPath: visualizationPath,
+					converterContext: converterContext
+				});
+				break;
+			case UIAnnotationTerms.PresentationVariant:
+				presentationVariantAnnotation = visualization as PresentationVariantTypeTypes;
+				visualizationAnnotations = visualizationAnnotations.concat(
+					getVisualizationsFromPresentationVariant(
+						visualization as PresentationVariantTypeTypes,
+						visualizationPath,
+						converterContext,
+						viewConfiguration
+					)
+				);
+				break;
+			case UIAnnotationTerms.SelectionPresentationVariant:
+				presentationVariantAnnotation = (visualization as SelectionPresentationVariantTypeTypes).PresentationVariant;
+				// Presentation can be inline or outside the SelectionPresentationVariant
+				presentationPath = presentationVariantAnnotation.fullyQualifiedName;
+
+				if (!isPresentationCompliant(presentationVariantAnnotation)) {
+					const entityType = converterContext.getEntityType();
+					const defaultLineItemAnnotation = getDefaultLineItem(entityType) as LineItem;
+					if (defaultLineItemAnnotation) {
+						visualizationAnnotations.push({
+							visualization: defaultLineItemAnnotation,
+							annotationPath: converterContext.getRelativeAnnotationPath(
+								defaultLineItemAnnotation.fullyQualifiedName,
+								entityType
+							),
+							converterContext: converterContext
+						});
+					}
+				} else {
+					visualizationAnnotations = visualizationAnnotations.concat(
+						getVisualizationsFromPresentationVariant(
+							presentationVariantAnnotation,
+							visualizationPath,
+							converterContext,
+							viewConfiguration
+						)
+					);
+				}
+				break;
+			default:
+				break;
+		}
+		visualizationAnnotations.map(visualizationAnnotation => {
+			const { visualization, annotationPath, converterContext } = visualizationAnnotation;
+			switch (visualization.term) {
+				case UIAnnotationTerms.Chart:
+					chartVisualization = createChartVisualization(
+						visualization as ChartDefinitionTypeTypes,
+						annotationPath,
+						converterContext,
+						doNotCheckApplySupported
+					);
+					break;
+				case UIAnnotationTerms.LineItem:
+				default:
+					tableVisualization = createTableVisualization(
+						visualization as LineItem,
+						annotationPath,
+						converterContext,
+						presentationVariantAnnotation,
+						isCondensedTableLayoutCompliant,
+						viewConfiguration
+					);
+					break;
+			}
+		});
+	} else {
+		tableVisualization = createDefaultTableVisualization(converterContext);
+		converterContext.getDiagnostics().addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.MISSING_LINEITEM);
+	}
+	const aVisualizations: any = [];
+	let sPath =
+		sTerm === UIAnnotationTerms.SelectionPresentationVariant ? presentationPath : visualization && visualization.fullyQualifiedName;
+	if (sPath === undefined) {
+		sPath = "/";
+	}
+	if (chartVisualization) {
+		aVisualizations.push(chartVisualization);
+	}
+	if (tableVisualization) {
+		aVisualizations.push(tableVisualization);
+	}
+	return {
+		visualizations: aVisualizations,
+		annotationPath: converterContext.getEntitySetBasedAnnotationPath(sPath)
+	};
+}

package/packages/sap.fe.core/src/sap/fe/core/converters/controls/Common/Form-dbg.js

@@ -0,0 +1,222 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["../../helpers/ConfigurableObject", "../../helpers/ID", "../../helpers/Key", "sap/fe/core/converters/annotations/DataField", "sap/fe/core/templating/DataModelPathHelper", "../../../helpers/StableIdHelper"], function (ConfigurableObject, ID, Key, DataField, DataModelPathHelper, StableIdHelper) {
+  "use strict";
+
+  var _exports = {};
+  var generate = StableIdHelper.generate;
+  var getTargetObjectPath = DataModelPathHelper.getTargetObjectPath;
+  var getTargetEntitySetPath = DataModelPathHelper.getTargetEntitySetPath;
+  var getSemanticObjectPath = DataField.getSemanticObjectPath;
+  var KeyHelper = Key.KeyHelper;
+  var FormID = ID.FormID;
+  var Placement = ConfigurableObject.Placement;
+  var insertCustomElements = ConfigurableObject.insertCustomElements;
+
+  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+  var FormElementType;
+
+  (function (FormElementType) {
+    FormElementType["Default"] = "Default";
+    FormElementType["Annotation"] = "Annotation";
+  })(FormElementType || (FormElementType = {}));
+
+  _exports.FormElementType = FormElementType;
+
+  /**
+   * Returns default format options for text fields on a form.
+   *
+   * @returns {FormatOptionsType} Collection of format options with default values
+   */
+  function getDefaultFormatOptionsForForm() {
+    return {
+      textLinesEdit: 4
+    };
+  }
+
+  function getFormElementsFromAnnotations(facetDefinition, converterContext) {
+    var formElements = [];
+    var resolvedTarget = converterContext.getEntityTypeAnnotation(facetDefinition.Target.value);
+    var formAnnotation = resolvedTarget.annotation;
+    converterContext = resolvedTarget.converterContext;
+
+    function getDataFieldsFromAnnotations(field) {
+      var _field$annotations, _field$annotations$UI, _field$annotations$UI2;
+
+      var semanticObjectAnnotationPath = getSemanticObjectPath(converterContext, field);
+
+      if (field.$Type !== "com.sap.vocabularies.UI.v1.DataFieldForAction" && field.$Type !== "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation" && ((_field$annotations = field.annotations) === null || _field$annotations === void 0 ? void 0 : (_field$annotations$UI = _field$annotations.UI) === null || _field$annotations$UI === void 0 ? void 0 : (_field$annotations$UI2 = _field$annotations$UI.Hidden) === null || _field$annotations$UI2 === void 0 ? void 0 : _field$annotations$UI2.valueOf()) !== true) {
+        formElements.push({
+          key: KeyHelper.generateKeyFromDataField(field),
+          type: FormElementType.Annotation,
+          annotationPath: converterContext.getEntitySetBasedAnnotationPath(field.fullyQualifiedName) + "/",
+          semanticObjectPath: semanticObjectAnnotationPath,
+          formatOptions: getDefaultFormatOptionsForForm()
+        });
+      }
+    }
+
+    switch (formAnnotation === null || formAnnotation === void 0 ? void 0 : formAnnotation.term) {
+      case "com.sap.vocabularies.UI.v1.FieldGroup":
+        formAnnotation.Data.forEach(getDataFieldsFromAnnotations);
+        break;
+
+      case "com.sap.vocabularies.UI.v1.Identification":
+        formAnnotation.forEach(getDataFieldsFromAnnotations);
+        break;
+
+      case "com.sap.vocabularies.UI.v1.DataPoint":
+        formElements.push({
+          // key: KeyHelper.generateKeyFromDataField(formAnnotation),
+          key: "DataPoint::" + (formAnnotation.qualifier ? formAnnotation.qualifier : ""),
+          type: FormElementType.Annotation,
+          annotationPath: converterContext.getEntitySetBasedAnnotationPath(formAnnotation.fullyQualifiedName) + "/"
+        });
+        break;
+
+      case "com.sap.vocabularies.Communication.v1.Contact":
+        formElements.push({
+          // key: KeyHelper.generateKeyFromDataField(formAnnotation),
+          key: "Contact::" + (formAnnotation.qualifier ? formAnnotation.qualifier : ""),
+          type: FormElementType.Annotation,
+          annotationPath: converterContext.getEntitySetBasedAnnotationPath(formAnnotation.fullyQualifiedName) + "/"
+        });
+        break;
+
+      default:
+        break;
+    }
+
+    return formElements;
+  }
+
+  function getFormElementsFromManifest(facetDefinition, converterContext) {
+    var manifestWrapper = converterContext.getManifestWrapper();
+    var manifestFormContainer = manifestWrapper.getFormContainer(facetDefinition.Target.value);
+    var formElements = {};
+
+    if (manifestFormContainer !== null && manifestFormContainer !== void 0 && manifestFormContainer.fields) {
+      Object.keys(manifestFormContainer === null || manifestFormContainer === void 0 ? void 0 : manifestFormContainer.fields).forEach(function (fieldId) {
+        formElements[fieldId] = {
+          key: fieldId,
+          type: FormElementType.Default,
+          template: manifestFormContainer.fields[fieldId].template,
+          label: manifestFormContainer.fields[fieldId].label,
+          position: manifestFormContainer.fields[fieldId].position || {
+            placement: Placement.After
+          },
+          formatOptions: _objectSpread(_objectSpread({}, getDefaultFormatOptionsForForm()), manifestFormContainer.fields[fieldId].formatOptions)
+        };
+      });
+    }
+
+    return formElements;
+  }
+
+  _exports.getFormElementsFromManifest = getFormElementsFromManifest;
+
+  function getFormContainer(facetDefinition, converterContext, actions) {
+    var _resolvedTarget$conve;
+
+    //TODO form container id
+    var resolvedTarget = converterContext.getEntityTypeAnnotation(facetDefinition.Target.value);
+    var sEntitySetPath; // resolvedTarget doesn't have a entitySet in case Containments and Paramterized services.
+
+    if (resolvedTarget.converterContext.getEntitySet() && resolvedTarget.converterContext.getEntitySet() !== converterContext.getEntitySet()) {
+      sEntitySetPath = getTargetEntitySetPath(resolvedTarget.converterContext.getDataModelObjectPath());
+    } else if (((_resolvedTarget$conve = resolvedTarget.converterContext.getDataModelObjectPath().targetObject) === null || _resolvedTarget$conve === void 0 ? void 0 : _resolvedTarget$conve.containsTarget) === true) {
+      sEntitySetPath = getTargetObjectPath(resolvedTarget.converterContext.getDataModelObjectPath(), false);
+    }
+
+    actions = actions !== undefined ? actions.filter(function (action) {
+      return action.facetName == facetDefinition.fullyQualifiedName;
+    }) : [];
+
+    if (actions.length === 0) {
+      actions = undefined;
+    }
+
+    return {
+      id: generate([{
+        Facet: facetDefinition
+      }]),
+      formElements: insertCustomElements(getFormElementsFromAnnotations(facetDefinition, converterContext), getFormElementsFromManifest(facetDefinition, converterContext), {
+        formatOptions: "overwrite"
+      }),
+      annotationPath: "/" + facetDefinition.fullyQualifiedName,
+      entitySet: sEntitySetPath,
+      actions: actions
+    };
+  }
+
+  _exports.getFormContainer = getFormContainer;
+
+  function getFormContainersForCollection(facetDefinition, converterContext, actions) {
+    var _facetDefinition$Face;
+
+    var formContainers = []; //TODO coll facet inside coll facet?
+
+    (_facetDefinition$Face = facetDefinition.Facets) === null || _facetDefinition$Face === void 0 ? void 0 : _facetDefinition$Face.forEach(function (facet) {
+      // Ignore level 3 collection facet
+      if (facet.$Type === "com.sap.vocabularies.UI.v1.CollectionFacet") {
+        return;
+      }
+
+      formContainers.push(getFormContainer(facet, converterContext, actions));
+    });
+    return formContainers;
+  }
+
+  function isReferenceFacet(facetDefinition) {
+    return facetDefinition.$Type === "com.sap.vocabularies.UI.v1.ReferenceFacet";
+  }
+
+  _exports.isReferenceFacet = isReferenceFacet;
+
+  function createFormDefinition(facetDefinition, converterContext, actions) {
+    var _facetDefinition$anno, _facetDefinition$anno2, _facetDefinition$anno3;
+
+    switch (facetDefinition.$Type) {
+      case "com.sap.vocabularies.UI.v1.CollectionFacet":
+        // Keep only valid children
+        var formCollectionDefinition = {
+          id: FormID({
+            Facet: facetDefinition
+          }),
+          useFormContainerLabels: true,
+          hasFacetsNotPartOfPreview: facetDefinition.Facets.some(function (childFacet) {
+            var _childFacet$annotatio, _childFacet$annotatio2, _childFacet$annotatio3;
+
+            return ((_childFacet$annotatio = childFacet.annotations) === null || _childFacet$annotatio === void 0 ? void 0 : (_childFacet$annotatio2 = _childFacet$annotatio.UI) === null || _childFacet$annotatio2 === void 0 ? void 0 : (_childFacet$annotatio3 = _childFacet$annotatio2.PartOfPreview) === null || _childFacet$annotatio3 === void 0 ? void 0 : _childFacet$annotatio3.valueOf()) === false;
+          }),
+          formContainers: getFormContainersForCollection(facetDefinition, converterContext, actions)
+        };
+        return formCollectionDefinition;
+
+      case "com.sap.vocabularies.UI.v1.ReferenceFacet":
+        var formDefinition = {
+          id: FormID({
+            Facet: facetDefinition
+          }),
+          useFormContainerLabels: false,
+          hasFacetsNotPartOfPreview: ((_facetDefinition$anno = facetDefinition.annotations) === null || _facetDefinition$anno === void 0 ? void 0 : (_facetDefinition$anno2 = _facetDefinition$anno.UI) === null || _facetDefinition$anno2 === void 0 ? void 0 : (_facetDefinition$anno3 = _facetDefinition$anno2.PartOfPreview) === null || _facetDefinition$anno3 === void 0 ? void 0 : _facetDefinition$anno3.valueOf()) === false,
+          formContainers: [getFormContainer(facetDefinition, converterContext, actions)]
+        };
+        return formDefinition;
+
+      default:
+        throw new Error("Cannot create form based on ReferenceURLFacet");
+    }
+  }
+
+  _exports.createFormDefinition = createFormDefinition;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Form.ts"],"names":["FormElementType","getDefaultFormatOptionsForForm","textLinesEdit","getFormElementsFromAnnotations","facetDefinition","converterContext","formElements","resolvedTarget","getEntityTypeAnnotation","Target","value","formAnnotation","annotation","getDataFieldsFromAnnotations","field","semanticObjectAnnotationPath","getSemanticObjectPath","$Type","annotations","UI","Hidden","valueOf","push","key","KeyHelper","generateKeyFromDataField","type","Annotation","annotationPath","getEntitySetBasedAnnotationPath","fullyQualifiedName","semanticObjectPath","formatOptions","term","Data","forEach","qualifier","getFormElementsFromManifest","manifestWrapper","getManifestWrapper","manifestFormContainer","getFormContainer","fields","Object","keys","fieldId","Default","template","label","position","placement","Placement","After","actions","sEntitySetPath","getEntitySet","getTargetEntitySetPath","getDataModelObjectPath","targetObject","containsTarget","getTargetObjectPath","undefined","filter","action","facetName","length","id","generate","Facet","insertCustomElements","entitySet","getFormContainersForCollection","formContainers","Facets","facet","isReferenceFacet","createFormDefinition","formCollectionDefinition","FormID","useFormContainerLabels","hasFacetsNotPartOfPreview","some","childFacet","PartOfPreview","formDefinition","Error"],"mappings":"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","sourceRoot":".","sourcesContent":["import {\n\tAnnotationTerm,\n\tCollectionFacetTypes,\n\tCommunicationAnnotationTerms,\n\tDataFieldAbstractTypes,\n\tFacetTypes,\n\tFieldGroup,\n\tIdentification,\n\tReferenceFacetTypes,\n\tUIAnnotationTerms,\n\tUIAnnotationTypes\n} from \"@sap-ux/vocabularies-types\";\nimport { BindingExpression } from \"sap/fe/core/helpers/BindingExpression\";\nimport { ConfigurableObject, CustomElement, insertCustomElements, Placement } from \"../../helpers/ConfigurableObject\";\nimport { FormID } from \"../../helpers/ID\";\nimport { KeyHelper } from \"../../helpers/Key\";\nimport { FormManifestConfiguration, FormatOptionsType } from \"../../ManifestSettings\";\nimport { getSemanticObjectPath } from \"sap/fe/core/converters/annotations/DataField\";\nimport { getTargetEntitySetPath, getTargetObjectPath } from \"sap/fe/core/templating/DataModelPathHelper\";\nimport { generate } from \"../../../helpers/StableIdHelper\";\nimport ConverterContext from \"../../ConverterContext\";\nimport { BaseAction, ConverterAction } from \"sap/fe/core/converters/controls/Common/Action\";\n\nexport type FormDefinition = {\n\tid: string;\n\tuseFormContainerLabels: boolean;\n\thasFacetsNotPartOfPreview: boolean;\n};\n\nexport enum FormElementType {\n\tDefault = \"Default\",\n\tAnnotation = \"Annotation\"\n}\n\nexport type BaseFormElement = ConfigurableObject & {\n\ttype: FormElementType;\n\tlabel?: string;\n\tvisible?: BindingExpression<boolean>;\n\tformatOptions?: FormatOptionsType;\n};\n\nexport type AnnotationFormElement = BaseFormElement & {\n\tidPrefix?: string;\n\tannotationPath?: string;\n\tisValueMultilineText?: boolean;\n\tsemanticObjectPath?: string;\n};\n\nexport type CustomFormElement = CustomElement<\n\tBaseFormElement & {\n\t\ttype: FormElementType.Default;\n\t\ttemplate: string;\n\t}\n>;\n\nexport type FormElement = CustomFormElement | AnnotationFormElement;\n\ntype FormContainer = {\n\tid?: string;\n\tformElements: FormElement[];\n\tannotationPath: string;\n\tentitySet?: string;\n\tactions?: ConverterAction[] | BaseAction[];\n};\n\n/**\n * Returns default format options for text fields on a form.\n *\n * @returns {FormatOptionsType} Collection of format options with default values\n */\nfunction getDefaultFormatOptionsForForm(): FormatOptionsType {\n\treturn {\n\t\ttextLinesEdit: 4\n\t};\n}\n\nfunction getFormElementsFromAnnotations(facetDefinition: ReferenceFacetTypes, converterContext: ConverterContext): AnnotationFormElement[] {\n\tconst formElements: AnnotationFormElement[] = [];\n\tconst resolvedTarget = converterContext.getEntityTypeAnnotation(facetDefinition.Target.value);\n\tconst formAnnotation: AnnotationTerm<Identification> | AnnotationTerm<FieldGroup> = resolvedTarget.annotation as\n\t\t| AnnotationTerm<Identification>\n\t\t| AnnotationTerm<FieldGroup>;\n\tconverterContext = resolvedTarget.converterContext;\n\n\tfunction getDataFieldsFromAnnotations(field: DataFieldAbstractTypes) {\n\t\tconst semanticObjectAnnotationPath = getSemanticObjectPath(converterContext, field);\n\t\tif (\n\t\t\tfield.$Type !== UIAnnotationTypes.DataFieldForAction &&\n\t\t\tfield.$Type !== UIAnnotationTypes.DataFieldForIntentBasedNavigation &&\n\t\t\tfield.annotations?.UI?.Hidden?.valueOf() !== true\n\t\t) {\n\t\t\tformElements.push({\n\t\t\t\tkey: KeyHelper.generateKeyFromDataField(field),\n\t\t\t\ttype: FormElementType.Annotation,\n\t\t\t\tannotationPath: converterContext.getEntitySetBasedAnnotationPath(field.fullyQualifiedName) + \"/\",\n\t\t\t\tsemanticObjectPath: semanticObjectAnnotationPath,\n\t\t\t\tformatOptions: getDefaultFormatOptionsForForm()\n\t\t\t});\n\t\t}\n\t}\n\n\tswitch (formAnnotation?.term) {\n\t\tcase UIAnnotationTerms.FieldGroup:\n\t\t\t(formAnnotation as AnnotationTerm<FieldGroup>).Data.forEach(getDataFieldsFromAnnotations);\n\t\t\tbreak;\n\t\tcase UIAnnotationTerms.Identification:\n\t\t\t(formAnnotation as AnnotationTerm<Identification>).forEach(getDataFieldsFromAnnotations);\n\t\t\tbreak;\n\t\tcase UIAnnotationTerms.DataPoint:\n\t\t\tformElements.push({\n\t\t\t\t// key: KeyHelper.generateKeyFromDataField(formAnnotation),\n\t\t\t\tkey: \"DataPoint::\" + (formAnnotation.qualifier ? formAnnotation.qualifier : \"\"),\n\t\t\t\ttype: FormElementType.Annotation,\n\t\t\t\tannotationPath: converterContext.getEntitySetBasedAnnotationPath(formAnnotation.fullyQualifiedName) + \"/\"\n\t\t\t});\n\t\t\tbreak;\n\t\tcase CommunicationAnnotationTerms.Contact:\n\t\t\tformElements.push({\n\t\t\t\t// key: KeyHelper.generateKeyFromDataField(formAnnotation),\n\t\t\t\tkey: \"Contact::\" + (formAnnotation.qualifier ? formAnnotation.qualifier : \"\"),\n\t\t\t\ttype: FormElementType.Annotation,\n\t\t\t\tannotationPath: converterContext.getEntitySetBasedAnnotationPath(formAnnotation.fullyQualifiedName) + \"/\"\n\t\t\t});\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tbreak;\n\t}\n\treturn formElements;\n}\n\nexport function getFormElementsFromManifest(\n\tfacetDefinition: ReferenceFacetTypes,\n\tconverterContext: ConverterContext\n): Record<string, CustomFormElement> {\n\tconst manifestWrapper = converterContext.getManifestWrapper();\n\tconst manifestFormContainer: FormManifestConfiguration = manifestWrapper.getFormContainer(facetDefinition.Target.value);\n\tconst formElements: Record<string, CustomFormElement> = {};\n\tif (manifestFormContainer?.fields) {\n\t\tObject.keys(manifestFormContainer?.fields).forEach(fieldId => {\n\t\t\tformElements[fieldId] = {\n\t\t\t\tkey: fieldId,\n\t\t\t\ttype: FormElementType.Default,\n\t\t\t\ttemplate: manifestFormContainer.fields[fieldId].template,\n\t\t\t\tlabel: manifestFormContainer.fields[fieldId].label,\n\t\t\t\tposition: manifestFormContainer.fields[fieldId].position || {\n\t\t\t\t\tplacement: Placement.After\n\t\t\t\t},\n\t\t\t\tformatOptions: {\n\t\t\t\t\t...getDefaultFormatOptionsForForm(),\n\t\t\t\t\t...manifestFormContainer.fields[fieldId].formatOptions\n\t\t\t\t}\n\t\t\t};\n\t\t});\n\t}\n\treturn formElements;\n}\n\nexport function getFormContainer(\n\tfacetDefinition: ReferenceFacetTypes,\n\tconverterContext: ConverterContext,\n\tactions: BaseAction[] | ConverterAction[] | undefined\n): FormContainer {\n\t//TODO form container id\n\tconst resolvedTarget = converterContext.getEntityTypeAnnotation(facetDefinition.Target.value);\n\tlet sEntitySetPath!: string;\n\t// resolvedTarget doesn't have a entitySet in case Containments and Paramterized services.\n\tif (\n\t\tresolvedTarget.converterContext.getEntitySet() &&\n\t\tresolvedTarget.converterContext.getEntitySet() !== converterContext.getEntitySet()\n\t) {\n\t\tsEntitySetPath = getTargetEntitySetPath(resolvedTarget.converterContext.getDataModelObjectPath());\n\t} else if (resolvedTarget.converterContext.getDataModelObjectPath().targetObject?.containsTarget === true) {\n\t\tsEntitySetPath = getTargetObjectPath(resolvedTarget.converterContext.getDataModelObjectPath(), false);\n\t}\n\tactions = actions !== undefined ? actions.filter(action => action.facetName == facetDefinition.fullyQualifiedName) : [];\n\tif (actions.length === 0) {\n\t\tactions = undefined;\n\t}\n\treturn {\n\t\tid: generate([{ Facet: facetDefinition }]),\n\t\tformElements: insertCustomElements(\n\t\t\tgetFormElementsFromAnnotations(facetDefinition, converterContext),\n\t\t\tgetFormElementsFromManifest(facetDefinition, converterContext),\n\t\t\t{ formatOptions: \"overwrite\" }\n\t\t),\n\t\tannotationPath: \"/\" + facetDefinition.fullyQualifiedName,\n\t\tentitySet: sEntitySetPath,\n\t\tactions: actions\n\t};\n}\n\nfunction getFormContainersForCollection(\n\tfacetDefinition: CollectionFacetTypes,\n\tconverterContext: ConverterContext,\n\tactions: BaseAction[] | ConverterAction[]\n): FormContainer[] {\n\tconst formContainers: FormContainer[] = [];\n\t//TODO coll facet inside coll facet?\n\tfacetDefinition.Facets?.forEach(facet => {\n\t\t// Ignore level 3 collection facet\n\t\tif (facet.$Type === UIAnnotationTypes.CollectionFacet) {\n\t\t\treturn;\n\t\t}\n\t\tformContainers.push(getFormContainer(facet as ReferenceFacetTypes, converterContext, actions));\n\t});\n\treturn formContainers;\n}\n\nexport function isReferenceFacet(facetDefinition: FacetTypes): facetDefinition is ReferenceFacetTypes {\n\treturn facetDefinition.$Type === UIAnnotationTypes.ReferenceFacet;\n}\n\nexport function createFormDefinition(\n\tfacetDefinition: FacetTypes,\n\tconverterContext: ConverterContext,\n\tactions: BaseAction[] | ConverterAction[]\n): FormDefinition {\n\tswitch (facetDefinition.$Type) {\n\t\tcase UIAnnotationTypes.CollectionFacet:\n\t\t\t// Keep only valid children\n\t\t\tconst formCollectionDefinition = {\n\t\t\t\tid: FormID({ Facet: facetDefinition }),\n\t\t\t\tuseFormContainerLabels: true,\n\t\t\t\thasFacetsNotPartOfPreview: facetDefinition.Facets.some(\n\t\t\t\t\tchildFacet => childFacet.annotations?.UI?.PartOfPreview?.valueOf() === false\n\t\t\t\t),\n\t\t\t\tformContainers: getFormContainersForCollection(facetDefinition, converterContext, actions)\n\t\t\t};\n\t\t\treturn formCollectionDefinition;\n\t\tcase UIAnnotationTypes.ReferenceFacet:\n\t\t\tconst formDefinition = {\n\t\t\t\tid: FormID({ Facet: facetDefinition }),\n\t\t\t\tuseFormContainerLabels: false,\n\t\t\t\thasFacetsNotPartOfPreview: facetDefinition.annotations?.UI?.PartOfPreview?.valueOf() === false,\n\t\t\t\tformContainers: [getFormContainer(facetDefinition, converterContext, actions)]\n\t\t\t};\n\t\t\treturn formDefinition;\n\t\tdefault:\n\t\t\tthrow new Error(\"Cannot create form based on ReferenceURLFacet\");\n\t}\n}\n"]}

package/packages/sap.fe.core/src/sap/fe/core/converters/controls/Common/Form.js

@@ -0,0 +1,5 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["../../helpers/ConfigurableObject","../../helpers/ID","../../helpers/Key","sap/fe/core/converters/annotations/DataField","sap/fe/core/templating/DataModelPathHelper","../../../helpers/StableIdHelper"],function(C,I,K,D,a,S){"use strict";var _={};var g=S.generate;var b=a.getTargetObjectPath;var c=a.getTargetEntitySetPath;var d=D.getSemanticObjectPath;var e=K.KeyHelper;var F=I.FormID;var P=C.Placement;var f=C.insertCustomElements;function o(i,t){var u=Object.keys(i);if(Object.getOwnPropertySymbols){var v=Object.getOwnPropertySymbols(i);if(t){v=v.filter(function(w){return Object.getOwnPropertyDescriptor(i,w).enumerable;});}u.push.apply(u,v);}return u;}function h(t){for(var i=1;i<arguments.length;i++){var u=arguments[i]!=null?arguments[i]:{};if(i%2){o(Object(u),true).forEach(function(v){j(t,v,u[v]);});}else if(Object.getOwnPropertyDescriptors){Object.defineProperties(t,Object.getOwnPropertyDescriptors(u));}else{o(Object(u)).forEach(function(v){Object.defineProperty(t,v,Object.getOwnPropertyDescriptor(u,v));});}}return t;}function j(i,t,v){if(t in i){Object.defineProperty(i,t,{value:v,enumerable:true,configurable:true,writable:true});}else{i[t]=v;}return i;}var k;(function(k){k["Default"]="Default";k["Annotation"]="Annotation";})(k||(k={}));_.FormElementType=k;function l(){return{textLinesEdit:4};}function m(i,t){var u=[];var v=t.getEntityTypeAnnotation(i.Target.value);var w=v.annotation;t=v.converterContext;function x(y){var z,A,B;var E=d(t,y);if(y.$Type!=="com.sap.vocabularies.UI.v1.DataFieldForAction"&&y.$Type!=="com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation"&&((z=y.annotations)===null||z===void 0?void 0:(A=z.UI)===null||A===void 0?void 0:(B=A.Hidden)===null||B===void 0?void 0:B.valueOf())!==true){u.push({key:e.generateKeyFromDataField(y),type:k.Annotation,annotationPath:t.getEntitySetBasedAnnotationPath(y.fullyQualifiedName)+"/",semanticObjectPath:E,formatOptions:l()});}}switch(w===null||w===void 0?void 0:w.term){case"com.sap.vocabularies.UI.v1.FieldGroup":w.Data.forEach(x);break;case"com.sap.vocabularies.UI.v1.Identification":w.forEach(x);break;case"com.sap.vocabularies.UI.v1.DataPoint":u.push({key:"DataPoint::"+(w.qualifier?w.qualifier:""),type:k.Annotation,annotationPath:t.getEntitySetBasedAnnotationPath(w.fullyQualifiedName)+"/"});break;case"com.sap.vocabularies.Communication.v1.Contact":u.push({key:"Contact::"+(w.qualifier?w.qualifier:""),type:k.Annotation,annotationPath:t.getEntitySetBasedAnnotationPath(w.fullyQualifiedName)+"/"});break;default:break;}return u;}function n(i,t){var u=t.getManifestWrapper();var v=u.getFormContainer(i.Target.value);var w={};if(v!==null&&v!==void 0&&v.fields){Object.keys(v===null||v===void 0?void 0:v.fields).forEach(function(x){w[x]={key:x,type:k.Default,template:v.fields[x].template,label:v.fields[x].label,position:v.fields[x].position||{placement:P.After},formatOptions:h(h({},l()),v.fields[x].formatOptions)};});}return w;}_.getFormElementsFromManifest=n;function p(i,t,u){var v;var w=t.getEntityTypeAnnotation(i.Target.value);var E;if(w.converterContext.getEntitySet()&&w.converterContext.getEntitySet()!==t.getEntitySet()){E=c(w.converterContext.getDataModelObjectPath());}else if(((v=w.converterContext.getDataModelObjectPath().targetObject)===null||v===void 0?void 0:v.containsTarget)===true){E=b(w.converterContext.getDataModelObjectPath(),false);}u=u!==undefined?u.filter(function(x){return x.facetName==i.fullyQualifiedName;}):[];if(u.length===0){u=undefined;}return{id:g([{Facet:i}]),formElements:f(m(i,t),n(i,t),{formatOptions:"overwrite"}),annotationPath:"/"+i.fullyQualifiedName,entitySet:E,actions:u};}_.getFormContainer=p;function q(i,t,u){var v;var w=[];(v=i.Facets)===null||v===void 0?void 0:v.forEach(function(x){if(x.$Type==="com.sap.vocabularies.UI.v1.CollectionFacet"){return;}w.push(p(x,t,u));});return w;}function r(i){return i.$Type==="com.sap.vocabularies.UI.v1.ReferenceFacet";}_.isReferenceFacet=r;function s(i,t,u){var v,w,x;switch(i.$Type){case"com.sap.vocabularies.UI.v1.CollectionFacet":var y={id:F({Facet:i}),useFormContainerLabels:true,hasFacetsNotPartOfPreview:i.Facets.some(function(A){var B,E,G;return((B=A.annotations)===null||B===void 0?void 0:(E=B.UI)===null||E===void 0?void 0:(G=E.PartOfPreview)===null||G===void 0?void 0:G.valueOf())===false;}),formContainers:q(i,t,u)};return y;case"com.sap.vocabularies.UI.v1.ReferenceFacet":var z={id:F({Facet:i}),useFormContainerLabels:false,hasFacetsNotPartOfPreview:((v=i.annotations)===null||v===void 0?void 0:(w=v.UI)===null||w===void 0?void 0:(x=w.PartOfPreview)===null||x===void 0?void 0:x.valueOf())===false,formContainers:[p(i,t,u)]};return z;default:throw new Error("Cannot create form based on ReferenceURLFacet");}}_.createFormDefinition=s;return _;},false);