def getRankingCountAsync()

in s2rest_play/app/org/apache/s2graph/rest/play/controllers/CounterController.scala [471:531]
51 lines of code
11 McCabe index (conditional complexity)

  def getRankingCountAsync(service: String, action: String) = Action.async { implicit request =>
    lazy val intervalUnits = getQueryString("interval", getQueryString("step", "t")).split(',').toSeq
      .map(IntervalUnit.withName)
    lazy val limit = getQueryString("limit", "1").toInt
    lazy val kValue = getQueryString("k", "10").toInt

    lazy val qsSum = request.getQueryString("sum")

    lazy val optFrom = request.getQueryString("from").filter(!_.isEmpty).map(UnitConverter.toMillis)
    lazy val optTo = request.getQueryString("to").filter(!_.isEmpty).map(UnitConverter.toMillis)

    // find dimension
    lazy val dimensionMap = request.queryString.filterKeys { k => k.charAt(0) == ':' }.map { case (k, v) =>
      (k.substring(1), v.mkString(",").split(',').toList)
    }

    val dimensions = {
      for {
        values <- CartesianProduct(dimensionMap.values.toList).toSeq
      } yield {
        dimensionMap.keys.zip(values).toMap
      }
    }

    counterModel.findByServiceAction(service, action) match {
      case Some(policy) =>
        val tqs = TimedQualifier.getQualifiersToLimit(intervalUnits, limit, optTo)
        val dimKeys = {
          for {
            dimension <- dimensions
          } yield {
            dimension -> tqs.map(tq => RankingKey(policy.id, policy.version, ExactQualifier(tq, dimension)))
          }
        }

        // if tqs has only 1 tq, do not apply sum function
        try {
          val rankResult = {
            if (tqs.length > 1 && qsSum.isDefined) {
              getSumRankCounterResultAsync(policy, dimKeys, kValue, qsSum)
            } else {
              // no summary
              Future.successful(getRankCounterResult(policy, dimKeys, kValue))
            }
          }

          rankResult.map { result =>
            Ok(Json.toJson(result))
          }
        } catch {
          case e: UnsupportedOperationException =>
            Future.successful(NotImplemented(Json.toJson(
              Map("msg" -> e.getMessage)
            )))
          case e: Throwable =>
            throw e
        }
      case None =>
        Future.successful(NotFound(Json.toJson(Map("msg" -> s"$service.$action not found"))))
    }
  }