private def uploadCreateOrUpdateRecord()

in online_archive/src/main/scala/VidispineFunctions.scala [74:131]
56 lines of code
5 McCabe index (conditional complexity)

  private def uploadCreateOrUpdateRecord(filePath:String, relativePath:String, mediaIngested: VidispineMediaIngested,
                                         archivedRecord: Option[ArchivedRecord]) = {
    logger.info(s"Archiving file '$filePath' to s3://${mediaFileUploader.bucketName}/$relativePath")

    mediaFileUploader.copyFileToS3(new File(filePath), Some(relativePath)).flatMap(fileInfo => {
      val (fileName, fileSize) = fileInfo
      logger.debug(s"$filePath: Upload completed")
      val record = archivedRecord match {
        case Some(rec) =>
          logger.debug(s"actual archivehunter ID for $relativePath is ${rec.archiveHunterID}")
          rec.copy(
            originalFileSize = fileSize,
            uploadedPath = fileName,
            vidispineItemId = mediaIngested.itemId,
            vidispineVersionId = mediaIngested.essenceVersion
          )
        case None =>
          val archiveHunterID = utils.ArchiveHunter.makeDocId(bucket = mediaFileUploader.bucketName, fileName)
          logger.debug(s"Provisional archivehunter ID for $relativePath is $archiveHunterID")
          ArchivedRecord(None,
            archiveHunterID,
            archiveHunterIDValidated=false,
            originalFilePath=filePath,
            originalFileSize=fileSize,
            uploadedBucket = mediaFileUploader.bucketName,
            uploadedPath = fileName,
            uploadedVersion = None,
            vidispineItemId = mediaIngested.itemId,
            vidispineVersionId = mediaIngested.essenceVersion,
            None,
            None,
            None,
            None,
            None,
            "corrid"
          )
      }

      logger.info(s"Updating record for ${record.originalFilePath} with vidispine ID ${mediaIngested.itemId}, vidispine version ${mediaIngested.essenceVersion}. ${if(!record.archiveHunterIDValidated) "ArchiveHunter ID validation is required."}")
      archivedRecordDAO
        .writeRecord(record)
        .map(recId=>Right(record.copy(id=Some(recId)).asJson))
    }).recoverWith(err=>{
      val attemptCount = attemptCountFromMDC() match {
        case Some(count)=>count
        case None=>
          logger.warn(s"Could not get attempt count from diagnostic context for $filePath")
          1
      }
      val rec = FailureRecord(id = None,
        originalFilePath = archivedRecord.map(_.originalFilePath).getOrElse(filePath),
        attempt = attemptCount,
        errorMessage = err.getMessage,
        errorComponent = ErrorComponents.AWS,
        retryState = RetryStates.WillRetry)
      failureRecordDAO.writeRecord(rec).map(_=>Left(err.getMessage))
    })
  }