def uploadIfRequiredAndNotExists()

in online_archive/src/main/scala/VidispineFunctions.scala [148:189]
40 lines of code
8 McCabe index (conditional complexity)

  def uploadIfRequiredAndNotExists(filePath: String,
                                   relativePath: String,
                                   mediaIngested: VidispineMediaIngested): Future[Either[String, Json]] = {
    logger.debug(s"uploadIfRequiredAndNotExists: Original file is $filePath, target path is $relativePath")
    for {
      maybeArchivedRecord <- archivedRecordDAO.findBySourceFilename(filePath)
      maybeIgnoredRecord <- ignoredRecordDAO.findBySourceFilename(filePath)
      maybeFailureRecord <- failureRecordDAO.findBySourceFilename(filePath)
      result <- (maybeIgnoredRecord, maybeArchivedRecord) match {
        case (Some(ignoreRecord), _) =>
          Future(Left(s"${filePath} should be ignored due to reason ${ignoreRecord.ignoreReason}"))
        case (None, Some(archivedRecord)) =>
          showPreviousFailure(maybeFailureRecord, filePath)
          MDC.put("correlationId", archivedRecord.correlationId)

          if(archivedRecord.archiveHunterID.isEmpty || !archivedRecord.archiveHunterIDValidated) {
            logger.info(s"Archive hunter ID does not exist yet for filePath $filePath, will retry")
            Future(Left(s"Archive hunter ID does not exist yet for filePath $filePath, will retry"))
          } else Future.fromTry(mediaFileUploader.objectExists(archivedRecord.uploadedPath))
            .flatMap(exist => {
              if (exist) {
                logger.info(s"Filepath $filePath already exists in S3 bucket")
                val record = archivedRecord.copy(
                  vidispineItemId = mediaIngested.itemId,
                  vidispineVersionId = mediaIngested.essenceVersion
                )

                logger.info(s"Updating record for ${record.originalFilePath} with vidispine ID ${mediaIngested.itemId} and version ${mediaIngested.essenceVersion}")
                archivedRecordDAO
                  .writeRecord(record)
                  .map(recId=>Right(record.copy(id=Some(recId)).asJson))
              } else {
                logger.warn(s"Filepath $filePath does not exist in S3, re-uploading")
                uploadCreateOrUpdateRecord(filePath, relativePath, mediaIngested, Some(archivedRecord))
              }
            })
        case (None, None) =>
          showPreviousFailure(maybeFailureRecord, filePath)
          uploadCreateOrUpdateRecord(filePath, relativePath, mediaIngested, None)
      }
    } yield result
  }