Using ElementProxy to get data fields for selected Jira card

Hey Matt!

We looked into this, and it turns out there is a bug on our end. The developer who found the issue out sick today, so I don’t have an ETA on the fix (the rest of us don’t know the details 😅).

Hopefully, I will get back to you soon once our developer is feeling better. Apologies for the delay and thanks for your partnership!

Okay! So what we found is our code is not returning all the collections it should be. One of our developers is working on a fix. We expect to have it released middle of next week (with the caveat that this is an “expectation” and timelines may change).

Thanks for your partnership Matt!

Hey Matt! We believe we fixed the bug. Could you try it again?

OK good news but [maybe] another problem. Or perhaps I’m doing something wrong? I now am able to retrieve the collection from a DataItemProxy, and I can pull out a list of the Field names using ‘getFields’ on the collection. However, when I try to iterate through all the fields to grab their values I’m getting an odd error saying that the “Collection not found.” Maybe this is a misleading error, and I’m not using the MapProxy calls correctly? I know the Collection is accessible.

Thanks as always for all your help! Here are the details:

Function ‘listDataFieldsAndValues’

I started a new module file called ‘utilityfunctions.ts’ to hold the functions outside of ‘extension.ts’ in order to keep things clean and readable. For POC purposes I created a function called ‘listDataFieldsAndValues’ that takes a client and an elementId, and hopefully will eventually return a Map with field names and value. I just want to be able to get at all the data field names and values and put them in the console at this point. I’ve added a handful of troubleshooting console entries as you can see.This function is imported and called from extension.ts based on selected items.

// This module contains a set of functions that can be used to interact with the Lucidc editor.
// Functions here are intended to be used as utility functions for the NextGen Roadmaps extension.
// Written by Matt Wyman in March 2024.

import { ElementProxy, BlockProxy, MapProxy } from "lucid-extension-sdk";

export async function listDataFieldsAndValues(client: any, elementId: string) {
  const elementProxy = new ElementProxy(elementId, client);

  let fieldsSet = new Set();
  let keysSet = new Set();

  // Map to store field values for each field
  let fieldValuesMap = new Map();

  for (const referenceKey of elementProxy.referenceKeys.values()) {
    const dataItemProxy = referenceKey.getItem();
    console.log("DataItemProxy:", dataItemProxy);
    if (!dataItemProxy) {
      console.error("DataItemProxy not found for referenceKey:", referenceKey);
      continue;
    }

    const primaryKey = dataItemProxy.primaryKey;
    keysSet.add(primaryKey);
    console.log("PrimaryKey:", primaryKey);

    const collectionProxy = dataItemProxy.collection;
    console.log("CollectionProxy:", collectionProxy);

    if (collectionProxy && typeof collectionProxy.getFields === "function") {
      try {
        const fields = collectionProxy.getFields();

        console.log("Fields in Collection:", fields);

        if (Array.isArray(fields)) {
          for (const field of fields) {
            try {
              console.log(`Attempting to fetch value for field: ${field}`);
              const fieldValue = dataItemProxy.fields.get(field);
              if (fieldValue !== undefined) {
                // Proceed with processing if the field value is not undefined
                fieldsSet.add(field);
                console.log(`Value for ${field}:`, fieldValue);
                if (!fieldValuesMap.has(field)) {
                  fieldValuesMap.set(field, []);
                }
                fieldValuesMap.get(field).push(fieldValue);
              } else {
                console.error(`Field ${field} is undefined or has no value`);
              }
            } catch (fieldError) {
              console.error(
                `Error fetching value for field ${field}:`,
                fieldError
              );
            }
          }
        } else {
          console.error("fields is not an array", fields);
        }
      } catch (getFieldsError) {
        console.error(
          "Error fetching fields from collectionProxy",
          getFieldsError
        );
      }
    } else {
      console.error(
        "CollectionProxy is undefined or does not have the getFields method",
        collectionProxy
      );
    }
  }
  console.log("Keys Set:", keysSet);
  console.log("Fields Set:", fieldsSet);
  console.log("Field Values Map:", fieldValuesMap);

  return Array.from(fieldsSet);
}

export function connectBlocks(block1: BlockProxy, block2: BlockProxy) {
  block1.getPage().addLine({
    endpoint1: {
      connection: block1,
      linkX: 0.5,
      linkY: 1,
    },
    endpoint2: {
      connection: block2,
      linkX: 0.5,
      linkY: 0,
    },
  });
}

export function toggleHighlight(block: BlockProxy) {
  block.properties.set("Fillcolor", "#ff0000ff");
}

export function getBlockClassName(block: BlockProxy) {
  return block.getClassName;
}

Screen shot of Console

Notice that I get the DataItemProxy and a value Collection with list of fields, but when I go to fetch the value of each field I get an error each time (it repeats the error for all of the fields).

Hello again Connor and the rest of the Lucid team. I was able to test further and I think maybe I’ve found a related bug, although I’ll be happy if I’m mistaken. I am now able to read the field values thanks to your fix and can confirm it works well so far. However, when I try to update a field value using ‘patchItems’ on the CollectionProxy I am getting the same type of error message as before saying it “could not find collection...” 

I set up a simple demonstration in the code below for your review, with a hard-coded update value in string format. I picked a field called “summary” which is just a string to hopefully rule out type compatibility issues. Thanks again for all of your help!

Here’s my function getFieldValueFromElement, and you can see that all of the read the fields from the collection (and display the collection itself) up until I execute the patch command.

export async function getFieldValueFromElement(
  client: EditorClient,
  elementId: string,
  fieldName: string
) {
  // Obtain an ElementProxy for the given elementId
  const elementProxy = new ElementProxy(elementId, client);
  // Check if elementProxy is null or undefined
  if (!elementProxy) {
    throw new Error(`Element with ID ${elementId} not found.`);
  }

  // Iterate over reference keys to find the associated data item
  for (const referenceKey of elementProxy.referenceKeys.values()) {
    const dataItemProxy = referenceKey.getItem();
    if (!dataItemProxy) {
      continue; // Skip if no data item proxy is associated with this reference key
    }

    // Obtain the CollectionProxy from the DataItemProxy
    const collectionProxy = dataItemProxy.collection;
    if (collectionProxy) {
      // Get all field names for the collection
      const fields = collectionProxy.getFields();
      console.log("Fields in Collection:", fields);
      if (fields.includes(fieldName)) {
        // Get the value for the specified field
        const fieldValue = dataItemProxy.fields.get(fieldName);

        if (fieldValue !== undefined) {
          /************************************************************** */
          // Test code for patch ability
          // Assuming passed in field name contains a string value
          /************************************************************** */

          const testNewValue = "Test updated value";

          console.log(`Attempting to change value of ${fieldName}`);
          console.log(`Current Value of ${fieldName}:`, fieldValue);

          const primaryKey = dataItemProxy.primaryKey;

          console.log(`Primary Key:`, primaryKey);

          const changedItems = new Map();
          changedItems.set(primaryKey, { [fieldName]: testNewValue });

          console.log("Changed Items Map:", changedItems);
          console.log("CollectionProxy:", collectionProxy);

          collectionProxy.patchItems({ changed: changedItems });

          console.log(
            `New Value of ${fieldName}:`,
            dataItemProxy.fields.get(fieldName)
          );
          /************************************************************** */

          return fieldValue; // Return the found value
        }
      }
    }
  }

  // If the loop completes without returning, the field was not found
  throw new Error(
    `Field '${fieldName}' not found in any referenced data items.`
  );
}

Here’s a capture of the console log: