#2335 Fix initial values creation

migration/src/main/resources/reference.conf

@@ -43,6 +43,7 @@ output {
   caseNumberShift: 0
   resume: false
   removeData: false
+  integrityCheck.enabled: false
   db {
     provider: janusgraph
     janusgraph {

migration/src/main/scala/org/thp/thehive/migration/Migrate.scala

@@ -91,6 +91,9 @@ object Migrate extends App with MigrationOps {
       opt[Int]('t', "thread-count")
         .text("number of threads")
         .action((t, c) => addConfig(c, "threadCount", t)),
+      opt[Unit]('k', "integrity-checks")
+        .text("run integrity checks after the migration")
+        .action((_, c) => addConfig(c, "output.integrityCheck.enabled", true)),
       /* case age */
       opt[String]("max-case-age")
         .valueName("<duration>")

migration/src/main/scala/org/thp/thehive/migration/th4/DummyActor.scala

@@ -1,7 +1,20 @@
 package org.thp.thehive.migration.th4
 
-import akka.actor.Actor
+import akka.actor.typed.scaladsl.Behaviors
+import akka.actor.typed.scaladsl.adapter.ClassicActorSystemOps
+import akka.actor.{Actor, ActorSystem}
+import akka.actor.typed.{ActorRef => TypedActorRef}
+
+import java.util.UUID
+import javax.inject.{Inject, Provider}
 
 class DummyActor extends Actor {
   override def receive: Receive = PartialFunction.empty
 }
+
+class DummyTypedActorProvider[T] @Inject() (actorSystem: ActorSystem) extends Provider[TypedActorRef[T]] {
+  override def get(): TypedActorRef[T] =
+    actorSystem
+      .toTyped
+      .systemActorOf(Behaviors.empty, UUID.randomUUID().toString)
+}

migration/src/main/scala/org/thp/thehive/migration/th4/Output.scala

@@ -55,7 +55,7 @@ object Output {
               bindActor[DummyActor]("notification-actor")
               bindActor[DummyActor]("config-actor")
               bindActor[DummyActor]("cortex-actor")
-              bindActor[DummyActor]("integrity-check-actor")
+              bind[ActorRef[IntegrityCheck.Request]].toProvider[DummyTypedActorProvider[IntegrityCheck.Request]]
               bind[ActorRef[CaseNumberActor.Request]].toProvider[CaseNumberActorProvider]
               val integrityCheckOpsBindings = ScalaMultibinder.newSetBinder[IntegrityCheck](binder)
               integrityCheckOpsBindings.addBinding.to[AlertIntegrityCheck]
@@ -131,6 +131,7 @@ class Output @Inject() (
     resolutionStatusSrv: ResolutionStatusSrv,
     jobSrv: JobSrv,
     actionSrv: ActionSrv,
+    dashboardSrv: DashboardSrv,
     db: Database,
     cache: SyncCacheApi,
     checks: immutable.Set[IntegrityCheck]
@@ -204,23 +205,23 @@ class Output @Inject() (
     db.addSchemaIndexes(theHiveSchema)
       .flatMap(_ => db.addSchemaIndexes(cortexSchema))
       .foreach { _ =>
-        implicit val authContext: AuthContext = LocalUserSrv.getSystemAuthContext
-        checks.foreach { c =>
-          logger.info(s"Running check on ${c.name} ...")
-          val desupStats = c match {
-            case dc: DedupCheck[_] => dc.dedup(KillSwitch.alwaysOn)
-            case _                 => Map.empty[String, Long]
-          }
-          val globalStats = c match {
-            case gc: GlobalCheck[_] => gc.runGlobalCheck(24.hours, KillSwitch.alwaysOn)
-            case _                  => Map.empty[String, Long]
+        if (configuration.get[Boolean]("integrityCheck.enabled"))
+          checks.foreach { c =>
+            logger.info(s"Running check on ${c.name} ...")
+            val desupStats = c match {
+              case dc: DedupCheck[_] => dc.dedup(KillSwitch.alwaysOn)
+              case _                 => Map.empty[String, Long]
+            }
+            val globalStats = c match {
+              case gc: GlobalCheck[_] => gc.runGlobalCheck(24.hours, KillSwitch.alwaysOn)
+              case _                  => Map.empty[String, Long]
+            }
+            val statsStr = (desupStats <+> globalStats)
+              .collect { case (k, v) if v != 0 => s"$k:$v" }
+              .mkString(" ")
+            if (statsStr.isEmpty) logger.info(s"Check on ${c.name}: no change needed")
+            else logger.info(s"Check on ${c.name}: $statsStr")
           }
-          val statsStr = (desupStats <+> globalStats)
-            .collect { case (k, v) if v != 0 => s"$k:$v" }
-            .mkString(" ")
-          if (statsStr.isEmpty) logger.info(s"Check on ${c.name}: no change needed")
-          else logger.info(s"Check on ${c.name}: $statsStr")
-        }
       }
 
     Try(db.close())
@@ -874,4 +875,22 @@ class Output @Inject() (
         _ <- context.map(auditSrv.auditContextSrv.create(AuditContext(), createdAudit, _)).flip
       } yield ()
     }
+
+  def dashboardExists(graph: Graph, inputDashboard: InputDashboard): Boolean =
+    if (!resumeMigration) false
+    else
+      db.roTransaction { implicit graph =>
+        dashboardSrv.startTraversal.has(_.title, inputDashboard.dashboard.title).exists
+      }
+
+  override def createDashboard(graph: Graph, inputDashboard: InputDashboard): Try[IdMapping] =
+    withAuthContext(inputDashboard.metaData.createdBy) { implicit authContext =>
+      implicit val g: Graph = graph
+      logger.debug(s"Create dashboard ${inputDashboard.dashboard.title}")
+      for {
+        dashboard <- dashboardSrv.create(inputDashboard.dashboard).map(_.dashboard)
+        _         <- inputDashboard.organisation.map { case (org, writable) => dashboardSrv.share(dashboard, EntityName(org), writable) }.flip
+        _ = updateMetaData(dashboard, inputDashboard.metaData)
+      } yield IdMapping(inputDashboard.metaData.id, dashboard._id)
+    }
 }

thehive/app/org/thp/thehive/models/TheHiveSchemaDefinition.scala

@@ -11,7 +11,6 @@ import org.thp.scalligraph.EntityId
 import org.thp.scalligraph.auth.AuthContext
 import org.thp.scalligraph.janus.JanusDatabase
 import org.thp.scalligraph.models._
-import org.thp.scalligraph.traversal.Graph
 import org.thp.scalligraph.traversal.TraversalOps._
 import org.thp.thehive.services.LocalUserSrv
 import play.api.Logger
@@ -525,16 +524,10 @@ class TheHiveSchemaDefinition @Inject() extends Schema with UpdatableSchema {
       .toSeq
   }
 
-  override lazy val initialValues: Seq[InitialValue[_]] = modelList.collect {
-    case vertexModel: VertexModel => vertexModel.getInitialValues
-  }.flatten
-
   private def tagString(namespace: String, predicate: String, value: String): String =
     (if (namespace.headOption.getOrElse('_') == '_') "" else namespace + ':') +
       (if (predicate.headOption.getOrElse('_') == '_') "" else predicate) +
       (if (value.isEmpty) "" else f"""="$value"""")
 
-  override def init(db: Database)(implicit graph: Graph, authContext: AuthContext): Try[Unit] = Success(())
-
   override val authContext: AuthContext = LocalUserSrv.getSystemAuthContext
 }

thehive/app/org/thp/thehive/services/IntegrityCheckActor.scala

@@ -7,6 +7,8 @@ import akka.actor.typed.scaladsl.{Behaviors, TimerScheduler}
 import akka.cluster.typed.{ClusterSingleton, SingletonActor}
 import org.quartz
 import org.quartz._
+import org.thp.scalligraph.auth.AuthContext
+import org.thp.scalligraph.models.Database
 import org.thp.scalligraph.services.config.{ApplicationConfig, ConfigItem}
 import org.thp.scalligraph.services.config.ApplicationConfig.finiteDurationFormat
 import org.thp.scalligraph.services.{DedupCheck, GlobalCheck, IntegrityCheck, KillSwitch}
@@ -17,7 +19,7 @@ import play.api.libs.json._
 import javax.inject.{Inject, Provider, Singleton}
 import scala.collection.immutable
 import scala.concurrent.duration.{DurationDouble, DurationLong, FiniteDuration}
-import scala.util.Try
+import scala.util.{Success, Try}
 
 case class CheckStats(global: Map[String, Long], last: Map[String, Long], lastDate: Long) {
   def +(stats: Map[String, Long]): CheckStats = {
@@ -112,6 +114,7 @@ object IntegrityCheck {
   private val actorRefContextKey = "IntegrityCheck-actor"
 
   def behavior(
+      db: Database,
       quartzScheduler: quartz.Scheduler,
       appConfig: ApplicationConfig,
       integrityChecks: Seq[IntegrityCheck]
@@ -128,6 +131,11 @@ object IntegrityCheck {
             }
         )
 
+        db.tryTransaction { implicit graph =>
+          implicit val authContext: AuthContext = LocalUserSrv.getSystemAuthContext
+          integrityChecks.foreach(_.initialCheck())
+          Success(())
+        }
         setupScheduling(context.self, quartzScheduler, integrityChecks, configItem)
         behavior(context.self, quartzScheduler, configItem, timers, integrityChecks.map(_.name))
       }
@@ -428,12 +436,13 @@ object IntegrityCheck {
 
 @Singleton
 class IntegrityCheckActorProvider @Inject() (
+    db: Database,
     system: ActorSystem,
     quartzScheduler: quartz.Scheduler,
     appConfig: ApplicationConfig,
     integrityChecks: immutable.Set[IntegrityCheck]
 ) extends Provider[ActorRef[IntegrityCheck.Request]] {
   override lazy val get: ActorRef[IntegrityCheck.Request] =
     ClusterSingleton(system.toTyped)
-      .init(SingletonActor(IntegrityCheck.behavior(quartzScheduler, appConfig, integrityChecks.toSeq), "IntegrityCheckActor"))
+      .init(SingletonActor(IntegrityCheck.behavior(db, quartzScheduler, appConfig, integrityChecks.toSeq), "IntegrityCheckActor"))
 }

thehive/app/org/thp/thehive/services/ProfileSrv.scala

@@ -14,7 +14,7 @@ import org.thp.thehive.services.ProfileOps._
 import play.api.libs.json.JsObject
 
 import javax.inject.{Inject, Provider, Singleton}
-import scala.util.{Failure, Success, Try}
+import scala.util.{Failure, Try}
 
 @Singleton
 class ProfileSrv @Inject() (