def imagePersistenceReasons()

in media-api/app/lib/ImageResponse.scala [53:130]
60 lines of code
6 McCabe index (conditional complexity)

  def imagePersistenceReasons(image: Image): List[String] = imgPersistenceReasons.reasons(image)

  def canBeDeleted(image: Image) = image.canBeDeleted

  def create(
              id: String,
              imageWrapper: SourceWrapper[Image],
              withWritePermission: Boolean,
              withDeleteImagePermission: Boolean,
              withDeleteCropsOrUsagePermission: Boolean,
              included: List[String] = List(), tier: Tier): (JsValue, List[Link], List[Action]) = {

    val image = imageWrapper.instance

    val source = Try {
      Json.toJsObject(image)(imageResponseWrites(image.id, included.contains("fileMetadata"))) ++ imageWrapper.fields
    }.recoverWith {
      case e =>
        logger.error(s"Failed to read ElasticSearch response $id into Image object: ${e.getMessage}")
        Failure(e)
    }.get

    val pngFileUri = image.optimisedPng.map(_.file)

    val fileUri = image.source.file

    val imageUrl = s3Client.signUrl(config.imageBucket, fileUri, image, imageType = Source)
    val pngUrl: Option[String] = pngFileUri
      .map(s3Client.signUrl(config.imageBucket, _, image, imageType = OptimisedPng))

    def s3SignedThumbUrl = s3Client.signUrl(config.thumbBucket, fileUri, image, imageType = Thumbnail)

    val thumbUrl = config.cloudFrontDomainThumbBucket
      .flatMap(s3Client.signedCloudFrontUrl(_, fileUri.getPath.drop(1)))
      .getOrElse(s3SignedThumbUrl)

    val validityMap = checkUsageRestrictions(source, ImageExtras.validityMap(image, withWritePermission))
    val valid = ImageExtras.isValid(validityMap)
    val invalidReasons = ImageExtras.invalidReasons(validityMap, config.customValidityDescription)

    val downloadableMap = checkDownloadRestrictions(source, ImageExtras.downloadableMap(image, withWritePermission), withWritePermission)
    val isDownloadable = ImageExtras.isValid(downloadableMap)

    val persistenceReasons = imagePersistenceReasons(image)
    val isPersisted = persistenceReasons.nonEmpty

    val aliases = extractAliasFieldValues(config, imageWrapper)

    val data = source.transform(addSecureSourceUrl(imageUrl))
      .flatMap(_.transform(wrapUserMetadata(id)))
      .flatMap(_.transform(addSecureThumbUrl(thumbUrl)))
      .flatMap(_.transform(
        pngUrl
          .map(url => addSecureOptimisedPngUrl(url))
          .getOrElse(__.json.pick)
      ))
      .flatMap(_.transform(addValidity(valid)))
      .flatMap(_.transform(addInvalidReasons(invalidReasons)))
      .flatMap(_.transform(addUsageCost(source)))
      .flatMap(_.transform(addPersistedState(isPersisted, persistenceReasons)))
      .flatMap(_.transform(addSyndicationStatus(image)))
      .flatMap(_.transform(addAliases(aliases)))
      .flatMap(_.transform(addFromIndex(imageWrapper.fromIndex)))
      .flatMap(_.transform(updateCustomSpecialInstructions(source)))
      .flatMap(_.transform(updateCustomUsageRestrictions(source)))
      .get

    val links: List[Link] = tier match {
      case Internal => imageLinks(id, imageUrl, pngUrl, withWritePermission, valid) ++ getDownloadLinks(id, isDownloadable)
      case _ => List(downloadLink(id), downloadOptimisedLink(id))
    }

    val isDeletable = canBeDeleted(image) && withDeleteImagePermission

    val actions: List[Action] = if (tier == Internal) imageActions(id, isDeletable, withWritePermission, withDeleteCropsOrUsagePermission) else Nil

    (data, links, actions)
  }