@sap/ux-specification 1.84.46 → 1.84.50

package/dist/src/sync/v4/generate/listReport.js

@@ -0,0 +1,651 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateListReportSchemaV4 = void 0;
+const utils_1 = require("../utils/utils");
+const ux_specification_types_1 = require("@sap/ux-specification-types");
+const i18next_1 = __importDefault(require("i18next"));
+const extensionLogger_1 = require("../../../extensionLogger");
+const common_1 = require("../../common");
+/**
+ * Adds the selection fields to the app schema, as properties of the FilterBar
+ * @param entityType - the entity type as part of the AVT ConvertedMetadata
+ * @param appSchema - the app specific schema that shall get enhanced
+ * @param selectionFieldsAnnotation - the UI.SelectionField annotation
+ */
+function addSelectionFields(entityType, appSchema, selectionFieldsAnnotation) {
+    const selectionFieldsDefinition = appSchema['definitions'].SelectionFields;
+    selectionFieldsDefinition.additionalProperties = false;
+    selectionFieldsDefinition.properties = {};
+    if (!entityType) {
+        return;
+    }
+    selectionFieldsDefinition[common_1.SchemaTag.annotationPath] = common_1.createAnnotationPath(entityType.fullyQualifiedName, "com.sap.vocabularies.UI.v1.SelectionFields" /* SelectionFields */);
+    if (!selectionFieldsAnnotation) {
+        return;
+    }
+    let i = 0;
+    selectionFieldsAnnotation.forEach((selectionField) => {
+        let description = selectionField.value;
+        const fieldDefinition = 'SelectionField::' + common_1.prepareRef(selectionField.value);
+        if (selectionField.type === 'PropertyPath') {
+            description = common_1.getLabelForPropertyPath(selectionField, entityType);
+        }
+        selectionFieldsDefinition['properties'][fieldDefinition] = {
+            $ref: common_1.DEFINITION_LINK_PREFIX + fieldDefinition
+        };
+        selectionFieldsDefinition['properties'][fieldDefinition][common_1.SchemaTag.propertyIndex] = i;
+        const dataType = common_1.determineDataType(selectionField);
+        appSchema['definitions'][fieldDefinition] = {
+            type: 'object',
+            properties: {},
+            description,
+            annotationPath: `${selectionFieldsDefinition[common_1.SchemaTag.annotationPath]}/${i}`,
+            isViewNode: true,
+            additionalProperties: false,
+            annotationType: selectionField?.type,
+            ...(dataType && { dataType })
+        };
+        i++;
+    });
+}
+/**
+ * Convert alias prefix of visualization if different from @UI (e.g. SAP__UI)
+ * @param visualization visualization of an (Selection)PresentationVariant
+ * @param alias - the given alias or namespace of the OData annotations
+ * @returns the converted visualization
+ */
+function convertVisualization(visualization, alias) {
+    if (visualization && !visualization.startsWith(`@${alias}`)) {
+        return visualization.replace(visualization.split('.')[0], '@UI');
+    }
+    else {
+        return visualization;
+    }
+}
+function defineActions(appSchema, schemaIdForActions, annotations, targetAnnotation, entityType) {
+    appSchema.definitions[schemaIdForActions] = JSON.parse(JSON.stringify(appSchema.definitions['Actions']));
+    const actions = appSchema.definitions[schemaIdForActions];
+    actions.properties = {};
+    actions.additionalProperties = false;
+    const chartAnnotation = annotations[targetAnnotation?.split(`${common_1.UIVOCABULARY}.`)[1]];
+    if (chartAnnotation && chartAnnotation.Actions) {
+        let i = 0;
+        chartAnnotation.Actions.forEach((actionRecord) => {
+            const actionDefinition = common_1.prepareRef(`${common_1.DefinitionName.ChartToolBarAction}<${actionRecord.Action}>`);
+            const description = common_1.getDataFieldDescription(actionRecord, entityType);
+            const prefix = actionRecord.$Type.split(`${common_1.UIVOCABULARY}.`)[1];
+            const action = (actions.properties[`${prefix}::${actionRecord.Action}`] = {
+                $ref: common_1.DEFINITION_LINK_PREFIX + actionDefinition,
+                description
+            });
+            //Add tags
+            action[common_1.SchemaTag.propertyIndex] = i;
+            action[common_1.SchemaTag.annotationType] = actionRecord.$Type;
+            action[common_1.SchemaTag.annotationPath] = `/${actionRecord.fullyQualifiedName}`;
+            //as ChartToolBarAction is an empty object, copy ViewToolBarAction and remove properties
+            appSchema.definitions[actionDefinition] = JSON.parse(JSON.stringify(appSchema.definitions[common_1.DefinitionName.ViewToolBarAction]));
+            appSchema.definitions[actionDefinition].properties = {};
+            appSchema.definitions[actionDefinition][common_1.SchemaTag.annotationPath] = actionRecord.fullyQualifiedName;
+            i++;
+        });
+    }
+}
+/**
+ * Finds the right visualization for a given view
+ * @param allVisualizations - list of visualizations for the given (S)PV
+ * @param alias - alias definition for the relevant namespace
+ * @param namespace - namespace for the UI annotations
+ * @param viewKey - view key: primary, secondary, or anything else; may also be undefined. The first visualization is taken in this case.
+ * @param visualizationType - allows to find the right visualization if there are many.
+ * @returns the value of the first fitting visualization
+ */
+function findTheRightVisualization(allVisualizations, alias, namespace, viewKey, visualizationType) {
+    let visualization, visualizationObject, targetAnnotation;
+    if (allVisualizations) {
+        if (viewKey === 'primary') {
+            visualizationObject = allVisualizations.find((vis) => {
+                return vis['value'].indexOf('Chart') > -1;
+            });
+        }
+        else if (viewKey === 'secondary') {
+            visualizationObject = allVisualizations.find((vis) => {
+                return vis['value'].indexOf(common_1.FacetBase.LineItem) > -1;
+            });
+        }
+        else {
+            if (visualizationType) {
+                visualizationObject = allVisualizations.find((v) => v['value'].indexOf(visualizationType) > -1);
+            }
+            else {
+                visualizationObject = allVisualizations[0];
+            }
+        }
+        visualization = convertVisualization(visualizationObject?.['value'], alias);
+        if (visualizationObject?.['$target']?.fullyQualifiedName) {
+            targetAnnotation = `/${namespace}/${visualizationObject['$target'].fullyQualifiedName.split(namespace)[1]}`;
+        }
+        else if (visualization) {
+            targetAnnotation = `/${namespace}/` + visualization.replace(`UI`, common_1.UIVOCABULARY);
+        }
+    }
+    return { visualization, targetAnnotation };
+}
+/**
+ * An annotationPath must be analyzed, to find the right target annotation and visualization
+ *
+ */
+function analyzeChartAnnotation(namespace, annotationPath, annotationAVT, viewKey) {
+    const visualization = '@UI.Chart';
+    const targetAnnotationFullName = `/${namespace}/@${annotationPath}`;
+    let chartTitle;
+    if (annotationAVT['Title']) {
+        chartTitle = annotationAVT['Title'];
+    }
+    else {
+        chartTitle = `Chart View (${viewKey})`;
+    }
+    return { visualization, targetAnnotation: targetAnnotationFullName, chartTitle };
+}
+/**
+ * An annotationPath must be analyzed, to find the right target annotation and visualization
+ * @param annotationPath - given annotationPath
+ * @param uIAnnotations - annotations of UI namespace of the given entityType
+ * @param generateParameters - parameters required to generate app schema
+ * @param viewKey - allows to distinguish the different view types (LR or ALP)
+ * @param visualizationType - allows to find the right visualization if there are many.
+ * @returns { visualization: string describing the visualization of the annotation,
+ *            targetAnnotation: the target annotation behind the visualization
+ *            namespace: namespace of the annotation,
+ *            title: title to be shown, derived from the annotation }
+ */
+function analyzeViewAnnotation(annotationPath, uIAnnotations, generateParameters, viewKey, visualizationType) {
+    let namespace = undefined, title;
+    const UILINEITEM = '@UI.LineItem';
+    const annotationInManifest = annotationPath?.split(`${common_1.UIVOCABULARY}.`)[1];
+    const annotationAVT = annotationInManifest && uIAnnotations[annotationInManifest];
+    if (!annotationAVT) {
+        return { visualization: undefined, targetAnnotation: undefined, namespace, title: `View (${viewKey})` };
+    }
+    title = annotationAVT.Text;
+    namespace = annotationAVT.fullyQualifiedName.split('@com.sap.vocabularies.UI.v1.')[0];
+    const alias = common_1.findAlias(common_1.UIVOCABULARY, generateParameters.serviceAVT);
+    if (annotationInManifest.startsWith('PresentationVariant')) {
+        const { visualization, targetAnnotation } = findTheRightVisualization(annotationAVT.Visualizations, alias, namespace, viewKey, visualizationType);
+        title = title || `View (${viewKey})`;
+        return { visualization, targetAnnotation, namespace, title };
+    }
+    else if (annotationInManifest.startsWith('SelectionPresentationVariant')) {
+        let { visualization, targetAnnotation } = findTheRightVisualization(annotationAVT.PresentationVariant.Visualizations, alias, namespace, viewKey, visualizationType);
+        if (!visualization) {
+            visualization = UILINEITEM; // default visualization
+            targetAnnotation = `/${namespace}/` + visualization.replace(`UI`, common_1.UIVOCABULARY); // default targetAnnotation
+        }
+        title = title || `View (${viewKey})`;
+        return { visualization, targetAnnotation, namespace, title };
+    }
+    else if (annotationInManifest.startsWith('SelectionVariant')) {
+        const visualization = UILINEITEM;
+        const targetAnnotation = `/${namespace}/@com.sap.vocabularies.UI.v1.LineItem`;
+        title = title || `Table View (${viewKey})`;
+        return { visualization, targetAnnotation, namespace, title };
+    }
+    else if (annotationInManifest.startsWith('LineItem')) {
+        const visualization = UILINEITEM;
+        const targetAnnotation = `/${namespace}/@${annotationPath}`;
+        title = title || `Table View (${viewKey})`;
+        return { visualization, targetAnnotation, namespace, title };
+    }
+    else if (annotationInManifest.startsWith('Chart')) {
+        const { visualization, targetAnnotation, chartTitle } = analyzeChartAnnotation(namespace, annotationPath, annotationAVT, viewKey);
+        return { visualization, targetAnnotation, namespace, title: chartTitle };
+    }
+    return { visualization: undefined, targetAnnotation: undefined, namespace, title: `View (${viewKey})` };
+}
+/**
+ * Adds the ALP chart view to the app-specific schema
+ * @param {Definition} appSchema - app-specific JSON schema
+ * @param targetAnnotation - target annotation of the chart view, as determined by analyzeViewAnnotation
+ * @param annotations - UI annotations, as determined by AVT
+ */
+function addALPChartView(appSchema, chartAnnotationPath, targetAnnotation, annotations) {
+    const chartView = appSchema.definitions[common_1.DefinitionName.ALPChartView];
+    appSchema.definitions[common_1.DefinitionName.ALPChart] = JSON.parse(JSON.stringify(chartView));
+    delete appSchema.definitions[common_1.DefinitionName.ALPChart][common_1.SchemaTag.isViewNode];
+    if (targetAnnotation) {
+        appSchema.definitions[common_1.DefinitionName.ALPChart][common_1.SchemaTag.annotationPath] = targetAnnotation;
+    }
+    appSchema.definitions[common_1.DefinitionName.ALPChart].properties.annotationPath[common_1.SchemaTag.hidden] = true;
+    chartView.properties.annotationPath[common_1.SchemaTag.hidden] = true;
+    chartView.additionalProperties = false;
+    chartView.description = `Chart (key: primary)`;
+    chartView.title = `Chart`;
+    chartView.$ref = `${common_1.DEFINITION_LINK_PREFIX}${common_1.DefinitionName.ALPChart}`;
+    if (chartAnnotationPath) {
+        const viewAnnotation = chartAnnotationPath.split(common_1.UIVOCABULARYDOT)[1];
+        const pathParts = annotations[viewAnnotation].fullyQualifiedName.split('@');
+        chartView[common_1.SchemaTag.annotationPath] = `/${pathParts[0]}/@${pathParts[1]}`;
+    }
+    chartView[common_1.SchemaTag.artifactType] = ux_specification_types_1.ArtifactType.Manifest;
+    chartView[common_1.SchemaTag.key] = 'primary';
+}
+/**
+ * Adds the ALP views to the app-specific schema
+ * @param {Definition} appSchema - app-specific JSON schema
+ * @param {Array<Object>} viewsPaths - views' paths' section in the manifest
+ * @param {EntityType} entityType - actual entity type of the page's entitySet
+ * @param {GenerateAppSchemaParameters} generateParameters - list of API input parameters
+ * @param templateAnnotation - defaultTemplateAnnotationPath as registered in manifest
+ */
+function addALPViews(appSchema, viewsPaths, entityType, generateParameters, templateAnnotation, tableDefinitionName) {
+    const annotations = entityType.annotations.UI;
+    //1. Chart View
+    const chartAnnotationPath = viewsPaths?.[0]?.['primary']?.[0]?.[common_1.SchemaTag.annotationPath];
+    const { targetAnnotation } = analyzeViewAnnotation(chartAnnotationPath, annotations, generateParameters, 'primary');
+    addALPChartView(appSchema, chartAnnotationPath, targetAnnotation, annotations);
+    // Copy toolbar
+    const schemaIdForActions = `Actions<ALPChart>`;
+    appSchema.definitions[common_1.DefinitionName.ViewChartToolBar].properties.actions['$ref'] =
+        common_1.DEFINITION_LINK_PREFIX + schemaIdForActions;
+    defineActions(appSchema, schemaIdForActions, annotations, targetAnnotation, entityType);
+    //2. Table View
+    const { visualization: tableVisualization, targetAnnotation: target } = analyzeViewAnnotation(viewsPaths?.[0]?.['secondary']?.[0]?.[common_1.SchemaTag.annotationPath], annotations, generateParameters, 'secondary');
+    const tableDefinition = appSchema.definitions[tableDefinitionName];
+    if (tableVisualization || templateAnnotation) {
+        tableDefinition.properties.toolBar['$ref'] = `${common_1.DEFINITION_LINK_PREFIX}${common_1.DefinitionName.ToolBarLR}`;
+        // Switch from generic column to specific definition
+        tableDefinition.properties['columns'] = {
+            $ref: common_1.DEFINITION_LINK_PREFIX + common_1.DefinitionName.LineItems
+        };
+        tableDefinition.properties.annotationPath[common_1.SchemaTag.hidden] = true;
+    }
+    else {
+        tableDefinition.properties = {};
+    }
+    const tableView = appSchema.definitions[common_1.DefinitionName.ALPTableView];
+    appSchema.definitions[common_1.DefinitionName.ALPTable] = JSON.parse(JSON.stringify(tableView));
+    delete appSchema.definitions[common_1.DefinitionName.ALPTable][common_1.SchemaTag.isViewNode];
+    tableView.additionalProperties = false;
+    tableView.description = `Table (key: secondary)`;
+    tableView.title = `Table`;
+    if (tableVisualization) {
+        delete tableView.properties;
+        tableView.$ref = `${common_1.DEFINITION_LINK_PREFIX}${common_1.DefinitionName.ALPTable}`;
+    }
+    else if (!templateAnnotation) {
+        tableView.properties = {};
+    }
+    tableView[common_1.SchemaTag.artifactType] = ux_specification_types_1.ArtifactType.Manifest;
+    let annotationTerm, viewAnnotation;
+    if (tableVisualization && tableVisualization.indexOf(common_1.FacetBase.LineItem) > -1) {
+        annotationTerm = tableVisualization.split('.')[1];
+        viewAnnotation = viewsPaths[0]['secondary'][0].annotationPath.split(common_1.UIVOCABULARYDOT)[1];
+    }
+    else if (templateAnnotation) {
+        annotationTerm = viewAnnotation = templateAnnotation.split(common_1.UIVOCABULARYDOT)[1];
+    }
+    if (annotationTerm) {
+        const dataForLineItem = {
+            appSchema,
+            lineItemAnnotation: entityType.annotations.UI[annotationTerm],
+            entityType,
+            oDataServiceAVT: generateParameters.serviceAVT,
+            lineItemId: common_1.DefinitionName.LineItems
+        };
+        utils_1.addLineItemsTypeToSchema(dataForLineItem, common_1.DefinitionName.ViewTableColumn);
+        appSchema.definitions[common_1.DefinitionName.ALPTable][common_1.SchemaTag.annotationPath] = target;
+        const pathParts = annotations[viewAnnotation].fullyQualifiedName.split('@');
+        tableView[common_1.SchemaTag.annotationPath] = `/${pathParts[0]}/@${pathParts[1]}`;
+        tableView[common_1.SchemaTag.key] = 'secondary';
+    }
+}
+/**
+ * Modifies the app schema, adds the right line chart settings
+ * @param inputParameters - list of input parameters as collected by the calling instance
+ * @param annotations - UI annotations of the given entityType
+ * @returns the ID for the chart view in schema
+ */
+function addViewChartDefinitions(inputParameters, annotations) {
+    const idForChart = `${common_1.DefinitionName.LRChartView}<${inputParameters.viewKey}>`;
+    inputParameters.appSchema.definitions[idForChart] = JSON.parse(JSON.stringify(inputParameters.appSchema.definitions[common_1.DefinitionName.LRChartView]));
+    delete inputParameters.appSchema.definitions[idForChart][common_1.SchemaTag.isViewNode];
+    inputParameters.appSchema.definitions[idForChart][common_1.SchemaTag.annotationPath] = inputParameters.targetAnnotation;
+    if (inputParameters.navPropName) {
+        inputParameters.appSchema.definitions[idForChart]['navigationProperty'] = inputParameters.navPropName;
+    }
+    //Copy toolbar
+    const idForToolbar = `${common_1.DefinitionName.ViewChartToolBar}<${inputParameters.viewKey}>`;
+    inputParameters.appSchema.definitions[idForToolbar] = JSON.parse(JSON.stringify(inputParameters.appSchema.definitions[common_1.DefinitionName.ViewChartToolBar]));
+    inputParameters.appSchema.definitions[idForChart]['properties'].toolBar.$ref = `${common_1.DEFINITION_LINK_PREFIX}${idForToolbar}`;
+    //Copy actions
+    const schemaIdForActions = `${common_1.DefinitionName.Actions}<${inputParameters.viewKey}>`;
+    defineActions(inputParameters.appSchema, schemaIdForActions, annotations, inputParameters.targetAnnotation, inputParameters.targetEntityType);
+    inputParameters.appSchema.definitions[idForToolbar]['properties'][common_1.PropertyName.actions]['$ref'] = `${common_1.DEFINITION_LINK_PREFIX}${schemaIdForActions}`;
+    return idForChart;
+}
+/**
+ * Adds the definition of a chart view to the app schema
+ * @param inputParameters - list of input parameters as collected by the calling instance
+ * @param UIAnnotations - AVT UI annotations of the given entity type
+ * @param appSchema - app schema
+ * @param viewsDefinition - the views definition in app schema (MultiTableModeV4)
+ * @param viewKey - view key
+ * @param title - view title
+ */
+function addViewChart(inputParameters, UIAnnotations, appSchema, viewsDefinition, viewKey, title) {
+    const idForChart = addViewChartDefinitions(inputParameters, UIAnnotations);
+    appSchema.definitions[idForChart].properties.annotationPath[common_1.SchemaTag.hidden] = true;
+    appSchema.definitions[idForChart].properties.index[common_1.SchemaTag.hidden] = true;
+    appSchema.definitions[idForChart].properties.entitySet[common_1.SchemaTag.hidden] = true;
+    const titleOnHover = `Chart View (key: ${viewKey})`;
+    viewsDefinition.properties[viewKey] = {
+        $ref: `${common_1.DEFINITION_LINK_PREFIX}${idForChart}`,
+        description: title ? title : titleOnHover,
+        title: titleOnHover
+    };
+}
+/**
+ * Modifies the app schema, adds the right line item settings as derived from the visualization
+ * @param inputParameters - list of input parameters as collected by the calling instance
+ * @param viewsDefinition - the views definition in app schema (MultiTableModeV4)
+ * @param visualization - visualization from the given (S)PV
+ * @param templateAnnotation - defaultTemplateAnnotationPath as registered in manifest
+ * @param {GenerateAppSchemaParameters} generateParameters - list of API input parameters
+ */
+function addViewLineItems(inputParameters, viewsDefinition, visualization, templateAnnotation, generateParameters) {
+    const tableId = `${common_1.DefinitionName.LRTableView}<${inputParameters.viewKey}>`;
+    const viewId = `${common_1.DefinitionName.LineItemsOfView}::${inputParameters.viewKey}`;
+    const lrTableView = common_1.parseSchemaDefinition(common_1.DefinitionName.LRTableView, inputParameters.viewKey, inputParameters.appSchema);
+    delete lrTableView[common_1.SchemaTag.isViewNode];
+    lrTableView[common_1.SchemaTag.annotationPath] = inputParameters.targetAnnotation;
+    if (inputParameters.navPropName) {
+        lrTableView['navigationProperty'] = inputParameters.navPropName;
+    }
+    //Copy toolbar
+    common_1.addDefinitionRef(lrTableView.properties.toolBar, common_1.DefinitionName.ToolBar, viewId);
+    const title = `Table View (key: ${inputParameters.viewKey})`;
+    viewsDefinition.properties[inputParameters.viewKey] = {
+        $ref: `${common_1.DEFINITION_LINK_PREFIX}${tableId}`,
+        description: inputParameters.title || title,
+        title
+    };
+    common_1.addDefinitionRef(lrTableView.properties.columns, viewId);
+    lrTableView.properties.annotationPath[common_1.SchemaTag.hidden] = true;
+    lrTableView.properties.index[common_1.SchemaTag.hidden] = true;
+    lrTableView.properties.entitySet[common_1.SchemaTag.hidden] = true;
+    const annotationTerm = visualization?.split('.')[1] || templateAnnotation.split(common_1.UIVOCABULARYDOT)[1];
+    const dataForLineItem = {
+        appSchema: inputParameters.appSchema,
+        lineItemAnnotation: inputParameters.targetEntityType.annotations.UI[annotationTerm],
+        entityType: inputParameters.targetEntityType,
+        oDataServiceAVT: generateParameters.serviceAVT,
+        lineItemId: viewId
+    };
+    utils_1.addLineItemsTypeToSchema(dataForLineItem, common_1.DefinitionName.ViewTableColumn);
+}
+/**
+ * Adds the schema tags to a given view
+ * @param viewsDefinition - the views definition in app schema (MultiTableModeV4)
+ * @param viewKey - key property of the view
+ * @param namespace - target namespace for annotations
+ * @param view - the given view
+ */
+function addTagsToView(viewsDefinition, viewKey, namespace, view) {
+    viewsDefinition.properties[viewKey][common_1.SchemaTag.isViewNode] = true;
+    viewsDefinition.properties[viewKey][common_1.SchemaTag.annotationPath] = namespace
+        ? `/${namespace}/@${view[common_1.SchemaTag.annotationPath]}`
+        : undefined;
+    viewsDefinition.properties[viewKey][common_1.SchemaTag.artifactType] = ux_specification_types_1.ArtifactType.Manifest;
+    viewsDefinition.properties[viewKey][common_1.SchemaTag.key] = viewKey;
+}
+/**
+ * Adjusts the entity type if a different entity set is maintained for a view
+ * @param {EntitySet} entitySet - actual entity set (AVT information)
+ * @param view - the current view in manifest
+ * @param {GenerateAppSchemaParameters} generateParameters - list of API input parameters
+ * @param {EntityType} entityType - actual entity type of the page's entitySet
+ * @returns the target entity type
+ */
+function getTargetEntityType(entitySet, view, generateParameters, entityType) {
+    let targetEntityType = entityType;
+    let viewEntitySet = entitySet;
+    if (view['entitySet'] && view['entitySet'] !== entitySet.name) {
+        viewEntitySet = generateParameters.serviceAVT.entitySets.find((es) => {
+            return es.name === view['entitySet'];
+        });
+        targetEntityType = viewEntitySet.entityType;
+    }
+    return targetEntityType;
+}
+/**
+ * Adds definition parts to a LR View (LineItem/Chart)
+ * @param {string} templateAnnotation - defaultTemplateAnnotationPath as registered in manifest
+ * @param {string} visualization - visualization of the annotation
+ * @param viewsDefinition - the views definition in app schema (MultiTableModeV4)
+ * @param {object} commonInputParameters - list of input parameters as collected by the calling instance
+ * @param {GenerateAppSchemaParameters} generateParameters - list of API input parameters
+ * @param {SapUiAppPageV4} v4Page - the given page in manifest
+ * @param uiAnnotations - UI annotations of the given entityType
+ * @paran view - the given view
+ */
+function addLRViewParts(visualization, viewsDefinition, commonInputParameters, generateParameters, v4Page, uiAnnotations, view) {
+    if (visualization?.indexOf(ux_specification_types_1.Visualization.LineItem) > -1) {
+        //Add Line item view
+        addViewLineItems(commonInputParameters, viewsDefinition, visualization, commonInputParameters.targetAnnotation, generateParameters);
+    }
+    else if (visualization?.indexOf('Chart') > -1) {
+        //Add Chart view
+        addViewChart(commonInputParameters, uiAnnotations, commonInputParameters.appSchema, viewsDefinition, commonInputParameters.viewKey, commonInputParameters.title);
+    }
+    else if (view['template']) {
+        const titleOnHover = view['label'] || `Custom View (key: ${commonInputParameters.viewKey})`;
+        viewsDefinition.properties[commonInputParameters.viewKey] = {
+            description: commonInputParameters.title || titleOnHover,
+            title: titleOnHover,
+            // Default view - use table view reference as default
+            $ref: `${common_1.DEFINITION_LINK_PREFIX}${common_1.DefinitionName.TableViewExtension}`
+        };
+    }
+    else {
+        const titleOnHover = `View (key: ${commonInputParameters.viewKey})`;
+        viewsDefinition.properties[commonInputParameters.viewKey] = {
+            description: commonInputParameters.title || titleOnHover,
+            title: titleOnHover,
+            // Default view - use table view reference as default
+            $ref: `${common_1.DEFINITION_LINK_PREFIX}${common_1.DefinitionName.LRTableView}`
+        };
+    }
+}
+/**
+ * Add list report views to the app-specific schema
+ * @param {Definition} appSchema - app-specific JSON schema
+ * @param {Array<Object>} viewsPaths - views' paths' section in the manifest
+ * @param {EntityType} entityType - actual entity type of the page's entitySet
+ * @param {EntitySet} entitySet - actual entity set (AVT information)
+ * @param {GenerateAppSchemaParameters} generateParameters - list of API input parameters
+ * @param {string} templateAnnotation - defaultTemplateAnnotationPath as registered in manifest
+ * @param {SapUiAppPageV4} v4Page - the given page in manifest
+ */
+function addLRViews(appSchema, viewsPaths, entityType, entitySet, generateParameters, v4Page, tableDefinitionName) {
+    const tableDefinition = appSchema.definitions[tableDefinitionName];
+    tableDefinition.properties = {
+        annotationPath: tableDefinition.properties.annotationPath,
+        initialLoad: tableDefinition.properties.initialLoad,
+        views: tableDefinition.properties.views
+    };
+    const viewsDefinition = appSchema.definitions.MultiTableModeV4;
+    for (const view of viewsPaths) {
+        if (!view[common_1.SchemaTag.key]) {
+            continue;
+        }
+        let navPropName = undefined;
+        const targetEntityType = getTargetEntityType(entitySet, view, generateParameters, entityType);
+        const uiAnnotations = targetEntityType.annotations.UI;
+        const { visualization, targetAnnotation, namespace, title } = analyzeViewAnnotation(view?.[common_1.SchemaTag.annotationPath], uiAnnotations, generateParameters, view[common_1.SchemaTag.key]);
+        if (view['entitySet']) {
+            navPropName = entityType.navigationProperties.find((np) => {
+                return np.targetTypeName === namespace;
+            })?.name;
+        }
+        const viewKey = common_1.prepareRef(view[common_1.SchemaTag.key]);
+        const commonInputParameters = {
+            viewKey,
+            appSchema,
+            targetAnnotation,
+            navPropName,
+            targetEntityType,
+            title
+        };
+        addLRViewParts(visualization, viewsDefinition, commonInputParameters, generateParameters, v4Page, uiAnnotations, view);
+        addTagsToView(viewsDefinition, viewKey, namespace, view);
+    }
+}
+/**
+ * Adapts the table definition in schema.
+ * Evaluates the path depending on if defaultTemplateAnnotationPath or Selection-/PresentationVariant is present.
+ * @param {SapUiAppPageV4} v4Page - the given page in manifest
+ * @param {EntityType} entityType - the current entity type, as defined in AVT
+ * @param {GenerateAppSchemaParameters} generateParameters - list of API input parameters
+ * @param appSchema - the app-specific JSON schema
+ * @param alias - alias definition for the UI vocabulary
+ */
+function adaptTableDefinition(appSchema, entityType, generateParameters, templateAnnotation, v4Page, alias, tableDefinitionName) {
+    //here: tableDefinitionName = DefinitionName.Table
+    const tableDefinition = appSchema.definitions[tableDefinitionName];
+    const { visualization, targetAnnotation, namespace } = analyzeViewAnnotation(templateAnnotation, entityType.annotations.UI, generateParameters, undefined, ux_specification_types_1.Visualization.LineItem);
+    if (visualization) {
+        const annotationTerm = visualization.split('.')[1];
+        const annotationTermInSchema = `${common_1.DefinitionName.LineItems}OfSPV::${common_1.prepareRef(annotationTerm)}`;
+        const spvTable = (appSchema.definitions[`${tableDefinitionName}SPV`] = JSON.parse(JSON.stringify(appSchema.definitions[tableDefinitionName])));
+        delete spvTable[common_1.SchemaTag.isViewNode];
+        common_1.addDefinitionRef(spvTable.properties.toolBar, common_1.DefinitionName.ToolBar, annotationTermInSchema);
+        // Switch from generic column to specific definition
+        spvTable[common_1.SchemaTag.annotationPath] = targetAnnotation;
+        spvTable.properties.columns = {};
+        common_1.addDefinitionRef(spvTable.properties.columns, annotationTermInSchema);
+        delete tableDefinition.properties;
+        common_1.addDefinitionRef(tableDefinition, `${tableDefinitionName}SPV`);
+        tableDefinition[common_1.SchemaTag.annotationPath] = `/${namespace}/@${templateAnnotation}`;
+        const lineItemAnnotation = entityType.annotations.UI[annotationTerm];
+        const dataForLineItem = {
+            appSchema,
+            lineItemAnnotation,
+            entityType,
+            oDataServiceAVT: generateParameters.serviceAVT,
+            lineItemId: annotationTermInSchema
+        };
+        utils_1.addLineItemsTypeToSchema(dataForLineItem);
+    }
+    else {
+        tableDefinition.properties.toolBar['$ref'] = `${common_1.DEFINITION_LINK_PREFIX}${common_1.DefinitionName.ToolBarLR}`;
+        // Switch from generic column to specific definition
+        common_1.addDefinitionRef(tableDefinition.properties.columns, common_1.DefinitionName.LineItems);
+        const lineItemAnnotation = entityType?.annotations?.[alias]?.LineItem;
+        const dataForLineItem = {
+            appSchema,
+            lineItemAnnotation,
+            entityType,
+            oDataServiceAVT: generateParameters.serviceAVT,
+            lineItemId: common_1.DefinitionName.LineItems
+        };
+        utils_1.addLineItemsTypeToSchema(dataForLineItem);
+        if (lineItemAnnotation) {
+            tableDefinition[common_1.SchemaTag.annotationPath] = common_1.createAnnotationPath(entityType.fullyQualifiedName, lineItemAnnotation.term, lineItemAnnotation.qualifier);
+        }
+    }
+}
+/**
+ * Checks for the default annotation path to use for LR table
+ * @param {SapUiAppPageV4} v4Page - actual page in the manifest
+ * @param {EntityType} entityType - actual entity type (AVT information)
+ * @returns {string} annotation term
+ */
+function getDefaultAnnotationPath(v4Page, entityType, templateType) {
+    if (v4Page.options.settings?.views?.paths && templateType === common_1.TemplateType.ListReportObjectPageV4) {
+        return;
+    }
+    if (v4Page.options.settings?.defaultTemplateAnnotationPath) {
+        return v4Page.options.settings.defaultTemplateAnnotationPath;
+    }
+    if (templateType === common_1.TemplateType.ListReportObjectPageV4) {
+        return (entityType.annotations.UI?.SelectionPresentationVariant?.term ||
+            entityType.annotations.UI?.PresentationVariant?.term);
+    }
+}
+/**
+ * Add views to schema (LR or ALP)
+ * @param {Definition} appSchema - app-specific JSON schema
+ * @param {SapUiAppPageV4} v4Page - actual page in the manifest
+ * @param {EntityType} entityType - actual entity type (AVT information)
+ * @param {EntitySet} entitySet - actual entity set (AVT information)
+ * @param {GenerateAppSchemaParameters} generateParameters - list of API input parameters
+ */
+function addTableAndViews(appSchema, v4Page, entityType, entitySet, generateParameters, alias) {
+    const viewsPaths = v4Page.options?.settings?.views?.paths;
+    const defaultAnnotation = getDefaultAnnotationPath(v4Page, entityType, generateParameters.templateType);
+    const tableDefinitionName = utils_1.alignSchemaWithTemplateType(appSchema, generateParameters);
+    if (generateParameters.templateType === common_1.TemplateType.ListReportObjectPageV4) {
+        if (viewsPaths) {
+            addLRViews(appSchema, viewsPaths, entityType, entitySet, generateParameters, v4Page, tableDefinitionName);
+        }
+        else {
+            if (!v4Page.options?.settings?.views) {
+                appSchema.definitions.MultiTableModeV4.properties = {};
+            }
+            adaptTableDefinition(appSchema, entityType, generateParameters, defaultAnnotation, v4Page, alias, tableDefinitionName);
+        }
+        appSchema.properties[common_1.PropertyName.chart][common_1.SchemaTag.hidden] = true;
+    }
+    else if (generateParameters.templateType === common_1.TemplateType.AnalyticalListPageV4) {
+        addALPViews(appSchema, viewsPaths, entityType, generateParameters, defaultAnnotation, tableDefinitionName);
+    }
+}
+/**
+ * Generates an app specific schema for the FE V4 ListReport from the generic schema.
+ * Generic types are replaced by information from the app specific annotations.
+ * @param {GenerateAppSchemaParameters} generateParameters - list of API input parameters
+ * @param genericSchema  - generic JSON schema of an object page
+ * @param {EntitySet} entitySet - entity set (AVT object) that is relevant for the given page
+ * @param {string} templateName - allows to distinguish list report from ALP
+ *
+ * @returns {object} application-specific schema of the list report
+ */
+function generateListReportSchemaV4(generateParameters, genericSchema, entitySet, templateName) {
+    const appSchema = JSON.parse(JSON.stringify(genericSchema));
+    const entityType = entitySet?.entityType;
+    const alias = generateParameters.serviceAVT && common_1.findAlias(common_1.UIVOCABULARY, generateParameters.serviceAVT);
+    //Add selection fields
+    const selectionFieldAnnotation = alias && entityType?.annotations?.[alias]?.SelectionFields;
+    addSelectionFields(entityType, appSchema, selectionFieldAnnotation);
+    appSchema.properties[common_1.PropertyName.defaultTemplateAnnotationPath][common_1.SchemaTag.hidden] = true;
+    //enum for annotation path as part of QuickVariantSelection
+    common_1.addEnumForSingleTabVariant(entityType, appSchema, common_1.DefinitionName.AnnotationPathAsObject);
+    if (generateParameters.manifest) {
+        //Find page in targets
+        const pages = generateParameters.manifest[ux_specification_types_1.ManifestSection.ui5].routing
+            .targets;
+        if (!pages) {
+            extensionLogger_1.log(generateParameters.logger, {
+                severity: "error" /* Error */,
+                message: i18next_1.default.t('NOPAGES', { appId: generateParameters.manifest['sap.app']['id'] }),
+                location: {
+                    path: common_1.MANIFESTPATH,
+                    range: [ux_specification_types_1.ManifestSection.generic]
+                }
+            });
+            return appSchema;
+        }
+        const v4Page = utils_1.findPageV4(pages, templateName, entitySet, generateParameters.logger);
+        if (!v4Page) {
+            return appSchema;
+        }
+        addTableAndViews(appSchema, v4Page, entityType, entitySet, generateParameters, alias);
+    }
+    delete appSchema.definitions.GenericColumns;
+    delete appSchema.definitions.Action;
+    return appSchema;
+}
+exports.generateListReportSchemaV4 = generateListReportSchemaV4;
+//# sourceMappingURL=listReport.js.map