[OG-4]: Get case fields based on uuid for update case (#1282)

## TL;DR
Fetches the case fields based on the case UUID that is selected or input.
Works with pasted case UUID and variables.

## Why make this change?
Ensures that the fields are valid for the selected case.
* Previous implementation fetched the fields based on the last case that was created in OG, but OG can have multiple case types.
* Reduces errors for user than if they were to manually type in the field


## Tests
- [ ] Correct fields are fetched for different case UUIDs
- [ ] Update case fetches correct fields with case uuid variable
- [ ] Update case fetches correct fields with case uuid variable from for each

Author: kevinkim-ogp

packages/backend/src/apps/gathersg/actions/create-case/index.ts

@@ -23,7 +23,7 @@ const action: IRawAction = {
       label: 'Case type',
       key: 'caseType',
       type: 'dropdown' as const,
-      description: 'Enter the type of the case you want to create',
+      description: 'Select the type of the case you want to create',
       required: true,
       variables: false,
       showOptionValue: false,

packages/backend/src/apps/gathersg/actions/update-case/index.ts

@@ -20,17 +20,19 @@ const action: IRawAction = {
       label: 'Case UUID',
       key: 'caseUuid',
       type: 'string' as const,
-      description: 'Enter the case uuid you want to update',
+      description: 'Select the case uuid you want to update.',
       required: true,
       variables: true,
+      // we intentionally disable typing for case uuid as it is used in
+      // to get dynamic data for case fields
+      // it can still be pasted via mouse click
       singleVariableSelection: true,
     },
-    // TODO: see if it is possible to get all possible statuses from the API
     {
       label: 'Case status',
       key: 'caseStatus',
       type: 'dropdown' as const,
-      description: 'Enter the status you want to update the case to.',
+      description: 'Select the status you want to update the case to.',
       required: false,
       variables: false,
       showOptionValue: false,
@@ -65,6 +67,10 @@ const action: IRawAction = {
                 name: 'key',
                 value: 'getCaseFields',
               },
+              {
+                name: 'parameters.caseUuid',
+                value: '{parameters.caseUuid}',
+              },
             ],
           },
           customStyle: { flex: 2 },

packages/backend/src/apps/gathersg/dynamic-data/get-case-fields.ts

@@ -5,54 +5,112 @@ import {
 } from '@plumber/types'
 
 import HttpError from '@/errors/http'
+import { VARIABLE_REGEX } from '@/helpers/check-step-parameters'
+import { computeForEachParameters } from '@/helpers/compute-for-each-parameters'
+import computeParameters from '@/helpers/compute-parameters'
+import { getTestExecutionSteps } from '@/helpers/get-test-execution-steps'
 
-import { fetchCaseFields } from '../common/fetch-case-fields'
-import { GatherSGError } from '../common/types'
-
-/**
- * Subset of result
- */
-interface GatherSGCase {
-  uuid: string
-  createdAt: string
-  updatedAt: string
-  status: {
-    uuid: string
-    name: string
-    color: string
-    isFinal: boolean
+import { fetchCaseFields, GatherSGCaseField } from '../common/fetch-case-fields'
+import { GatherSGCase, GatherSGError } from '../common/types'
+
+const getCaseUuidFromVariable = async (
+  $: IGlobalVariable,
+  variable: string,
+) => {
+  const testExecutionSteps = await getTestExecutionSteps($.flow.id)
+
+  if (/items.columns/.test(variable)) {
+    // if variable from for each, then we compute slightly differently
+    const stepIdAndKeyPath = variable.replace(/{{step.|}}/g, '') as string
+    const [stepId, ...keyPaths] = stepIdAndKeyPath.split('.')
+
+    const executionStep = testExecutionSteps.find((executionStep) => {
+      return executionStep.stepId === stepId
+    })
+
+    if (!executionStep) {
+      return ''
+    }
+
+    return computeForEachParameters({
+      data: executionStep?.dataOut,
+      keyPath: keyPaths.join('.'),
+      executionSteps: testExecutionSteps,
+      executionStep,
+      stepId,
+      forEachContext: {
+        executionStepMetadata: testExecutionSteps[0].metadata,
+        forEachStepPosition: 0,
+        isForEachStep: true,
+        stepPositions: {
+          [stepId]: 0,
+        },
+      },
+    })
+  } else {
+    const { caseUuid } = computeParameters(
+      { caseUuid: variable },
+      testExecutionSteps,
+    )
+    return caseUuid
+  }
+}
+
+const processCaseFields = (caseFields: GatherSGCaseField[]) => {
+  return {
+    data: caseFields.map((field) => {
+      return {
+        name: field.name,
+        value: field.name,
+      }
+    }),
   }
-  caseRef: string
-  fields: Record<string, string | string[] | null | number>
-  tags: string[]
 }
 
 const dynamicData: IDynamicData = {
   key: 'getCaseFields',
   name: 'Get Case Fields',
   async run($: IGlobalVariable): Promise<DynamicDataOutput> {
     try {
-      const { caseType: caseTypeUuid } = $.step.parameters
+      const { caseType: caseTypeUuid, caseUuid } = $.step.parameters
 
       if (caseTypeUuid) {
+        // Fetch case fields using the determined case type UUID
         const { filteredFields } = await fetchCaseFields({
           $,
           caseTypeUuid: caseTypeUuid as string,
         })
 
+        return processCaseFields(filteredFields)
+      } else if (caseUuid) {
+        if (
+          typeof caseUuid === 'string' &&
+          caseUuid.match(`^${VARIABLE_REGEX.source}$`)
+        ) {
+          // if the case uuid is a variable, we need to compute the value
+          const computedCaseUuid = await getCaseUuidFromVariable($, caseUuid)
+
+          // use the case uuid to fetch the case data to derive the case type uuid
+          const { data: caseData } = await $.http.get<{ data: GatherSGCase }>(
+            `/cases/:caseUuid`,
+            {
+              urlPathParams: { caseUuid: computedCaseUuid as string },
+            },
+          )
+
+          const { filteredFields } = await fetchCaseFields({
+            $,
+            caseTypeUuid: caseData.data.type.uuid,
+          })
+          return processCaseFields(filteredFields)
+        }
+
         return {
-          data: filteredFields.map((field) => {
-            return {
-              name: field.name,
-              value: field.name,
-            }
-          }),
+          data: [],
         }
       }
 
-      // TODO (kevinkim-ogp): this needs to be updated to use the caseUuid to fetch the fields
-      // of that specific case using /cases/{caseUuid}
-      // need to figure out how to do this with both string and computed parameters if the UUID is a variable
+      // BACKWARD COMPATIBILITY: this gets the case fields from the latest case in gathersg
       const { data: searchResult } = await $.http.post<{
         traceId: string
         total: number