def backupProjects()

in app/services/NewProjectBackup.scala [464:507]
41 lines of code
7 McCabe index (conditional complexity)

  def backupProjects(onlyInProgress:Boolean):Future[BackupResults] = {
    val parallelCopies = config.getOptional[Int]("backup.parallelCopies").getOrElse(1)

    var backupTypes = Array(1,5)
    val backupTypesSequence = config.getOptional[Seq[Int]]("backup_types").getOrElse(None)
    if (backupTypesSequence != None) {
      backupTypes = backupTypesSequence.iterator.toArray
    }

    def getScanSource() = if(onlyInProgress) {
      ProjectEntry.scanProjectsForStatusAndTypes(EntryStatus.InProduction, backupTypes)
    } else {
      ProjectEntry.scanAllProjects
    }

    for {
      drivers <- loadStorageDrivers()
      storages <- loadAllStorages()
      result <- getScanSource()
        .map(p => {
          logger.debug(s"Checking project ${p.projectTitle} for backup")
          p
        })
        .mapAsync(parallelCopies)(p => p.associatedFiles(allVersions = true).map((p, _)))
        .map(projectAndFiles => {
          val p = projectAndFiles._1
          val f = projectAndFiles._2
          val backupsCount = f.count(_.backupOf.isDefined)
          logger.debug(s"Project ${p.projectTitle} has ${f.length} files of which $backupsCount are backups")
          projectAndFiles
        })
        .mapAsync(parallelCopies)(projectAndFiles => conditionalBackup(projectAndFiles, drivers, storages))
        .toMat(Sink.fold(BackupResults.empty(0))((acc, elem) => elem match {
          case Left(errs) =>
            logger.warn(s"Backup failed: ${errs}")
            acc.copy(totalCount = acc.totalCount + 1, failedCount = acc.failedCount + 1)
          case Right(true) =>
            acc.copy(totalCount = acc.totalCount + 1, successCount = acc.successCount + 1)
          case Right(false) =>
            acc.copy(totalCount = acc.totalCount + 1, notNeededCount = acc.notNeededCount + 1)
        }))(Keep.right)
        .run()
    } yield result
  }