private def limitToChannelQuery()

in src/main/scala/datastore/ElasticsearchRepo.scala [136:185]
44 lines of code
5 McCabe index (conditional complexity)

  private def limitToChannelQuery(channel:String):Query = NestedQuery(
    path="channels",
    query=BoolQuery(must=Seq(
      MatchQuery("channels.channelId", channel),
      MatchQuery("channels.fields.isAvailable", true)
    ))
  )

  private val standardAvailabilityQuery:Seq[Query] = Seq(
    MatchQuery("isExpired", false),
    MatchQuery("isGone", false),
  )
  override def marshalledDocs(queryString: Option[String], queryFields: Option[Seq[String]],
                              atomId: Option[String], forChannel:Option[String], userTier:UserTier,
                              tagIds: Option[Seq[String]], excludeTags: Option[Seq[String]],
                              sectionIds: Option[Seq[String]], excludeSections: Option[Seq[String]],
                              orderDate: Option[String], orderBy: Option[SortOrder],
                              limit: Option[Int], cursor: Option[String]): Future[Edge[Content]] = {
    val pageSize = limit.getOrElse(defaultPageSize)

    val fieldsToQuery = queryFields
      .getOrElse(Seq("webTitle", "path"))  //default behaviour from Concierge
      .map(FieldWithOptionalBoost(_, None))

    //only internal tier users are allowed to query other channels
    val selectedChannel = if(userTier==InternalTier) forChannel.getOrElse("open") else "open"

    val params:Seq[Query] = standardAvailabilityQuery ++ Seq(
      Some(limitToChannelQuery(selectedChannel)),
      queryString.map(MultiMatchQuery(_, fields = fieldsToQuery)),
      atomId.map(MatchQuery("atomIds.id", _)),
      tagIds.map(tags=>BoolQuery(should=tags.map(MatchQuery("tags", _)))) ,
      excludeTags.map(tags=>BoolQuery(not=Seq(BoolQuery(should=tags.map(MatchQuery("tags", _)))))),
      sectionIds.map(s=>BoolQuery(should=s.map(MatchQuery("sectionId", _)))),
      excludeSections.map(s=>BoolQuery(not=Seq(BoolQuery(should=s.map(MatchQuery("sectionId", _))))))
    ).collect({case Some(q)=>q})

    Edge.decodeCursor(cursor) match {
      case Right(maybeCursor) =>
        client.execute {
          search("content")
            .query(BoolQuery(must=params))
            .sortBy(defaultingSortParam(orderDate, orderBy))
            .limit(pageSize)
            .searchAfter(maybeCursor)
        }.flatMap(handleResponseMultiple(_, pageSize)(contentTransform))
      case Left(err) =>
        Future.failed(new RuntimeException(s"Unable to decode cursor value $cursor: $err"))
    }
  }