async loadContents()

in parsers/LU/JS/packages/lu/src/parser/lubuild/builder.ts [32:152]
101 lines of code
18 McCabe index (conditional complexity)

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

    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 - fileCulture.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 fileContent = ''
      let result
      let luisObj
      let luFiles = await fileHelper.getLuObjects(undefined, file, true, fileExtEnum.LUFile)
      this.handler(`${file} loaded\n`)

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

      try {
        result = await LuisBuilderVerbose.build(luFiles, true, fileCulture, importResolver)
        luisObj = new Luis(result)
        fileContent = luisObj.parseToLuContent()
      } catch (err) {
        if (err.source) {
          err.text = `Invalid LU file ${err.source}: ${err.text}`
        } else {
          err.text = `Invalid LU file ${file}: ${err.text}`
        }
        throw (new exception(retCode.errorCode.INVALID_INPUT_FILE, err.text))
      }

      const multiRecognizerPath = path.join(fileFolder, `${fileName}.lu.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, `luis.settings.${suffix}.${region}.json`)
        let settingsContent = {}
        if (fs.existsSync(settingsPath)) {
          settingsContent = JSON.parse(await fileHelper.getContentFromFile(settingsPath)).luis
          this.handler(`${settingsPath} loaded\n`)
        }

        settings = new Settings(settingsPath, settingsContent)
      }

      const content = new Content(fileContent, new LUOptions(fileName, true, fileCulture, file))
      luContents.push(content)

      const dialogFile = path.join(fileFolder, `${content.name}.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(content.path, content.name, dialogFile, settings, existingDialogObj, schema)
      recognizers.set(content.name, recognizer)
    }

    // validate if there are duplicated files with same name and locale
    let setOfContents = new Set()
    const hasDuplicates = luContents.some(function (currentObj) {
      return setOfContents.size === setOfContents.add(currentObj.name).size
    })

    if (hasDuplicates) {
      throw(new exception(retCode.errorCode.INVALID_INPUT_FILE, 'Files with same name and locale are found.'))
    }

    return {luContents, recognizers, multiRecognizers, settings, crosstrainedRecognizers}
  }