@linkup-ai/abap-ai 2.0.0

package/dist/knowledge/fiori/ui5-controllers.md

@@ -0,0 +1,358 @@
+# UI5 Controllers — lifecycle, events, model access, navigation
+
+## Controller Definition
+
+```js
+sap.ui.define([
+    "sap/ui/core/mvc/Controller",
+    "sap/ui/model/json/JSONModel",
+    "sap/m/MessageBox",
+    "sap/m/MessageToast"
+], function(Controller, JSONModel, MessageBox, MessageToast) {
+    "use strict";
+
+    return Controller.extend("com.myapp.controller.Main", {
+
+        onInit: function() {
+            // Called once when view is instantiated
+            var oViewModel = new JSONModel({ busy: false, editMode: false });
+            this.getView().setModel(oViewModel, "view");
+        },
+
+        onBeforeRendering: function() {
+            // Called before every rendering (initial + re-render)
+        },
+
+        onAfterRendering: function() {
+            // Called after every rendering — DOM is available
+        },
+
+        onExit: function() {
+            // Called when view is destroyed — cleanup
+        }
+    });
+});
+```
+
+## TypeScript Controller
+
+```ts
+import Controller from "sap/ui/core/mvc/Controller";
+import JSONModel from "sap/ui/model/json/JSONModel";
+import MessageBox from "sap/m/MessageBox";
+import MessageToast from "sap/m/MessageToast";
+import Event from "sap/ui/base/Event";
+
+/**
+ * @namespace com.myapp.controller
+ */
+export default class Main extends Controller {
+    public onInit(): void {
+        const oViewModel = new JSONModel({ busy: false, editMode: false });
+        this.getView()?.setModel(oViewModel, "view");
+    }
+
+    public onItemPress(oEvent: Event): void {
+        const oItem = oEvent.getSource();
+        const sPath = oItem.getBindingContext().getPath();
+        // navigate...
+    }
+}
+```
+
+## Accessing Controls
+
+```js
+// By ID (from XML view)
+var oTable = this.byId("orderTable");
+var oInput = this.byId("nameInput");
+
+// Get view
+var oView = this.getView();
+
+// Get control from event
+onButtonPress: function(oEvent) {
+    var oButton = oEvent.getSource();
+    var oItem = oEvent.getParameter("listItem");   // for List/Table events
+}
+```
+
+## Model Access
+
+```js
+// Get named model
+var oModel = this.getView().getModel();           // default model
+var oModel = this.getView().getModel("view");      // named model
+
+// Get OData model (from component)
+var oModel = this.getOwnerComponent().getModel();
+
+// Read property
+var sName = oModel.getProperty("/Name");
+var sValue = oModel.getProperty(sPath + "/Amount");
+
+// Set property
+oModel.setProperty("/editMode", true);
+oModel.setProperty(sPath + "/Status", "A");
+
+// Get data from binding context
+onItemPress: function(oEvent) {
+    var oContext = oEvent.getSource().getBindingContext();
+    var sOrderID = oContext.getProperty("OrderID");
+    var oData = oContext.getObject();    // entire record
+}
+```
+
+## OData V2 — CRUD Operations
+
+```js
+var oModel = this.getView().getModel();  // sap.ui.model.odata.v2.ODataModel
+
+// READ
+oModel.read("/Orders('1000')", {
+    success: function(oData) { /* oData = record */ },
+    error: function(oError) { /* handle */ }
+});
+
+// READ with expand
+oModel.read("/Orders('1000')", {
+    urlParameters: { "$expand": "to_Items" },
+    success: function(oData) { /* oData.to_Items = items array */ }
+});
+
+// CREATE
+oModel.create("/Orders", oPayload, {
+    success: function(oData) {
+        MessageToast.show("Created: " + oData.OrderID);
+    },
+    error: function(oError) {
+        MessageBox.error("Creation failed");
+    }
+});
+
+// UPDATE
+oModel.update("/Orders('1000')", oPayload, {
+    success: function() { MessageToast.show("Updated"); },
+    error: function(oError) { /* handle */ }
+});
+
+// DELETE
+oModel.remove("/Orders('1000')", {
+    success: function() { MessageToast.show("Deleted"); },
+    error: function(oError) { /* handle */ }
+});
+
+// Batch — group multiple operations
+oModel.setDeferredGroups(["batchGroup"]);
+oModel.create("/Orders", oPayload1, { groupId: "batchGroup" });
+oModel.create("/Orders", oPayload2, { groupId: "batchGroup" });
+oModel.submitChanges({
+    groupId: "batchGroup",
+    success: function() { /* all succeeded */ },
+    error: function() { /* batch failed */ }
+});
+
+// Refresh
+oModel.refresh(true);   // force reload from server
+oTable.getBinding("items").refresh();  // refresh specific binding
+```
+
+## OData V4 — CRUD Operations
+
+```js
+var oModel = this.getView().getModel();  // sap.ui.model.odata.v4.ODataModel
+
+// CREATE via list binding
+var oList = this.byId("orderTable").getBinding("items");
+var oContext = oList.create({
+    CustomerID: "CUST100",
+    Amount: 500
+});
+// oContext is immediately available (optimistic)
+
+// Save pending changes
+oModel.submitBatch(oModel.getUpdateGroupId());
+
+// DELETE via context
+var oContext = oEvent.getSource().getBindingContext();
+oContext.delete().then(function() {
+    MessageToast.show("Deleted");
+});
+
+// UPDATE — modify bound property, then submitBatch
+oModel.setProperty(sPath + "/Status", "A");
+oModel.submitBatch(oModel.getUpdateGroupId());
+
+// Refresh
+oList.refresh();
+oContext.refresh();
+```
+
+## Event Handling
+
+```js
+// Button press
+onSave: function() {
+    var oModel = this.getView().getModel();
+    if (oModel.hasPendingChanges()) {
+        oModel.submitChanges({
+            success: function() { MessageToast.show("Saved"); }
+        });
+    }
+},
+
+// List item press
+onItemPress: function(oEvent) {
+    var oItem = oEvent.getSource();
+    var oContext = oItem.getBindingContext();
+    var sID = oContext.getProperty("OrderID");
+    this.getRouter().navTo("detail", { orderID: sID });
+},
+
+// Search
+onSearch: function(oEvent) {
+    var sQuery = oEvent.getParameter("query");
+    var oFilter = sQuery
+        ? new sap.ui.model.Filter("Name", "Contains", sQuery)
+        : [];
+    this.byId("orderTable").getBinding("items").filter(oFilter);
+},
+
+// Input change
+onNameChange: function(oEvent) {
+    var sValue = oEvent.getParameter("value");
+    // validate, update model, etc.
+},
+
+// Select change
+onStatusChange: function(oEvent) {
+    var sKey = oEvent.getParameter("selectedItem").getKey();
+}
+```
+
+## Formatters
+
+```js
+// In controller or separate formatter.js
+formatStatusState: function(sStatus) {
+    switch (sStatus) {
+        case "A": return "Success";
+        case "X": return "Error";
+        case "O": return "Warning";
+        default:  return "None";
+    }
+},
+
+formatAmount: function(fAmount, sCurrency) {
+    if (!fAmount) return "";
+    return parseFloat(fAmount).toFixed(2) + " " + sCurrency;
+},
+
+formatDate: function(sDate) {
+    if (!sDate) return "";
+    var oFormat = sap.ui.core.format.DateFormat.getDateInstance({ style: "medium" });
+    return oFormat.format(new Date(sDate));
+}
+```
+
+```xml
+<!-- Using in XML view -->
+<ObjectStatus text="{StatusText}"
+    state="{path: 'Status', formatter: '.formatStatusState'}"/>
+<Text text="{parts: [{path: 'Amount'}, {path: 'Currency'}],
+    formatter: '.formatAmount'}"/>
+```
+
+## Router Access
+
+```js
+// Get router from component
+getRouter: function() {
+    return this.getOwnerComponent().getRouter();
+},
+
+// Navigate
+onNavToDetail: function(sID) {
+    this.getRouter().navTo("detail", { orderID: sID });
+},
+
+// Navigate back
+onNavBack: function() {
+    var oHistory = sap.ui.core.routing.History.getInstance();
+    var sPreviousHash = oHistory.getPreviousHash();
+    if (sPreviousHash !== undefined) {
+        window.history.go(-1);
+    } else {
+        this.getRouter().navTo("list", {}, true);
+    }
+},
+
+// Attach route matched (in onInit)
+onInit: function() {
+    this.getRouter().getRoute("detail").attachPatternMatched(this._onRouteMatched, this);
+},
+
+_onRouteMatched: function(oEvent) {
+    var sOrderID = oEvent.getParameter("arguments").orderID;
+    // V2: bind element
+    this.getView().bindElement({
+        path: "/Orders('" + sOrderID + "')",
+        parameters: { expand: "to_Items" },
+        events: {
+            dataRequested: function() { /* show busy */ },
+            dataReceived: function() { /* hide busy */ }
+        }
+    });
+    // V4: bind element
+    this.getView().bindElement("/Orders('" + sOrderID + "')");
+}
+```
+
+## i18n Access
+
+```js
+// Get resource bundle
+var oBundle = this.getView().getModel("i18n").getResourceBundle();
+var sText = oBundle.getText("orderCreated", [sOrderID]);  // with placeholder
+
+// In XML view
+// text="{i18n>orderCreated}"
+```
+
+## Busy Handling
+
+```js
+onInit: function() {
+    this.getView().setModel(new JSONModel({ busy: false }), "view");
+},
+
+setBusy: function(bBusy) {
+    this.getView().getModel("view").setProperty("/busy", bBusy);
+}
+```
+
+```xml
+<Page busyIndicatorDelay="0" busy="{view>/busy}">
+```
+
+## Rules
+- `onInit` for one-time setup (models, route attachment); never for DOM manipulation
+- `onAfterRendering` for DOM access — but prefer data binding over DOM manipulation
+- Always access controls via `this.byId()`, never `sap.ui.getCore().byId()`
+- Get OData model from `getOwnerComponent().getModel()` (not view) for shared model
+- Use `getBindingContext().getProperty()` to read data from events (not hardcoded paths)
+- Separate formatters into `model/formatter.js` when reused across views
+- Always handle `error` callback in OData operations
+- V4: use `oContext.delete()` / `oList.create()` — not `oModel.remove/create`
+
+## Anti-Patterns
+| Anti-Pattern | Correct |
+|---|---|
+| `sap.ui.getCore().byId("id")` | `this.byId("id")` |
+| DOM manipulation in `onInit` | Use data binding or `onAfterRendering` |
+| Hardcoded paths in controller | Use binding context: `oContext.getProperty("field")` |
+| Missing error handler in OData calls | Always handle `error` callback |
+| Global variables in controller | Use view model (`JSONModel`) for state |
+| `window.location` for navigation | Use `this.getRouter().navTo()` |
+| Sync operations (`oModel.read` without callbacks) | Always use async pattern with success/error |
+| Formatter with side effects | Formatters must be pure functions (no model changes) |

package/dist/knowledge/fiori/ui5-data-binding.md

@@ -0,0 +1,311 @@
+# UI5 Data Binding — OData, JSON, property, aggregation, expression
+
+## Binding Modes
+
+| Mode | Direction | Use |
+|------|-----------|-----|
+| `OneWay` | Model → View | Display data (default for OData) |
+| `TwoWay` | Model ↔ View | Editable forms (default for JSON) |
+| `OneTime` | Model → View (once) | Static data, config |
+
+```js
+// Set default binding mode
+oModel.setDefaultBindingMode(sap.ui.model.BindingMode.TwoWay);
+```
+
+## Model Types
+
+### JSON Model (client-side)
+
+```js
+var oModel = new sap.ui.model.json.JSONModel({
+    orders: [
+        { id: "001", customer: "ACME", amount: 500 },
+        { id: "002", customer: "Beta", amount: 300 }
+    ],
+    selectedTab: "all",
+    editMode: false
+});
+this.getView().setModel(oModel, "local");
+```
+
+```xml
+<Input value="{local>/selectedTab}"/>
+<List items="{local>/orders}">
+    <StandardListItem title="{local>customer}" description="{local>amount}"/>
+</List>
+```
+
+### OData V2 Model
+
+```json
+// manifest.json
+{
+    "sap.ui5": {
+        "models": {
+            "": {
+                "dataSource": "mainService",
+                "preload": true,
+                "settings": {
+                    "defaultBindingMode": "TwoWay",
+                    "defaultCountMode": "Inline",
+                    "refreshAfterChange": false,
+                    "useBatch": true
+                }
+            }
+        }
+    }
+}
+```
+
+### OData V4 Model
+
+```json
+{
+    "sap.ui5": {
+        "models": {
+            "": {
+                "dataSource": "mainService",
+                "preload": true,
+                "settings": {
+                    "synchronizationMode": "None",
+                    "operationMode": "Server",
+                    "autoExpandSelect": true,
+                    "groupId": "$auto"
+                }
+            }
+        }
+    }
+}
+```
+
+## Property Binding
+
+```xml
+<!-- Simple -->
+<Text text="{Name}"/>
+<Input value="{Amount}"/>
+
+<!-- Named model -->
+<Text text="{view>/editMode}"/>
+<Text text="{i18n>orderTitle}"/>
+
+<!-- Absolute path -->
+<Text text="{/Orders('001')/Name}"/>
+
+<!-- With type (formatting + validation) -->
+<Input value="{
+    path: 'Amount',
+    type: 'sap.ui.model.type.Float',
+    formatOptions: { minFractionDigits: 2, maxFractionDigits: 2 },
+    constraints: { minimum: 0 }
+}"/>
+
+<DatePicker value="{
+    path: 'OrderDate',
+    type: 'sap.ui.model.type.Date',
+    formatOptions: { style: 'medium', source: { pattern: 'yyyyMMdd' } }
+}"/>
+
+<Input value="{
+    path: 'Currency',
+    type: 'sap.ui.model.type.Currency',
+    formatOptions: { showMeasure: false }
+}" description="{Currency}"/>
+```
+
+## Aggregation Binding (Lists/Tables)
+
+```xml
+<!-- Template binding -->
+<List items="{/Orders}">
+    <StandardListItem title="{OrderID}" description="{CustomerName}"/>
+</List>
+
+<!-- With sorter -->
+<List items="{
+    path: '/Orders',
+    sorter: { path: 'OrderDate', descending: true }
+}">
+    <StandardListItem title="{OrderID}"/>
+</List>
+
+<!-- With filter -->
+<List items="{
+    path: '/Orders',
+    filters: [{ path: 'Status', operator: 'EQ', value1: 'O' }]
+}">
+    <StandardListItem title="{OrderID}"/>
+</List>
+
+<!-- With parameters (OData) -->
+<Table items="{
+    path: '/Orders',
+    parameters: {
+        expand: 'to_Items',
+        select: 'OrderID,CustomerName,Amount,Status'
+    }
+}">
+```
+
+## Element Binding (Object/Detail Pages)
+
+```js
+// V2: Bind view to single entity
+this.getView().bindElement({
+    path: "/Orders('1000')",
+    parameters: { expand: "to_Items" },
+    events: {
+        change: this._onBindingChange.bind(this),
+        dataRequested: function() { oView.setBusy(true); },
+        dataReceived: function() { oView.setBusy(false); }
+    }
+});
+
+// V4: simpler
+this.getView().bindElement("/Orders('1000')");
+
+// After binding, all controls in the view resolve relative paths
+// <Text text="{OrderID}"/>  → resolves to /Orders('1000')/OrderID
+```
+
+## Expression Binding
+
+```xml
+<!-- Ternary -->
+<Text text="{= ${Amount} > 1000 ? 'High Value' : 'Standard'}"/>
+
+<!-- Boolean -->
+<Input editable="{= ${Status} === 'O'}"/>
+<Button visible="{= ${Status} !== 'A'}"/>
+<Panel visible="{= ${Amount} > 0}"/>
+
+<!-- Arithmetic -->
+<Text text="{= ${Quantity} * ${UnitPrice}}"/>
+
+<!-- Negation -->
+<Input editable="{= !${view>/readOnly}}"/>
+
+<!-- String comparison -->
+<ObjectStatus state="{= ${Status} === 'A' ? 'Success' : ${Status} === 'X' ? 'Error' : 'Warning'}"/>
+
+<!-- With formatter -->
+<Text text="{= ${Amount}.toFixed(2) + ' ' + ${Currency}}"/>
+```
+
+## Composite Binding (multiple parts)
+
+```xml
+<!-- parts array -->
+<Text text="{
+    parts: [
+        { path: 'FirstName' },
+        { path: 'LastName' }
+    ],
+    formatter: '.formatFullName'
+}"/>
+
+<!-- Simple concatenation with expression -->
+<Text text="{= ${FirstName} + ' ' + ${LastName}}"/>
+```
+
+## Filters (in Controller)
+
+```js
+var aFilters = [];
+
+// Simple filter
+aFilters.push(new sap.ui.model.Filter("Status", "EQ", "O"));
+
+// Contains
+aFilters.push(new sap.ui.model.Filter("Name", "Contains", sQuery));
+
+// Between
+aFilters.push(new sap.ui.model.Filter("Amount", "BT", 100, 1000));
+
+// AND (multiple filters)
+var oFilter = new sap.ui.model.Filter({
+    filters: [
+        new sap.ui.model.Filter("Status", "EQ", "O"),
+        new sap.ui.model.Filter("Amount", "GT", 100)
+    ],
+    and: true
+});
+
+// OR
+var oFilter = new sap.ui.model.Filter({
+    filters: [
+        new sap.ui.model.Filter("Status", "EQ", "O"),
+        new sap.ui.model.Filter("Status", "EQ", "P")
+    ],
+    and: false
+});
+
+// Apply to binding
+this.byId("orderTable").getBinding("items").filter(aFilters);
+
+// Clear filters
+this.byId("orderTable").getBinding("items").filter([]);
+```
+
+## Filter Operators
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `EQ` | Equal | `"EQ", "A"` |
+| `NE` | Not equal | `"NE", "D"` |
+| `GT` | Greater than | `"GT", 100` |
+| `GE` | Greater or equal | `"GE", 100` |
+| `LT` | Less than | `"LT", 1000` |
+| `LE` | Less or equal | `"LE", 1000` |
+| `BT` | Between | `"BT", 100, 1000` |
+| `Contains` | Contains string | `"Contains", "SAP"` |
+| `StartsWith` | Starts with | `"StartsWith", "Z"` |
+| `EndsWith` | Ends with | `"EndsWith", "GmbH"` |
+
+## Sorters (in Controller)
+
+```js
+var aSorters = [
+    new sap.ui.model.Sorter("OrderDate", true),    // descending
+    new sap.ui.model.Sorter("Amount", false)        // ascending
+];
+this.byId("orderTable").getBinding("items").sort(aSorters);
+
+// Grouped sorting
+var oSorter = new sap.ui.model.Sorter("Category", false, function(oContext) {
+    var sCategory = oContext.getProperty("Category");
+    return { key: sCategory, text: "Category: " + sCategory };
+});
+```
+
+## Common Data Types
+
+| Type | Use | Import |
+|------|-----|--------|
+| `sap.ui.model.type.String` | Text with constraints | `constraints: { maxLength: 40 }` |
+| `sap.ui.model.type.Integer` | Whole numbers | `constraints: { minimum: 0 }` |
+| `sap.ui.model.type.Float` | Decimals | `formatOptions: { minFractionDigits: 2 }` |
+| `sap.ui.model.type.Date` | Date formatting | `formatOptions: { style: 'medium' }` |
+| `sap.ui.model.type.DateTime` | Date + time | `formatOptions: { style: 'medium' }` |
+| `sap.ui.model.type.Currency` | Amount + currency | `formatOptions: { showMeasure: true }` |
+
+## Rules
+- Default model (no name) accessed via `{PropertyName}`; named model via `{modelName>PropertyName}`
+- JSON model: TwoWay by default; OData: OneWay by default (set TwoWay explicitly for forms)
+- Use `type` in binding for automatic formatting + validation (dates, numbers, currency)
+- Expression binding `{= ...}` for simple logic; formatter for complex logic
+- V2: `expand` via parameters in binding; V4: `autoExpandSelect: true` handles it
+- Always handle `change` event on element binding to detect missing records (404)
+- `bindElement` for detail pages; aggregation binding for lists/tables
+
+## Anti-Patterns
+| Anti-Pattern | Correct |
+|---|---|
+| Manual date formatting in JS | Use `type: 'sap.ui.model.type.Date'` in binding |
+| `oModel.getData()` on OData model | Use `oModel.getProperty(path)` or binding context |
+| Hardcoded paths: `"/Orders('1000')"` | Build paths from route parameters |
+| Missing `defaultCountMode: "Inline"` in V2 | Results in extra $count requests |
+| Expression binding with model writes | Expressions are read-only — use controller for writes |
+| `oModel.refresh(true)` after every change | Use `refreshAfterChange: false` + selective refresh |
+| Filter without clearing previous | Always pass full filter array (or empty to clear) |