async loadContents()

in parsers/LU/JS/packages/lu/src/parser/qnabuild/builder.ts [33:140]
91 lines of code
17 McCabe index (conditional complexity)

  async loadContents(
    files: string[],
    botName: string,
    suffix: string,
    region: string,
    culture: string,
    schema?: string,
    importResolver?: object) {
    let multiRecognizers = new Map<string, MultiLanguageRecognizer>()
    let settings: any
    let recognizers = new Map<string, Recognizer>()
    let qnaContents = new Map<string, any>()
    let crosstrainedRecognizers = new Map<string, CrossTrainedRecognizer>()
    let qnaObjects = new Map<string, any[]>()

    for (const file of files) {
      let fileCulture: string
      let fileName: string
      let cultureFromPath = fileHelper.getCultureFromPath(file)
      if (cultureFromPath) {
        fileCulture = cultureFromPath
        let fileNameWithCulture = path.basename(file, path.extname(file))
        fileName = fileNameWithCulture.substring(0, fileNameWithCulture.length - cultureFromPath.length - 1)
      } else {
        fileCulture = culture
        fileName = path.basename(file, path.extname(file))
      }

      const fileFolder = path.dirname(file)
      const crossTrainedFileName = fileName + '.lu.qna.dialog'
      const crossTrainedRecognizerPath = path.join(fileFolder, crossTrainedFileName)
      if (!crosstrainedRecognizers.has(fileName)) {
        let crosstrainedRecognizerContent = []
        let crosstrainedRecognizerSchema = schema
        if (fs.existsSync(crossTrainedRecognizerPath)) {
          let crosstrainedRecognizerObject = JSON.parse(await fileHelper.getContentFromFile(crossTrainedRecognizerPath))
          crosstrainedRecognizerContent = crosstrainedRecognizerObject.recognizers
          crosstrainedRecognizerSchema = crosstrainedRecognizerSchema || crosstrainedRecognizerObject.$schema
          this.handler(`${crossTrainedRecognizerPath} loaded\n`)
        }

        crosstrainedRecognizers.set(fileName, new CrossTrainedRecognizer(crossTrainedRecognizerPath, crosstrainedRecognizerContent, crosstrainedRecognizerSchema as string))
      }

      let qnaFiles = await fileHelper.getLuObjects(undefined, file, true, fileExtEnum.QnAFile)
      this.handler(`${file} loaded\n`)

      // filter empty qna files
      qnaFiles = qnaFiles.filter((file: any) => file.content !== '')
      if (qnaFiles.length <= 0) continue

      const multiRecognizerPath = path.join(fileFolder, `${fileName}.qna.dialog`)
      if (!multiRecognizers.has(fileName)) {
        let multiRecognizerContent = {}
        let multiRecognizerSchema = schema
        if (fs.existsSync(multiRecognizerPath)) {
          let multiRecognizerObject = JSON.parse(await fileHelper.getContentFromFile(multiRecognizerPath))
          multiRecognizerContent = multiRecognizerObject.recognizers
          multiRecognizerSchema = multiRecognizerSchema || multiRecognizerObject.$schema
          this.handler(`${multiRecognizerPath} loaded\n`)
        }

        multiRecognizers.set(fileName, new MultiLanguageRecognizer(multiRecognizerPath, multiRecognizerContent, multiRecognizerSchema as string))
      }

      if (settings === undefined) {
        const settingsPath = path.join(fileFolder, `qnamaker.settings.${suffix}.${region}.json`)
        let settingsContent = {}
        if (fs.existsSync(settingsPath)) {
          settingsContent = JSON.parse(await fileHelper.getContentFromFile(settingsPath)).qna
          this.handler(`${settingsPath} loaded\n`)
        }

        settings = new Settings(settingsPath, settingsContent)
      }

      const dialogName = `${fileName}.${fileCulture}.qna`
      const dialogFile = path.join(fileFolder, dialogName + '.dialog')
      let existingDialogObj: any
      if (fs.existsSync(dialogFile)) {
        existingDialogObj = JSON.parse(await fileHelper.getContentFromFile(dialogFile))
        this.handler(`${dialogFile} loaded\n`)
      }

      if (existingDialogObj && schema) {
        existingDialogObj.$schema = schema
      }

      let recognizer = Recognizer.load(file, dialogName, dialogFile, settings, existingDialogObj, schema)
      recognizers.set(dialogName, recognizer)

      if (!qnaContents.has(fileCulture)) {
        let contentPerCulture = new Content('', new qnaOptions(botName, true, fileCulture, file))
        qnaContents.set(fileCulture, contentPerCulture)
        qnaObjects.set(fileCulture, qnaFiles)
      } else {
        // merge contents of qna files with same culture
        let qnaObject = qnaObjects.get(fileCulture)
        if (qnaObject !== undefined) {
          qnaObject.push(...qnaFiles)
        }
      }
    }

    await this.resolveMergedQnAContentIds(qnaContents, qnaObjects, importResolver)

    return {qnaContents: [...qnaContents.values()], recognizers, multiRecognizers, settings, crosstrainedRecognizers}
  }