Add endpoint to get workset volumes by workset ID using volume-level …

…aggregated collection.

app/controllers/EfController.scala

@@ -102,6 +102,20 @@ class EfController @Inject()(efRepository: EfRepository,
       }
     }
 
+  def getWorksetVolumesAggregated(@ApiParam(value = "the workset ID", required = true) wid: WorksetId,
+                                  @ApiParam(value = "comma-separated list of fields to return") fields: Option[String]): Action[AnyContent] = {
+    //TODO: Add query parameter to specify whether to include POS information if that data becomes available in the future
+    Action.async { implicit req =>
+      render.async {
+        case Accepts.Json() =>
+          efRepository
+            .getWorkset(wid)
+            .flatMap(workset => efRepository.getVolumesAggregated(workset.htids, withPos = false, fields.map(tokenize(_)).getOrElse(List.empty)))
+            .map(WrappedResponse(_))
+      }
+    }
+  }
+
   def getWorksetVolumesMetadata(@ApiParam(value = "the workset ID", required = true) wid: WorksetId,
                                 @ApiParam(value = "comma-separated list of fields to return") fields: Option[String]): Action[AnyContent] =
     Action.async { implicit req =>

app/exceptions/VolumeNotFoundException.scala

@@ -2,3 +2,6 @@ package exceptions
 
 case class VolumeNotFoundException(id: String, cause: Throwable = null)
   extends ResourceNotFoundException(s"Volume $id not found", cause)
+
+case class NotImplementedException(msg: String, cause: Throwable = null)
+  extends RuntimeException(msg, cause)

app/repo/EfRepository.scala

@@ -11,6 +11,7 @@ trait EfRepository {
   def hasVolume(id: VolumeId): Future[Boolean]
   def getVolume(id: VolumeId, withPos: Boolean = true, fields: List[String] = List.empty): Future[JsObject]
   def getVolumes(ids: IdSet, withPos: Boolean = true, fields: List[String] = List.empty): Future[List[JsObject]]
+  def getVolumesAggregated(ids: IdSet, withPos: Boolean = false, fields: List[String] = List.empty): Future[List[JsObject]]
   def getVolumePages(id: VolumeId, pageSeqs: Option[PageSet] = None, withPos: Boolean = true, fields: List[String] = List.empty): Future[JsObject]
 
   def getVolumeMetadata(id: VolumeId, fields: List[String] = List.empty): Future[JsObject]

app/repo/EfRepositoryMongoImpl.scala

@@ -1,7 +1,7 @@
 package repo
 
 import akka.stream.Materializer
-import exceptions.{VolumeNotFoundException, WorksetNotFoundException}
+import exceptions.{NotImplementedException, VolumeNotFoundException, WorksetNotFoundException}
 import play.api.Logging
 import play.api.libs.json._
 import reactivemongo.api.bson._
@@ -29,6 +29,8 @@ class EfRepositoryMongoImpl @Inject()(val reactiveMongoApi: ReactiveMongoApi)
     reactiveMongoApi.database.map(_.collection[BSONCollection]("ef"))
   protected def featuresCol: Future[BSONCollection] =
     reactiveMongoApi.database.map(_.collection[BSONCollection]("features"))
+  protected def featuresAggNoPosCol: Future[BSONCollection] =
+    reactiveMongoApi.database.map(_.collection[BSONCollection]("featuresAggNoPos"))
   protected def metadataCol: Future[BSONCollection] =
     reactiveMongoApi.database.map(_.collection[BSONCollection]("metadata"))
   protected def pagesCol: Future[BSONCollection] =
@@ -51,6 +53,9 @@ class EfRepositoryMongoImpl @Inject()(val reactiveMongoApi: ReactiveMongoApi)
   override def getVolumes(ids: IdSet, withPos: Boolean = true, fields: List[String] = List.empty): Future[List[JsObject]] =
     if (withPos) getVolumesWithPos(ids, fields) else getVolumesNoPos(ids, fields)
 
+  override def getVolumesAggregated(ids: IdSet, withPos: Boolean = false, fields: List[String] = List.empty): Future[List[JsObject]] =
+    if (withPos) getVolumesAggregatedWithPos(ids, fields) else getVolumesAggregatedNoPos(ids, fields)
+
   protected def getVolumeWithPos(id: VolumeId, fields: List[String] = List.empty): Future[JsObject] =
     getVolumesWithPos(Set(id), fields).map {
       case vol :: Nil => vol
@@ -484,6 +489,77 @@ class EfRepositoryMongoImpl @Inject()(val reactiveMongoApi: ReactiveMongoApi)
     } yield volumes
   }
 
+  // Reference MongoDB Query for getVolumesAggregatedNoPos
+  //  db.getCollection("metadata").aggregate([
+  //    {
+  //      $match: {
+  //      htid: { $in: ['gri.ark:/13960/t1fj9k903'] }
+  //    }
+  //    },
+  //    {
+  //      $lookup: {
+  //      from: 'featuresAggNoPos',
+  //      let: { htid: '$htid' },
+  //      pipeline: [
+  //    {
+  //      $match: {
+  //      $expr: {
+  //      $eq: ['$htid', '$$htid']
+  //    }
+  //    }
+  //    },
+  //    { $project: { _id: 0 } },
+  //    { $replaceRoot: { newRoot: '$features' } }
+  //      ],
+  //      as: 'features'
+  //    }
+  //    },
+  //    {
+  //      $unwind: '$features'
+  //    },
+  //    {
+  //      $project: {
+  //      _id: 0
+  //    }
+  //    }
+  //  ])
+  private def getVolumesAggregatedNoPos(ids: IdSet, fields: List[String] = List.empty): Future[List[JsObject]] = {
+
+    val projFields = BSONDocument(fields.map(f => f -> BSONInteger(1)))
+
+    for {
+      col <- efCol; features <- featuresAggNoPosCol; metadata <- metadataCol;
+      volumes <- metadata
+        .aggregateWith[JsObject]() { framework =>
+          import framework._
+
+          val query = if (ids.isEmpty) document() else document("htid" -> document("$in" -> ids))
+
+          List(
+            Match(query),
+            LookupPipeline(
+              from = features.name,
+              let = document("htid" -> "$htid"),
+              pipeline = List(
+                Match(document("$expr" -> document("$eq" -> List("$htid", """$$htid""")))),
+                Project(document("_id" -> 0)),
+                ReplaceRootField("features")
+              ),
+              as = "features"
+            ),
+            UnwindField("features"),
+            Project(document("_id" -> 0) ++ projFields)
+          )
+        }
+        .collect[List]()
+    } yield volumes
+  }
+
+  //TODO: Implement this method after the aggregated collection with POS information is available
+  private def getVolumesAggregatedWithPos(ids: IdSet, fields: List[String] = List.empty): Future[List[JsObject]] = {
+    throw NotImplementedException("Volume level aggregation with POS information not implemented yet.")
+  }
+
   override def getVolumeMetadata(id: VolumeId, fields: List[String] = List.empty): Future[JsObject] = {
     val ids = Set(id)
     getVolumesMetadata(ids, fields).map {

conf/routes

@@ -21,4 +21,5 @@ POST    /worksets                       controllers.EfController.createWorkset()
 GET     /worksets/:id                   controllers.EfController.getWorkset(id)
 DELETE  /worksets/:id                   controllers.EfController.deleteWorkset(id)
 GET     /worksets/:id/volumes           controllers.EfController.getWorksetVolumes(id, pos: Boolean ?= true, fields: Option[String] ?= None)
+GET     /worksets/:id/volumes/aggregated    controllers.EfController.getWorksetVolumesAggregated(id, fields: Option[String] ?= None)
 GET     /worksets/:id/metadata          controllers.EfController.getWorksetVolumesMetadata(id, fields: Option[String] ?= None)