On-premises Aviator Workflow examples

async function ActionCanExecute(actionName) {
// ACTION: Generate Test Cases with Aviator
 if (actionName === 'UserDefinedActions.GenerateTestCasesWithAviator') {
    if (!TDConnection.Aviator().isEnabled()) {
      MsgBox('Aviator is not enabled. Please contact your administrator.')
      return false
    }
    try {
      const requirementId = Req_Fields('RQ_REQ_ID').Value
      const reqFactory = TDConnection.ReqFactory
      const reqObj = reqFactory.Item(requirementId)

      const name = removeSpecialChars(getNewLinesReplacedContent(reqObj.Name))
      const descriptionRaw = (getReqDescription() || '').trim()
      let description = stripHtml(descriptionRaw)
      description = removeSpecialChars(getNewLinesReplacedContent(description))

      const response = await TDConnection.Aviator()
        .prompt()
        .persona(
          'You are a seasoned professional in software testing and quality assurance. You specialize in analyzing requirements, identifying risks and edge cases, and designing test cases.'
        )
        .instructions(
          'Design up to 2 test cases covering the most critical aspects of the requirement.'
        )
        .instructions(
          'Include positive and negative scenarios, boundary conditions, potential error states and data-driven tests.'
        )
        .instructions(
          'If the requirement lacks sufficient details, respond with: "The provided requirement details are insufficient to generate comprehensive test cases."'
        )
        .context({ name: name, description: description })
        .format(TDConnection.Formats.TestCases)
        .language(getPreferredLanguage())
        .maxResults(2)
        .send({ loadingTitle: "We're generating your AI powered Test cases" })

      if (response.isEmpty()) {
        return
      }

      if (typeof response.raw === 'string' && !response.isList()) {
        MsgBox(response.raw)
        return
      }

      // Handle text-only responses wrapped in array (AI returned plain text instead of structured data)
      if (response.isList()) {
        const items = response.asList()
        if (items.length > 0 && typeof items[0] === 'string') {
          MsgBox(items.join('\n'))
          return
        }
      }

      const selectedList = await response.showSuggestions({
        title: 'Generate Tests with Aviator',
        description: 'Select suggestions that you want to add as a manual test',
        multiSelect: true
      })

      if (!selectedList || selectedList.length === 0) {
        MsgBox('Test Cases Generation is cancelled.')
        return false
      }

      await CreateTestCasesFromAviator(selectedList)
    } catch (e) {
      HideModalBox()
      MsgBox(e?.message || JSON.stringify(e))
    }
  }  
}  

async function ActionCanExecute(actionName) {
// ACTION: Generate Tests from Media (Attachment)
 if (actionName === 'UserDefinedActions.GenerateTestsFromMedia') {
    if (!TDConnection.Aviator().isEnabled()) {
      MsgBox('Aviator is not enabled. Please contact your administrator.')
      return false
    }
    try {
      const requirementId = Req_Fields('RQ_REQ_ID').Value
      const reqFactory = TDConnection.ReqFactory
      const reqObj = reqFactory.Item(requirementId)
      const attachments = reqObj.Attachments
      const attachList = attachments.NewList('')

      if (attachList.length === 0) {
        MsgBox(
          "This requirement doesn't have any attachments. Please try this option with another requirement, or attach media to the current requirement and try again"
        )
        return
      }

      const attachObj = attachList?.[0]

      const response = await TDConnection.Aviator()
        .prompt()
        .persona(
          'You are a seasoned professional in software testing and quality assurance. You specialize in analyzing requirements, identifying risks and edge cases, and designing test cases.'
        )
        .instructions(
          'Analyze the attached media and design up to 7 test cases covering the most critical aspects.'
        )
        .instructions(
          'Include positive and negative scenarios, boundary conditions, potential error states and data-driven tests.'
        )
        .instructions(
          'If the media lacks sufficient details, respond with: "The provided requirement details are insufficient to generate comprehensive test cases."'
        )
        .attachment(attachObj)
        .format(TDConnection.Formats.TestCases)
        .language(getPreferredLanguage())
        .maxResults(7)
        .send({ loadingTitle: "We're generating your AI powered Test cases" })

      if (response.statusCode === 408) {
        MsgBox('Request timed out. Please try again.')
        return
      }
      if (response.statusCode === 413) {
        MsgBox('Attachment size exceeds 10MB. Please use a smaller file to generate Test cases')
        return
      }

      if (response.isEmpty()) {
        return
      }

      if (typeof response.raw === 'string' && !response.isList()) {
        MsgBox(response.raw)
        return
      }

      // Handle text-only responses wrapped in array (AI returned plain text instead of structured data)
      if (response.isList()) {
        const items = response.asList()
        if (items.length > 0 && typeof items[0] === 'string') {
          MsgBox(items.join('\n'))
          return
        }
      }

      const selectedList = await response.showSuggestions({
        title: 'Generate Tests with Aviator',
        description: 'Select suggestions that you want add as a manual test',
        multiSelect: true
      })

      if (!selectedList || selectedList.length === 0) {
        MsgBox('Test Cases Generation is cancelled.')
        return false
      }

      await CreateTestCasesFromAviator(selectedList)
    } catch (e) {
      HideModalBox()
      MsgBox(e?.message || JSON.stringify(e))
    }
  } 
 
}  

async function ActionCanExecute(actionName) {
// ACTION: Generate User Stories
 if (actionName === 'UserDefinedActions.GenerateUserStories') {
    if (!TDConnection.Aviator().isEnabled()) {
      MsgBox('Aviator is not enabled. Please contact your administrator.')
      return false
    }
    try {
      const reqId = Req_Fields('RQ_REQ_ID').Value
      const reqName = removeSpecialChars(Req_Fields('RQ_REQ_NAME').Value || '')
      const reqDescription = removeSpecialChars(getReqDescription() || '')

      if (!reqName && !reqDescription) {
        MsgBox(
          'Error: Both requirement name and description are empty. Cannot generate user stories.'
        )
        return false
      }

      const userStoriesFormat = TDConnection.Aviator()
        .buildFormat()
        .addField('title', 'string', 'User story title')
        .addField(
          'description',
          'string',
          'In the form: As a [user type], I want [functionality] so that [benefit]'
        )
        .addField('acceptanceCriteria', 'string', 'Acceptance criteria for the story')
        .asList()
        .build()

      const response = await TDConnection.Aviator()
        .prompt()
        .persona('You are a Business Analyst skilled at writing user stories.')
        .instructions('Generate exactly three user stories for this requirement.')
        .instructions(
          'Each story should follow: As a [user type], I want [functionality] so that [benefit]'
        )
        .context({
          requirementName: reqName,
          requirementDescription: stripHtml(reqDescription)
        })
        .format(userStoriesFormat)
        .language(getPreferredLanguage())
        .maxResults(3)
        .send({ loadingTitle: "We're generating your AI powered User Stories", loadingType: 2 })

      if (response.isEmpty() || !response.isList()) {
        MsgBox('Error: Failed to generate user stories from AI.')
        return false
      }

      const selectedList = await response
        .mapToSuggestions({ name: 'title', description: 'description' })
        .showSuggestions({
          title: "We're generating your AI powered User Stories",
          description: 'Select suggestions that you want add as a sub requirements',
          multiSelect: true,
          type: 2
        })

      if (!selectedList || selectedList.length === 0) {
        MsgBox('User stories generation cancelled.')
        return false
      }

      const createdRequirements = await createUserStoryRequirements(selectedList, reqId)
      if (!createdRequirements || createdRequirements.length === 0) {
        return false
      }
    } catch (error) {
      HideModalBox()
      MsgBox('Error: ' + (error.message || JSON.stringify(error)))
    }
  } 
}  

async function ActionCanExecute(actionName) {
// ACTION: Summarize Requirement
if (actionName === 'UserDefinedActions.Summarize') {
    if (!TDConnection.Aviator().isEnabled()) {
      MsgBox('Aviator is not enabled. Please contact your administrator.')
      return false
    }
    try {
      const reqId = Req_Fields('RQ_REQ_ID').Value
      const req = TDConnection.ReqFactory.Item(reqId)
      let name = req.Name

      const commentsRaw = (req.Comment || '').trim()
      const descriptionRaw = (getReqDescription() || '').trim()

      let comments = stripHtml(commentsRaw)
      let description = stripHtml(descriptionRaw)

      if (!description && !comments) {
        MsgBox('Both the Description and Comment fields are empty for this requirement.')
        return false
      }

      name = removeSpecialChars(getNewLinesReplacedContent(name))
      description = removeSpecialChars(getNewLinesReplacedContent(description))
      comments = removeSpecialChars(getNewLinesReplacedContent(comments))

      const response = await TDConnection.Aviator()
        .prompt()
        .persona('You are a technical writer skilled at summarizing requirements.')
        .instructions('Summarize the NAME, DESCRIPTION and COMMENT below in ≤100 words.')
        .context({
          name: name,
          description: description || '<empty>',
          comment: comments || '<empty>'
        })
        .format(TDConnection.Formats.Text)
        .language(getPreferredLanguage())
        .send({ loadingTitle: 'The requirement is being summarized using AI', loadingType: 0 })

      if (response.isEmpty()) {
        MsgBox('Failed to obtain a summary from the AI service.')
        return false
      }

      MsgBox(JSON.stringify(response.data))
    } catch (e) {
      MsgBox(e?.message || JSON.stringify(e))
      HideModalBox()
    }
  } 
}  

async function ActionCanExecute(actionName) {
// ACTION: Reproduction Steps from Video (Defect)
 if (actionName === 'UserDefinedActions.ReproductionStepsFromVideo') {
    if (!TDConnection.Aviator().isEnabled()) {
      MsgBox('Aviator is not enabled. Please contact your administrator.')
      return false
    }
    try {
      const bugId = Bug_Fields('BG_BUG_ID').Value || ''
      const bugFactory = TDConnection.BugFactory
      const bugObj = bugFactory.Item(bugId)
      const attachments = bugObj.Attachments
      const attachList = attachments.NewList('')

      if (attachList.length === 0) {
        MsgBox(
          "This Defect doesn't have any attachments. Please try this option with another requirement, or attach media to the current requirement and try again"
        )
        return
      }

      const attachObj = attachList?.[0]

      const response = await TDConnection.Aviator()
        .prompt()
        .persona(
          'You are a QA expert skilled at analyzing video recordings to identify defect reproduction steps.'
        )
        .instructions('Watch the provided video which describes a defect in our product.')
        .instructions('Generate clear reproduction steps to recreate the issue shown in the video.')
        .instructions(
          'Include specific actions, expected vs actual behavior, and any preconditions visible.'
        )
        .context({
          defectId: bugObj.ID,
          defectName: bugObj.Name,
          currentDate: new Date().toDateString() + ' UTC'
        })
        .attachment(attachObj)
        .format(TDConnection.Formats.Text)
        .language(getPreferredLanguage())
        .send({ loadingTitle: "We're generating Reproduction steps from Video", loadingType: 5 })

      if (response.statusCode === 408) {
        MsgBox('Request timed out. Please try again.')
        return
      }
      if (response.statusCode === 413) {
        MsgBox(
          'Attachment size exceeds 10MB. Please use a smaller file to generate reproduction steps'
        )
        return
      }

      if (!response.isEmpty()) {
        // response.data is the parsed object from the LLM: { type: "text", description: "..." }
        // Extract the plain text description so ModalContainer can render the editable field
        const rawData = response.data
        let reproText =
          (rawData && typeof rawData === 'object' && rawData.description) ||
          (typeof rawData === 'string' ? rawData : '') ||
          ''

        const value = await ShowModalBox({
          title: 'Reproductions steps generated by AI',
          description: 'Please do changes to the content (if required)',
          response: reproText,
          isLoading: false,
          type: 5
        })
        if (value) {
          Bug_Fields('BG_DESCRIPTION').Value = value
        }
      }
    } catch (e) {
      HideModalBox()
      MsgBox(e?.message || JSON.stringify(e))
    }
  } 

}  

async function ActionCanExecute(actionName) {
// ACTION: Generate Tests with Context (Sub-Requirements + Avoid Duplicates)
 // Demonstrates useEntityChildren() and avoidDuplication() context options
  if (actionName === 'UserDefinedActions.GenerateTestsWithContext') {
    if (!TDConnection.Aviator().isEnabled()) {
      MsgBox('Aviator is not enabled. Please contact your administrator.')
      return false
    }
    try {
      const requirementId = Req_Fields('RQ_REQ_ID').Value
      const reqFactory = TDConnection.ReqFactory
      const reqObj = reqFactory.Item(requirementId)

      const name = removeSpecialChars(getNewLinesReplacedContent(reqObj.Name))
      const descriptionRaw = (getReqDescription() || '').trim()
      let description = stripHtml(descriptionRaw)
      description = removeSpecialChars(getNewLinesReplacedContent(description))

      // Fetch sub-requirements to provide as context
      const subRequirements = getSubRequirements(requirementId)

      // Fetch existing linked tests to avoid duplication
      const existingTests = getLinkedTests(requirementId)

      // Build context summary for user
      const contextSummary =
        'Found ' +
        subRequirements.length +
        ' sub-requirement(s) and ' +
        existingTests.length +
        ' existing test(s).'

      // Build prompt with context options
      const promptBuilder = TDConnection.Aviator()
        .prompt()
        .persona(
          'You are a seasoned professional in software testing and quality assurance. ' +
            'You specialize in analyzing requirements hierarchies and designing comprehensive test coverage.'
        )
        .instructions(
          'Design up to 10 test cases that provide comprehensive coverage for this requirement and all its sub-requirements.'
        )
        .instructions(
          'Ensure test cases cover the parent requirement AND each sub-requirement adequately.'
        )
        .instructions(
          'Include positive and negative scenarios, boundary conditions, and integration tests between related requirements.'
        )
        .context({
          requirement: {
            id: requirementId,
            name: name,
            description: description
          },
          subRequirements: subRequirements,
          existingTests: existingTests
        })
        .format(TDConnection.Formats.TestCases)
        .language(getPreferredLanguage())
        .maxResults(10)

      // Apply context options
      if (subRequirements.length > 0) {
        promptBuilder.useEntityChildren()
      }
      if (existingTests.length > 0) {
        promptBuilder.avoidDuplication()
      }

      const response = await promptBuilder.send({
        loadingTitle:
          'Generating AI Test Cases with Context... (' + contextSummary + ')'
      })

      if (response.isEmpty()) {
        MsgBox('No test cases could be generated. Please add more details to the requirement.')
        return
      }

      if (typeof response.raw === 'string' && !response.isList()) {
        MsgBox(response.raw)
        return
      }

      // Handle text-only responses wrapped in array (AI returned plain text instead of structured data)
      if (response.isList()) {
        const items = response.asList()
        if (items.length > 0 && typeof items[0] === 'string') {
          MsgBox(items.join('\n'))
          return
        }
      }

      const selectedList = await response.showSuggestions({
        title: 'Generate Tests with Context',
        description:
          'Generated ' +
          response.asList().length +
          ' tests considering ' +
          subRequirements.length +
          ' sub-requirement(s), avoiding ' +
          existingTests.length +
          ' existing test(s)',
        multiSelect: true
      })

      if (!selectedList || selectedList.length === 0) {
        MsgBox('Test Cases Generation is cancelled.')
        return false
      }

      await CreateTestCasesFromAviator(selectedList)
    } catch (e) {
      HideModalBox()
      MsgBox(e?.message || JSON.stringify(e))
    }
  } 
}  

const requiredFieldsCache = {}

async function safePost(entity, entityName, fieldValuesMap = {}) {
  if (requiredFieldsCache[entityName] && requiredFieldsCache[entityName].__cancelled__) {
    return false
  }
  
  if (requiredFieldsCache[entityName]) {
    for (const fieldName in requiredFieldsCache[entityName]) {
      if (fieldName === '__cancelled__') continue
      try {
        entity.Field[fieldName] = requiredFieldsCache[entityName][fieldName]
        fieldValuesMap[fieldName] = requiredFieldsCache[entityName][fieldName]
      } catch (e) {
        console.warn('Could not apply cached field', fieldName, ':', e)
      }
    }
  }
  try {
    entity.Post()
    return true
  } catch (error) {
    let originalErrorMessage = error?.message || JSON.stringify(error)
    try {
      const errorData = JSON.parse(error?.data)
      if (errorData?.Title) {
        originalErrorMessage = errorData.Title
      }
    } catch (e) {}
    
    const requiredFieldPattern = /The field '.+?' is required/i
    if (!requiredFieldPattern.test(originalErrorMessage)) {
      MsgBox(originalErrorMessage)
      return false
    }
    
    try {
      const fieldValues = await ShowRequiredFieldsWF(entityName, fieldValuesMap)
      
      if (fieldValues) {
        if (!requiredFieldsCache[entityName]) {
          requiredFieldsCache[entityName] = {}
        }
        for (const fieldName in fieldValues) {
          requiredFieldsCache[entityName][fieldName] = fieldValues[fieldName]
        }
        delete requiredFieldsCache[entityName].__cancelled__
        
        for (const fieldName in fieldValues) {
          if (fieldValues.hasOwnProperty(fieldName)) {
            entity.Field[fieldName] = fieldValues[fieldName]
            fieldValuesMap[fieldName] = fieldValues[fieldName]
          }
        }
        
        try {
          entity.Post()
          return true
        } catch (retryError) {
          let retryErrorMessage = retryError?.message || JSON.stringify(retryError)
          try {
            const retryErrorData = JSON.parse(retryError?.data)
            if (retryErrorData?.Title) {
              retryErrorMessage = retryErrorData.Title
            }
          } catch (e) {}
          MsgBox(retryErrorMessage)
          return false
        }
      } else {
        if (!requiredFieldsCache[entityName]) {
          requiredFieldsCache[entityName] = {}
        }
        requiredFieldsCache[entityName].__cancelled__ = true
        MsgBox(originalErrorMessage)
        return false
      }
    } catch (showError) {
      MsgBox(showError?.message || JSON.stringify(showError))
      return false
    }
  }
}

function stripHtml(html) {
  if (TDConnection.Utils?.stripHtml) {
    return TDConnection.Utils.stripHtml(html)
  }
  if (!html) return ''
  if (typeof document !== 'undefined' && document.createElement) {
    const tmp = document.createElement('div')
    tmp.innerHTML = html
    return (tmp.textContent || tmp.innerText || '').replace(/\s+/g, ' ').trim()
  }
  return html
    .replace(/<script[\s\S]*?<\/script>/gi, ' ')
    .replace(/<style[\s\S]*?<\/style>/gi, ' ')
    .replace(/<\/?[^>]+>/g, ' ')
    .replace(/&nbsp;/gi, ' ')
    .replace(/&amp;/gi, '&')
    .replace(/\s+/g, ' ')
    .trim()
}

function removeSpecialChars(str) {
  if (TDConnection.Utils?.removeSpecialChars) {
    return TDConnection.Utils.removeSpecialChars(str)
  }
  return str?.replace(/[^a-zA-Z0-9 ]/g, '')
}

function getNewLinesReplacedContent(str) {
  if (TDConnection.Utils?.normalizeWhitespace) {
    return TDConnection.Utils.normalizeWhitespace(str)
  }
  return str?.replace(/[\r\n]+/g, ' ')
}

function getPreferredLanguage() {
  return TDConnection.GetPreferredLanguage()
}

function getReqDescription() {
  const preferredNames = ['RQ_REQ_COMMENT']
  for (const name of preferredNames) {
    try {
      const f = Req_Fields.Field(name)
      if (f && f.Value) return f.Value
    } catch (_) {}
  }

  for (let i = 1; i <= Req_Fields.Count; i++) {
    const fld = Req_Fields.FieldById(i)
    if (fld && /description/i.test(fld.FieldLabel) && fld.Value) {
      return fld.Value
    }
  }
  return ''
}

/**
 * Fetches all child/sub-requirements for a given parent requirement ID.
 * Uses the standard ReqFactory filter to query by parent-id.
 *
 * @param {number|string} parentReqId - The ID of the parent requirement
 * @returns {Array} Array of simplified sub-requirement objects with id, name, description
 */
function getSubRequirements(parentReqId) {
  const subReqs = []
  try {
    const reqFactory = TDConnection.ReqFactory
    const filter = reqFactory.Filter
    filter.Filter['RQ_FATHER_ID'] = parentReqId
    const children = filter.NewList()

    for (let i = 0; i < children.length; i++) {
      const child = children[i]
      subReqs.push({
        id: child.ID,
        name: child.Name || '',
        description: stripHtml(child.Field['RQ_REQ_COMMENT'] || '')
      })
    }
  } catch (error) {
    console.error('Error fetching sub-requirements:', error)
  }
  return subReqs
}

/**
 * Fetches all tests linked (covered by) to a given requirement ID.
 * Uses TDConnection.CoverageFactory to query coverage entities by requirement ID.
 *
 * @param {number|string} reqId - The ID of the requirement
 * @returns {Array} Array of simplified test objects with id, name, description
 */
function getLinkedTests(reqId) {
  const linkedTests = []
  try {
    // Use TDConnection.CoverageFactory with filter to find coverages for this requirement
    const coverageFactory = TDConnection.CoverageFactory
    const filter = coverageFactory.Filter

    // Filter by requirement ID - coverage entity stores requirement in RC_REQ_ID
    filter.Filter['RC_REQ_ID'] = reqId
    const coverageList = filter.NewList()

    // Process coverage list
    const count = coverageList.length || coverageList.Count || 0

    for (let i = 0; i < count; i++) {
      try {
        const coverage = coverageList[i]
        if (!coverage) continue

        // Get test ID from coverage entity
        // Try different field access patterns
        let testId = null

        if (coverage.Field) {
          testId = coverage.Field['RC_ENTITY_ID'] || coverage.Field['TC_TEST_ID']
        }

        if (!testId) {
          testId = coverage.RC_ENTITY_ID || coverage.TC_TEST_ID || coverage.TestId
        }

        if (!testId) {
          testId = coverage['RC_ENTITY_ID'] || coverage['TC_TEST_ID']
        }

        if (testId) {
          const testFactory = TDConnection.TestFactory
          const test = testFactory.Item(testId)
          if (test) {
            linkedTests.push({
              id: test.ID,
              name: test.Name || '',
              description: stripHtml(
                test.Field ? test.Field['TS_DESCRIPTION'] || '' : test.Description || ''
              )
            })
          }
        }
      } catch (itemError) {
        console.warn('Could not process coverage item ' + i + ':', itemError)
      }
    }
  } catch (error) {
    console.error('Error fetching linked tests:', error)
  }

  return linkedTests
}

async function CreateTestCasesFromAviator(list) {
  if (list?.length > 0) {
    ShowModalBox({
      title: 'Creating Your Selected Test Cases...',
      description:
        "We're processing your selections. The system is adding details and designing test steps behind the scenes",
      isLoading: true,
      type: 1,
      isCreating: true
    })
    const testFolder = await generateAviatorTestFolder()
    if (!testFolder) {
      return
    }
    // Re-show modal in case it was hidden by required fields dialog
    ShowModalBox({
      title: 'Creating Your Selected Test Cases...',
      description:
        "We're processing your selections. The system is adding details and designing test steps behind the scenes",
      isLoading: true,
      type: 1,
      isCreating: true
    })
    const testsList = await generateTests(testFolder, list)
    HideModalBox()
    
    if (testsList && testsList.length > 0) {
      const firstTest = testsList[0]
      ShowModalBox({ title: 'Action Success!', isSuccess: true, result: firstTest })
    }
  }
}

async function getAviatorFolder() {
  const testFolderFactory = TDConnection.TestFolderFactory
  const testFolderFactoryFilter = testFolderFactory.Filter
  testFolderFactoryFilter.Filter['AL_DESCRIPTION'] = "'Tests from aviator'"
  const testFolders = testFolderFactoryFilter.NewList()
  const testFoldersRoot = testFolderFactory.Root

  if (testFolders.length !== 0) {
    for (let i = 0; i < testFolders.length; i++) {
      const testFolder = testFolders[i]
      if (testFolder.Field['AL_FATHER_ID'] == testFoldersRoot.ID) {
        return testFolder
      }
    }
  }

  const newTestFolder = testFolderFactory.AddItem(testFoldersRoot)
  const fieldValuesMap = {}
  newTestFolder.Field['AL_DESCRIPTION'] = 'Tests from aviator'
  fieldValuesMap['AL_DESCRIPTION'] = 'Tests from aviator'
  const success = await safePost(newTestFolder, 'test-folder', fieldValuesMap)
  return success ? newTestFolder : null
}

async function generateAviatorTestFolder() {
  const aviatorFolder = await getAviatorFolder()
  const reqName = Req_Fields('RQ_REQ_NAME').Value
  const reqId = Req_Fields('RQ_REQ_ID').Value

  const existingFolder = getExistingTestFolder(aviatorFolder, reqId)
  if (existingFolder) {
    return existingFolder
  }

  const folderName = '[Workflow] ' + reqName
  const testFolderFactory = aviatorFolder.TestFolderFactory
  const newTestFolder = testFolderFactory.AddItem(aviatorFolder)
  const fieldValuesMap = {}
  newTestFolder.Field['AL_DESCRIPTION'] = folderName
  fieldValuesMap['AL_DESCRIPTION'] = folderName
  newTestFolder.Field['AL_ABSOLUTE_PATH'] = 'aviator_req_' + reqId
  fieldValuesMap['AL_ABSOLUTE_PATH'] = 'aviator_req_' + reqId
  const success = await safePost(newTestFolder, 'test-folder', fieldValuesMap)
  return success ? newTestFolder : null
}

function getExistingTestFolder(aviatorFolder, reqId) {
  try {
    const testFolderFactory = aviatorFolder.TestFolderFactory
    const allFolders = testFolderFactory.NewList()

    for (let i = 0; i < allFolders.length; i++) {
      const folder = allFolders[i]
      const folderPath = folder.Field['AL_ABSOLUTE_PATH'] || ''
      if (folderPath === 'aviator_req_' + reqId) {
        return folder
      }
    }
    return null
  } catch (error) {
    console.error('Error checking existing test folders:', error)
    return null
  }
}

async function generateTests(testFolder, aiResponse) {
  if (!Array.isArray(aiResponse) || aiResponse.length === 0) return
  const testFactory = testFolder.TestFactory
  const newTests = []

  for (let i = 0; i < aiResponse.length; i++) {
    const aiItem = aiResponse[i]
    const newTest = testFactory.AddItem(null)
    const fieldValuesMap = {}
    newTest.Field['TS_DESCRIPTION'] =
      '<html>--- This test is initially created by Aviator in workflow --- <br>' +
      aiItem.description +
      '</html>'
    fieldValuesMap['TS_DESCRIPTION'] =
      '<html>--- This test is initially created by Aviator in workflow --- <br>' +
      aiItem.description +
      '</html>'
    newTest.Field['TS_NAME'] = aiItem.name
    fieldValuesMap['TS_NAME'] = aiItem.name
    newTest.Field['TS_ORIGIN'] = 'aviator'
    fieldValuesMap['TS_ORIGIN'] = 'aviator'
    newTest.Field['TS_RESPONSIBLE'] = User.UserName
    fieldValuesMap['TS_RESPONSIBLE'] = User.UserName
    newTest.Field['TS_IS_AVIATOR_GENERATED'] = 'Yes'
    fieldValuesMap['TS_IS_AVIATOR_GENERATED'] = 'Yes'
    const success = await safePost(newTest, 'test', fieldValuesMap)
    if (!success) continue
    await generateDesignSteps(newTest, aiItem.steps)
    generateCoverages([newTest.ID])
    newTests.push(newTest.ID)
  }

  return newTests
}

async function generateDesignSteps(test, steps) {
  if (!Array.isArray(steps) || steps.length === 0) return
  const designStepFactory = test.DesignStepFactory

  for (let i = 0; i < steps.length; i++) {
    const step = steps[i]
    const newStep = designStepFactory.AddItem(null)
    const fieldValuesMap = {}
    newStep.Field['DS_STEP_NAME'] = 'Step ' + (i + 1)
    fieldValuesMap['DS_STEP_NAME'] = 'Step ' + (i + 1)
    newStep.Field['DS_DESCRIPTION'] = '<html>' + step['description'] + '</html>'
    fieldValuesMap['DS_DESCRIPTION'] = '<html>' + step['description'] + '</html>'
    const expectedResult = step['expected_result'] || step['expected'] || ''
    if (expectedResult) {
      newStep.Field['DS_EXPECTED'] = '<html>' + expectedResult + '</html>'
      fieldValuesMap['DS_EXPECTED'] = '<html>' + expectedResult + '</html>'
    }
    newStep.Field['DS_STEP_ORDER'] = i + 1
    fieldValuesMap['DS_STEP_ORDER'] = i + 1
    await safePost(newStep, 'design-step', fieldValuesMap)
  }
}

function generateCoverages(tests) {
  if (!Array.isArray(tests) || tests.length === 0) return
  const reqFactory = TDConnection.ReqFactory
  const req = reqFactory.Item(Req_Fields('RQ_REQ_ID').Value)

  for (let i = 0; i < tests.length; i++) {
    req.AddCoverage(tests[i])
  }
}

// =============================================================================
// USER STORY CREATION
// =============================================================================

async function createUserStoryRequirements(userStories, parentReqId) {
  const reqFactory = TDConnection.ReqFactory
  const parentReq = reqFactory.Item(parentReqId)
  const createdRequirements = []

  try {
    ShowModalBox({
      title: 'Creating Your selected User Stories...',
      description:
        "We're processing your selections. The system is adding details and sub-requirements behind the scenes",
      isLoading: true,
      type: 2,
      isCreating: true
    })

    for (let i = 0; i < userStories.length; i++) {
      const story = userStories[i]
      const newReq = reqFactory.AddItem(parentReq)
      const fieldValuesMap = {}
      newReq.ParentId = parentReqId
      newReq.Field['RQ_REQ_NAME'] = story.title || story.name
      fieldValuesMap['RQ_REQ_NAME'] = story.title || story.name

      const fullDescription =
        '<html>' +
        '<h3>User Story:</h3>' +
        '<p>' +
        story.description +
        '</p>' +
        '<h3>Acceptance Criteria:</h3>' +
        '<p>' +
        (story.acceptanceCriteria || 'To be defined') +
        '</p>' +
        '<hr>' +
        '<small><i>Generated automatically from parent requirement</i></small>' +
        '</html>'

      const descriptionFields = ['RQ_REQ_COMMENT']
      for (const fieldName of descriptionFields) {
        if (newReq.Field[fieldName] !== undefined) {
          newReq.Field[fieldName] = fullDescription
          fieldValuesMap[fieldName] = fullDescription
          break
        }
      }

      try {
        newReq.Field['RQ_TYPE_ID'] = '3'
        fieldValuesMap['RQ_TYPE_ID'] = '3'
      } catch (e) {}
      try {
        newReq.Field['RQ_REQ_PRIORITY'] = 'Medium'
        fieldValuesMap['RQ_REQ_PRIORITY'] = 'Medium'
      } catch (_) {}
      try {
        newReq.Field['RQ_REQ_AUTHOR'] = User.UserName
        fieldValuesMap['RQ_REQ_AUTHOR'] = User.UserName
      } catch (_) {}

      const success = await safePost(newReq, 'requirement', fieldValuesMap)
      if (!success) {
        continue
      }

      createdRequirements.push({
        id: newReq.ID,
        name: story.title || story.name
      })
    }

    try {
      parentReq.Refresh()
    } catch (_) {}
    HideModalBox()

    if (createdRequirements?.length) {
      ShowModalBox({
        title: 'Action Success!',
        isSuccess: true,
        result: createdRequirements?.[0]?.id,
        type: 2
      })
    } else {
      MsgBox('Failed to create any user story requirements. Please check the required fields.')
    }
    return createdRequirements
  } catch (error) {
    console.error('Error creating user story requirements:', error)
    throw new Error('Failed to create requirements: ' + error.message)
  }
}