How to make it more Scala compatible?
What you have isn't bad, but I feel like you're creating too many variables. For example, in getAuditID and other methods, you assign an object to a variable and immediately return it. You also have some unnecessary type annotations.
def getAuditID: String = {
    val instant: Instant = Instant.now
    val zoneId: ZoneId = ZoneId.of(&quot;Canada/Eastern&quot;)
    val auditIdFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern(&quot;yyyyMMddHHmmssSSS&quot;)
    val auditId = ZonedDateTime.ofInstant(instant, zoneId).format(auditIdFormatter)
    auditId
}

After eliminating that, I got this:
abstract class FileSystem(flagFileURI: String) {

  def getRecordCount(properties: Properties): String =
    properties.getProperty(&quot;recordCount&quot;)

  def getAuditID: String =
    ZonedDateTime
      .ofInstant(Instant.now, ZoneId.of(&quot;Canada/Eastern&quot;))
      .format(DateTimeFormatter.ofPattern(&quot;yyyyMMddHHmmssSSS&quot;))

  def getSourcePath(properties: Properties): Path =
    new Path(properties.getProperty(&quot;dataFileURI&quot;))

  def getMetaDataFileURI(properties: Properties): String =
    properties.getProperty(&quot;metadataFileURI&quot;)

  def getIDPDataDate(properties: Properties): String =
    properties.getProperty(&quot;idpDataDate&quot;)

  def getDataFileName(srcPath: Path, auditID: String): String =
    srcPath.getName + &quot;_&quot; + getAuditID

  def getDestinationPath(
      properties: Properties,
      metaDataFileURI: String,
      IDPDataDate: String,
      dataFileName: String
  ): Path = {
    val l0DirLocation =
      ConfigFactory.load().getString(&quot;sparkFramework.hdfs.l0dirlocation&quot;)
    val frameWorkUtils = new FrameworkUtils()
    val sourceSystem =
      frameWorkUtils.getSourceSystem(metaDataFileURI)
    val schemaName = frameWorkUtils.getSchemaName(sourceSystem)
    val tableName = frameWorkUtils.getTableName(sourceSystem)

    new Path(
      l0DirLocation + schemaName + &quot;/&quot; + tableName + &quot;/idp_data_date=&quot; + IDPDataDate + &quot;/&quot; + dataFileName
    )
  }
}

However, your other method, copyFromLocalFile, could also be improved. The return type is a tuple of 5 strings, which to me seems much too complex. Instead of that, I'd suggest making a case class that makes it obvious what each of those strings mean.
case class FileInfo(
    IDPDataDate: String,
    recordCount: String,
    auditId: String,
    metaDataFileURI: String,
    dataFileName: String
)

Then you can define this method in FileSystem to get all the information at once
def getFileInfo(properties: Properties): FileInfo = {
    val auditId = getAuditID
    FileInfo(
      getIPDDataDate(properties),
      getRecordCount(properties),
      auditId,
      getMetaDataFileURI(properties),
      getDataFileName(getSourcePath(properties), auditID)
    )
}

After that, you can turn your method into something like this:
def copyFromLocalFile: FileInfo = {

    val properties: Properties = new Properties()

    properties.load(Source.fromFile(flagFileURI).reader)

    val fileInfo = getFileInfo(properties)

    FileSystem
      .get(new Configuration())
      .copyFromLocalFile(
        true,
        false,
        fileInfo.srcPath,
        getDestinationPath(
          properties,
          fileInfo.metaDataFileURI,
          fileInfo.IDPDataDate,
          fileInfo.dataFileName
        )
      )

    fileInfo
}

You can still destructure the result:
val FileInfo(idpDataDate, count, auditId, metadataFileURI, fileName) =
  hdFileSystem.copyFromLocalFile

Of course, I don't know about the whole structure of your program, so this might not work for you.
Link to Scastie