#1946 Use direct index for count

frontend/app/scripts/controllers/RootCtrl.js

@@ -95,9 +95,7 @@ angular.module('theHiveControllers').controller('RootCtrl',
         });
 
         StreamQuerySrv('v1', [
-            {_name: 'listAlert'},
-            {_name: 'filter', _field: 'read', _value: false},
-            {_name: 'count'}
+            {_name: 'countUnreadAlert'},
         ], {
             scope: $scope,
             rootId: 'any',

thehive/app/org/thp/thehive/controllers/v1/AlertCtrl.scala

@@ -56,6 +56,16 @@ class AlertCtrl @Inject() (
   implicit val caseFilterParser: FieldsParser[Option[InputQuery[Traversal.Unk, Traversal.Unk]]] =
     FilterQuery.default(caseProperties).paramParser(ru.typeOf[Traversal.V[Case]]).optional.on("caseFilter")
   override val extraQueries: Seq[ParamQuery[_]] = Seq(
+    Query.init[Long](
+      "countAlert",
+      (graph, authContext) =>
+        graph.indexCountQuery(s"""v."_label":Alert AND v.organisationId:${organisationSrv.currentId(graph, authContext).value}""")
+    ),
+    Query.init[Long](
+      "countUnreadAlert",
+      (graph, authContext) =>
+        graph.indexCountQuery(s"""v."_label":Alert AND v.organisationId:${organisationSrv.currentId(graph, authContext).value} AND v.read:false""")
+    ),
     Query[Traversal.V[Alert], Traversal.V[Observable]]("observables", (alertSteps, _) => alertSteps.observables),
     Query[Traversal.V[Alert], Traversal.V[Case]]("case", (alertSteps, _) => alertSteps.`case`),
     Query.withParam[Option[InputQuery[Traversal.Unk, Traversal.Unk]], Traversal.V[Alert], Traversal[

thehive/app/org/thp/thehive/controllers/v1/CaseCtrl.scala

@@ -56,6 +56,11 @@ class CaseCtrl @Inject() (
   )
   override val outputQuery: Query = Query.outputWithContext[RichCase, Traversal.V[Case]]((caseSteps, authContext) => caseSteps.richCase(authContext))
   override val extraQueries: Seq[ParamQuery[_]] = Seq(
+    Query.init[Long](
+      "countCase",
+      (graph, authContext) =>
+        graph.indexCountQuery(s"""v."_label":Case AND v.organisationIds:${organisationSrv.currentId(graph, authContext).value} """)
+    ),
     Query[Traversal.V[Case], Traversal.V[Observable]](
       "observables",
       (caseSteps, authContext) =>

thehive/app/org/thp/thehive/controllers/v1/ObservableCtrl.scala

@@ -74,6 +74,13 @@ class ObservableCtrl @Inject() (
   override val outputQuery: Query = Query.output[RichObservable, Traversal.V[Observable]](_.richObservable)
 
   override val extraQueries: Seq[ParamQuery[_]] = Seq(
+    Query.initWithParam[InCase, Long](
+      "countObservable",
+      (inCase, graph, authContext) =>
+        graph.indexCountQuery(
+          s"""v."_label":Observable AND relatedId:${inCase.caseId.value} AND organisationIds:${organisationSrv.currentId(graph, authContext).value}"""
+        )
+    ),
     Query[Traversal.V[Observable], Traversal.V[Organisation]](
       "organisations",
       (observableSteps, authContext) => observableSteps.organisations.visible(authContext)

thehive/app/org/thp/thehive/controllers/v1/TagCtrl.scala

@@ -45,6 +45,11 @@ class TagCtrl @Inject() (
   )
   override val extraQueries: Seq[ParamQuery[_]] = Seq(
     Query.init[Traversal.V[Tag]]("freetags", (graph, authContext) => tagSrv.startTraversal(graph).freetags(organisationSrv)(authContext)),
+    Query.init[Long](
+      "countFreetags",
+      (graph, authContext) =>
+        graph.indexCountQuery(s"""v."_label":Tag AND v.namespace:_freetags_${organisationSrv.currentId(graph, authContext).value}""")
+    ),
     Query[Traversal.V[Tag], Traversal.V[Tag]]("freetags", (tagSteps, authContext) => tagSteps.freetags(organisationSrv)(authContext)),
     Query.initWithParam[TagHint, Traversal[String, Vertex, Converter[String, Vertex]]](
       "tagAutoComplete",

thehive/app/org/thp/thehive/controllers/v1/TaskCtrl.scala

@@ -53,13 +53,20 @@ class TaskCtrl @Inject() (
   override val outputQuery: Query =
     Query.outputWithContext[RichTask, Traversal.V[Task]]((taskSteps, _) => taskSteps.richTask)
   override val extraQueries: Seq[ParamQuery[_]] = Seq(
+    Query.initWithParam[InCase, Long](
+      "countTask",
+      (inCase, graph, authContext) =>
+        graph.indexCountQuery(
+          s"""v."_label":Task AND relatedId:${inCase.caseId.value} AND organisationIds:${organisationSrv.currentId(graph, authContext).value}"""
+        )
+    ),
     Query.init[Traversal.V[Task]](
       "waitingTasks",
-      (graph, authContext) => taskSrv.startTraversal(graph).has(_.status, TaskStatus.Waiting).inCase.visible(organisationSrv)(authContext)
+      (graph, authContext) => taskSrv.startTraversal(graph).has(_.status, TaskStatus.Waiting).visible(organisationSrv)(authContext).inCase
     ),
     Query.init[Traversal.V[Task]]( // DEPRECATED
       "waitingTask",
-      (graph, authContext) => taskSrv.startTraversal(graph).has(_.status, TaskStatus.Waiting).inCase.visible(organisationSrv)(authContext)
+      (graph, authContext) => taskSrv.startTraversal(graph).has(_.status, TaskStatus.Waiting).visible(organisationSrv)(authContext).inCase
     ),
     Query.init[Traversal.V[Task]](
       "myTasks",
@@ -68,6 +75,7 @@ class TaskCtrl @Inject() (
           .startTraversal(graph)
           .assignTo(authContext.userId)
           .visible(organisationSrv)(authContext)
+          .inCase
     ),
     Query[Traversal.V[Task], Traversal.V[User]]("assignableUsers", (taskSteps, authContext) => taskSteps.assignableUsers(authContext)),
     Query[Traversal.V[Task], Traversal.V[Log]]("logs", (taskSteps, _) => taskSteps.logs),

thehive/app/org/thp/thehive/controllers/v1/TheHiveQueryExecutor.scala

@@ -1,12 +1,15 @@
 package org.thp.thehive.controllers.v1
 
+import org.thp.scalligraph.EntityId
 import org.thp.scalligraph.controllers.{FObject, FieldsParser}
 import org.thp.scalligraph.models.Database
 import org.thp.scalligraph.query._
 import org.thp.scalligraph.services.config.{ApplicationConfig, ConfigItem}
 
 import javax.inject.{Inject, Singleton}
 
+case class InCase(caseId: EntityId)
+
 case class OutputParam(from: Long, to: Long, extraData: Set[String])
 
 object OutputParam {