Merge pull request #2220 from IDEMSInternational/feat/data-items-eval-context

feat: add data-items eval context fields

Author: esmeetewinkel

packages/data-models/flowTypes.ts

@@ -337,11 +337,21 @@ export namespace FlowTypes {
     /** Keep a list of dynamic dependencies used within a template, by reference (e.g. {@local.var1 : ["text_1"]}) */
     _dynamicDependencies?: { [reference: string]: string[] };
     _translatedFields?: { [field: string]: any };
-    _evalContext?: { itemContext: any }; // force specific context variables when calculating eval statements (such as loop items)
+    _evalContext?: { itemContext: TemplateRowItemEvalContext }; // force specific context variables when calculating eval statements (such as loop items)
     __EMPTY?: any; // empty cells (can be removed after pr 679 merged)
   }
   export type IDynamicField = { [key: string]: IDynamicField | TemplateRowDynamicEvaluator[] };
 
+  export interface TemplateRowItemEvalContext {
+    // item metadata
+    _id: string;
+    _index: number;
+    _first: boolean;
+    _last: boolean;
+    // item data
+    [key: string]: any;
+  }
+
   type IDynamicPrefix = IAppConfig["DYNAMIC_PREFIXES"][number];
 
   /** Data passed back from regex match, e.g. expression @local.someField => type:local, fieldName: someField */

src/app/shared/components/template/components/data-items/data-items.component.ts

@@ -74,34 +74,48 @@ export class TmplDataItemsComponent extends TemplateBaseComponent implements OnD
     parameterList: any
   ) {
     const parsedItemDataList = await this.parseDataList(itemDataList);
-    const itemRows = new ItemProcessor(parsedItemDataList, parameterList).process(rows);
-    const parsedItemRows = await this.hackProcessRows(itemRows);
-    const replacedActionRows = this.setActionListMeta(parsedItemRows, parsedItemDataList);
+    const { itemRows, itemData } = new ItemProcessor(parsedItemDataList, parameterList).process(
+      rows
+    );
+    const itemRowsWithMeta = this.setItemMeta(itemRows, itemData);
+
+    const parsedItemRows = await this.hackProcessRows(itemRowsWithMeta);
     // TODO - deep diff and only update changed
-    this.itemRows = replacedActionRows;
+    this.itemRows = parsedItemRows;
     this.cdr.markForCheck();
   }
 
   /**
-   * Update any action list set_item args to contain name of current data list and item id
-   * and set_items action to include all currently displayed rows
+   * Update item dynamic evaluation context and action lists to include relevant
+   * item data
+   * @param templateRows List of template rows generated from itemData by item processor
+   * @param itemData List of original item data used to create item rows (post operations such as filter/sort)
    * */
-  private setActionListMeta(
-    rows: FlowTypes.TemplateRow[],
-    dataList: {
-      [index: string]: any;
-    }
-  ) {
-    return rows.map((r) => {
+  private setItemMeta(templateRows: FlowTypes.TemplateRow[], itemData: FlowTypes.Data_listRow[]) {
+    const lastItemIndex = itemData.length - 1;
+    const itemDataIDs = itemData.map((item) => item.id);
+    // Reassign metadata fields previously assigned by item as rendered row count may have changed
+    return templateRows.map((r) => {
+      // Map the row item context to the original list of items rendered to know position in item list.
+      const itemIndex = itemDataIDs.indexOf(r._evalContext.itemContext._id);
+      // Update metadata fields as _first, _last and index may have changed based on dynamic updates
+      r._evalContext.itemContext = {
+        ...r._evalContext.itemContext,
+        _index: itemIndex,
+        _first: itemIndex === 0,
+        _last: itemIndex === lastItemIndex,
+      };
+      // Update any action list set_item args to contain name of current data list and item id
+      // and set_items action to include all currently displayed rows
       if (r.action_list) {
         r.action_list = r.action_list.map((a) => {
           if (a.action_id === "set_item") {
-            a.args = [this.dataListName, r._evalContext.itemContext.id];
+            a.args = [this.dataListName, r._evalContext.itemContext._id];
           }
           if (a.action_id === "set_items") {
             // TODO - add a check for @item refs and replace parameter list with correct values
             // for each individual item (default will be just to pick the first)
-            a.args = [this.dataListName, Object.values(dataList).map((v) => v.id)];
+            a.args = [this.dataListName, itemDataIDs];
           }
           return a;
         });
@@ -114,7 +128,7 @@ export class TmplDataItemsComponent extends TemplateBaseComponent implements OnD
    * Ordinarily rows would be processed as part of the regular template processing,
    * however this must be bypassed to allow multiple reprocessing on item updates
    */
-  private async hackProcessRows(rows) {
+  private async hackProcessRows(rows: FlowTypes.TemplateRow[]) {
     const processor = new TemplateRowService(this.injector, {
       name: "",
       template: {

src/app/shared/components/template/processors/item.ts

@@ -15,7 +15,8 @@ export class ItemProcessor {
     const pipedData = this.pipeData(data, this.parameterList);
     const itemRows = this.generateLoopItemRows(templateRows, pipedData);
     const parsedItemRows = this.hackSetNestedName(itemRows);
-    return parsedItemRows;
+    // Return both rows for rendering and list of itemData used (post pipe operations)
+    return { itemRows: parsedItemRows, itemData: pipedData };
   }
 
   private pipeData(data: any[], parameter_list: any) {
@@ -32,13 +33,31 @@ export class ItemProcessor {
   /**
    * Takes a row and list of items to iterate over, creating a new entry for each item with
    * the same row values but a unique evaluation context for populating dynamic variables from the item
-   * @param items - list of items to iterate over
+   * @param templateRows - list of template rows to iterate over for each item
+   * @param itemData - list of items to iterate over
    */
-  private generateLoopItemRows(templateRows: FlowTypes.TemplateRow[], items: any[]) {
+  private generateLoopItemRows(
+    templateRows: FlowTypes.TemplateRow[],
+    itemData: FlowTypes.Data_listRow[]
+  ) {
     const loopItemRows: FlowTypes.TemplateRow[] = [];
-    for (const [index, item] of Object.entries(items)) {
-      item._index = index;
-      const evalContext = { itemContext: item };
+    const lastItemIndex = itemData.length - 1;
+    for (const [indexKey, item] of Object.entries(itemData)) {
+      const _index = Number(indexKey);
+      const itemContextMeta: FlowTypes.TemplateRowItemEvalContext = {
+        _index,
+        _id: item["id"],
+        _first: _index === 0,
+        _last: _index === lastItemIndex,
+      };
+      const evalContext: FlowTypes.TemplateRow["_evalContext"] = {
+        itemContext: {
+          ...item,
+          ...itemContextMeta,
+          // Assign row dynamic context to allow reference to rendered row metadata, including
+          // item index, id, and whether first or last item in list
+        },
+      };
       for (const r of templateRows) {
         const itemRow = this.setRecursiveRowEvalContext(r, evalContext);
         loopItemRows.push(itemRow);

src/app/shared/components/template/services/instance/template-row.service.ts

@@ -284,7 +284,7 @@ export class TemplateRowService extends SyncServiceBase {
       const itemDataList: { [id: string]: any } = row.value;
       const parameterList = this.hackUnparseItemParameterList(row);
       const parsedItemDataList = await this.parseDataList(itemDataList);
-      const itemRows = new ItemProcessor(parsedItemDataList, parameterList).process(row.rows);
+      const { itemRows } = new ItemProcessor(parsedItemDataList, parameterList).process(row.rows);
       const parsedItemRows = await this.processRows(itemRows, isNestedTemplate, row.name);
       return parsedItemRows;
     }