Time Tracking for Shared Annotations + Editable Mappings

CHANGELOG.unreleased.md

@@ -13,6 +13,7 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 ### Added
 - Creating and deleting edges is now possible with ctrl+(alt/shift)+leftclick in orthogonal, flight and oblique mode. Also, the flight and oblique modes allow selecting nodes with leftclick, creating new trees with 'c' and deleting the active node with 'del'. [#7678](https://github.com/scalableminds/webknossos/pull/7678)
 - Added Typescript defintions for @scalableminds/prop-types package. [#7744](https://github.com/scalableminds/webknossos/pull/7744)
+- Time Tracking now also works when editing other users’ shared annotations, and when editing proofreading annotations (a.k.a. editable mappings). [#7749](https://github.com/scalableminds/webknossos/pull/7749)
 
 ### Changed
 - Improved task list to sort tasks by project date, add option to expand all tasks at once and improve styling. [#7709](https://github.com/scalableminds/webknossos/pull/7709)

app/controllers/AnnotationController.scala

@@ -106,7 +106,7 @@ class AnnotationController @Inject()(
         _ <- Fox.runOptional(request.identity) { user =>
           if (typedTyp == AnnotationType.Task || typedTyp == AnnotationType.Explorational) {
             timeSpanService
-              .logUserInteraction(Instant(timestamp), user, annotation) // log time when a user starts working
+              .logUserInteractionIfTheyArePotentialContributor(Instant(timestamp), user, annotation) // log time when a user starts working
           } else Fox.successful(())
         }
         _ = Fox.runOptional(request.identity)(user => userDAO.updateLastActivity(user._id))
@@ -403,7 +403,7 @@ class AnnotationController @Inject()(
       restrictions <- provider.restrictionsFor(typ, id) ?~> "restrictions.notFound" ~> NOT_FOUND
       message <- annotationService.finish(annotation, issuingUser, restrictions) ?~> "annotation.finish.failed"
       updated <- provider.provideAnnotation(typ, id, issuingUser)
-      _ <- timeSpanService.logUserInteraction(timestamp, issuingUser, annotation) // log time on tracing end
+      _ <- timeSpanService.logUserInteractionIfTheyArePotentialContributor(timestamp, issuingUser, annotation) // log time on tracing end
     } yield (updated, message)
 
   def finish(typ: String, id: String, timestamp: Long): Action[AnyContent] = sil.SecuredAction.async {

app/models/user/time/TimeSpan.scala

@@ -16,7 +16,7 @@ import scala.concurrent.duration.FiniteDuration
 case class TimeSpan(
     _id: ObjectId,
     _user: ObjectId,
-    _annotation: Option[ObjectId],
+    _annotation: Option[ObjectId], // Optional for compatibility with legacy data. All new timespans have an annotation.
     time: Long,
     lastUpdate: Instant,
     numberOfUpdates: Long = 0,
@@ -38,8 +38,8 @@ object TimeSpan {
   def groupByDay(timeSpan: TimeSpan): Day =
     Day(timeSpan.created.dayOfMonth, timeSpan.created.monthOfYear, timeSpan.created.year)
 
-  def fromInstant(timestamp: Instant, _user: ObjectId, _annotation: Option[ObjectId]): TimeSpan =
-    TimeSpan(ObjectId.generate, _user, _annotation, time = 0L, lastUpdate = timestamp, created = timestamp)
+  def fromInstant(timestamp: Instant, userId: ObjectId, annotationId: ObjectId): TimeSpan =
+    TimeSpan(ObjectId.generate, userId, Some(annotationId), time = 0L, lastUpdate = timestamp, created = timestamp)
 
 }
 

app/models/user/time/TimeSpanService.scala

@@ -37,9 +37,11 @@ class TimeSpanService @Inject()(annotationDAO: AnnotationDAO,
   private lazy val Mailer: ActorSelection =
     actorSystem.actorSelection("/user/mailActor")
 
-  def logUserInteraction(timestamp: Instant, user: User, annotation: Annotation)(
+  def logUserInteractionIfTheyArePotentialContributor(timestamp: Instant, user: User, annotation: Annotation)(
       implicit ctx: DBAccessContext): Fox[Unit] =
-    logUserInteraction(Seq(timestamp), user, annotation)
+    if (user._id == annotation._user || annotation.othersMayEdit) {
+      logUserInteraction(Seq(timestamp), user, annotation)
+    } else Fox.successful(())
 
   def logUserInteraction(timestamps: Seq[Instant], user: User, annotation: Annotation)(
       implicit ctx: DBAccessContext): Fox[Unit] =
@@ -56,21 +58,19 @@ class TimeSpanService @Inject()(annotationDAO: AnnotationDAO,
   private val lastUserActivities = mutable.HashMap.empty[ObjectId, TimeSpan]
 
   @SuppressWarnings(Array("TraversableHead", "TraversableLast")) // Only functions call this which put at least one timestamp in the seq
-  private def trackTime(timestamps: Seq[Instant], _user: ObjectId, _annotation: Annotation)(
+  private def trackTime(timestamps: Seq[Instant], userId: ObjectId, annotation: Annotation)(
       implicit ctx: DBAccessContext): Fox[Unit] =
     if (timestamps.isEmpty) {
       logger.warn("Timetracking called with empty timestamps list.")
       Fox.successful(())
     } else {
-      // Only if the annotation belongs to the user, we are going to log the time on the annotation
-      val annotation = if (_annotation._user == _user) Some(_annotation) else None
       val start = timestamps.head
 
       var timeSpansToInsert: List[TimeSpan] = List()
       var timeSpansToUpdate: List[(TimeSpan, Instant)] = List()
 
-      def createNewTimeSpan(timestamp: Instant, _user: ObjectId, annotation: Option[Annotation]) = {
-        val timeSpan = TimeSpan.fromInstant(timestamp, _user, annotation.map(_._id))
+      def createNewTimeSpan(timestamp: Instant, _user: ObjectId, annotation: Annotation) = {
+        val timeSpan = TimeSpan.fromInstant(timestamp, _user, annotation._id)
         timeSpansToInsert = timeSpan :: timeSpansToInsert
         timeSpan
       }
@@ -88,39 +88,39 @@ class TimeSpanService @Inject()(annotationDAO: AnnotationDAO,
       }
 
       var current = lastUserActivities
-        .get(_user)
+        .get(userId)
         .flatMap(lastActivity => {
           if (isNotInterrupted(start, lastActivity)) {
-            if (belongsToSameTracing(lastActivity, annotation)) {
+            if (belongsToSameAnnotation(lastActivity, annotation)) {
               Some(lastActivity)
             } else {
               updateTimeSpan(lastActivity, start)
               None
             }
           } else None
         })
-        .getOrElse(createNewTimeSpan(start, _user, annotation))
+        .getOrElse(createNewTimeSpan(start, userId, annotation))
 
       timestamps.sliding(2).foreach { pair =>
         val start = pair.head
         val end = pair.last
         val duration = end - start
         if (duration >= conf.WebKnossos.User.timeTrackingPause) {
           updateTimeSpan(current, start)
-          current = createNewTimeSpan(end, _user, annotation)
+          current = createNewTimeSpan(end, userId, annotation)
         }
       }
       current = updateTimeSpan(current, timestamps.last)
-      lastUserActivities.update(_user, current)
+      lastUserActivities.update(userId, current)
 
       flushToDb(timeSpansToInsert, timeSpansToUpdate)(ctx)
     }
 
   private def isNotInterrupted(current: Instant, last: TimeSpan) =
     current - last.lastUpdate < conf.WebKnossos.User.timeTrackingPause
 
-  private def belongsToSameTracing(last: TimeSpan, annotation: Option[Annotation]) =
-    last._annotation.map(_.id) == annotation.map(_.id)
+  private def belongsToSameAnnotation(last: TimeSpan, annotation: Annotation) =
+    last._annotation.contains(annotation._id)
 
   private def logTimeToAnnotation(duration: FiniteDuration, annotation: Option[ObjectId]): Fox[Unit] =
     // Log time to annotation

webknossos-tracingstore/app/com/scalableminds/webknossos/tracingstore/controllers/VolumeTracingController.scala

@@ -14,7 +14,7 @@ import com.scalableminds.webknossos.datastore.helpers.{
   SegmentStatisticsParameters
 }
 import com.scalableminds.webknossos.datastore.models.datasource.{AdditionalAxis, DataLayer}
-import com.scalableminds.webknossos.datastore.models.{WebknossosDataRequest, WebknossosAdHocMeshRequest}
+import com.scalableminds.webknossos.datastore.models.{WebknossosAdHocMeshRequest, WebknossosDataRequest}
 import com.scalableminds.webknossos.datastore.rpc.RPC
 import com.scalableminds.webknossos.datastore.services.{
   EditableMappingSegmentListResult,
@@ -43,7 +43,8 @@ import com.scalableminds.webknossos.tracingstore.{
   TSRemoteDatastoreClient,
   TSRemoteWebknossosClient,
   TracingStoreAccessTokenService,
-  TracingStoreConfig
+  TracingStoreConfig,
+  TracingUpdatesReport
 }
 import net.liftweb.common.{Box, Empty, Failure, Full}
 import play.api.i18n.Messages
@@ -424,6 +425,15 @@ class VolumeTracingController @Inject()(
           _ <- bool2Fox(request.body.length == 1) ?~> "Editable mapping update request must contain exactly one update group"
           updateGroup <- request.body.headOption.toFox
           _ <- bool2Fox(updateGroup.version == currentVersion + 1) ?~> "version mismatch"
+          report = TracingUpdatesReport(
+            tracingId,
+            timestamps = List(Instant(updateGroup.timestamp)),
+            statistics = None,
+            significantChangesCount = updateGroup.actions.length,
+            viewChangesCount = 0,
+            urlOrHeaderToken(token, request)
+          )
+          _ <- remoteWebknossosClient.reportTracingUpdates(report)
           _ <- editableMappingService.update(mappingName, updateGroup, updateGroup.version)
         } yield Ok
       }