Use a minimum age of items to remove

In order to keep deleted items for a while, the periodic task can now
use a duration to only remove items with a certain age. This can be
used to ensure that a deleted item stays at least X days before it
will be removed from the database.

Refs: #347

modules/backend/src/main/scala/docspell/backend/ops/OCollective.scala

@@ -61,7 +61,7 @@ trait OCollective[F[_]] {
 
   def startLearnClassifier(collective: Ident): F[Unit]
 
-  def startEmptyTrash(collective: Ident): F[Unit]
+  def startEmptyTrash(args: EmptyTrashArgs): F[Unit]
 
   /** Submits a task that (re)generates the preview images for all
     * attachments of the given collective.
@@ -88,6 +88,8 @@ object OCollective {
   val Settings = RCollective.Settings
   type Classifier = RClassifierSetting.Classifier
   val Classifier = RClassifierSetting.Classifier
+  type EmptyTrash = REmptyTrashSetting.EmptyTrash
+  val EmptyTrash = REmptyTrashSetting.EmptyTrash
 
   sealed trait PassResetResult
   object PassResetResult {
@@ -160,51 +162,47 @@ object OCollective {
           id <- Ident.randomId[F]
           on    = sett.classifier.map(_.enabled).getOrElse(false)
           timer = sett.classifier.map(_.schedule).getOrElse(CalEvent.unsafe(""))
+          args  = LearnClassifierArgs(coll)
           ut = UserTask(
             id,
             LearnClassifierArgs.taskName,
             on,
             timer,
             None,
-            LearnClassifierArgs(coll)
+            args
           )
-          _ <- uts.updateOneTask(UserTaskScope(coll), ut)
+          _ <- uts.updateOneTask(UserTaskScope(coll), args.makeSubject.some, ut)
           _ <- joex.notifyAllNodes
         } yield ()
 
       private def updateEmptyTrashTask(coll: Ident, sett: Settings): F[Unit] =
         for {
           id <- Ident.randomId[F]
-          timer = sett.emptyTrash.getOrElse(CalEvent.unsafe(""))
-          ut = UserTask(
-            id,
-            EmptyTrashArgs.taskName,
-            true,
-            timer,
-            None,
-            EmptyTrashArgs(coll)
-          )
-          _ <- uts.updateOneTask(UserTaskScope(coll), ut)
+          settings = sett.emptyTrash.getOrElse(EmptyTrash.default)
+          args     = EmptyTrashArgs(coll, settings.minAge)
+          ut       = UserTask(id, EmptyTrashArgs.taskName, true, settings.schedule, None, args)
+          _ <- uts.updateOneTask(UserTaskScope(coll), args.makeSubject.some, ut)
           _ <- joex.notifyAllNodes
         } yield ()
 
       def startLearnClassifier(collective: Ident): F[Unit] =
         for {
           id <- Ident.randomId[F]
+          args = LearnClassifierArgs(collective)
           ut <- UserTask(
             id,
             LearnClassifierArgs.taskName,
             true,
             CalEvent(WeekdayComponent.All, DateEvent.All, TimeEvent.All),
             None,
-            LearnClassifierArgs(collective)
-          ).encode.toPeriodicTask(UserTaskScope(collective))
+            args
+          ).encode.toPeriodicTask(UserTaskScope(collective), args.makeSubject.some)
           job <- ut.toJob
           _   <- queue.insert(job)
           _   <- joex.notifyAllNodes
         } yield ()
 
-      def startEmptyTrash(collective: Ident): F[Unit] =
+      def startEmptyTrash(args: EmptyTrashArgs): F[Unit] =
         for {
           id <- Ident.randomId[F]
           ut <- UserTask(
@@ -213,8 +211,8 @@ object OCollective {
             true,
             CalEvent(WeekdayComponent.All, DateEvent.All, TimeEvent.All),
             None,
-            EmptyTrashArgs(collective)
-          ).encode.toPeriodicTask(UserTaskScope(collective))
+            args
+          ).encode.toPeriodicTask(UserTaskScope(args.collective), args.makeSubject.some)
           job <- ut.toJob
           _   <- queue.insert(job)
           _   <- joex.notifyAllNodes

modules/backend/src/main/scala/docspell/backend/ops/OItemSearch.scala

@@ -23,7 +23,7 @@ import doobie.implicits._
 trait OItemSearch[F[_]] {
   def findItem(id: Ident, collective: Ident): F[Option[ItemData]]
 
-  def findDeleted(collective: Ident, limit: Int): F[Vector[RItem]]
+  def findDeleted(collective: Ident, maxUpdate: Timestamp, limit: Int): F[Vector[RItem]]
 
   def findItems(maxNoteLen: Int)(q: Query, batch: Batch): F[Vector[ListItem]]
 
@@ -147,9 +147,13 @@ object OItemSearch {
               .toVector
           }
 
-      def findDeleted(collective: Ident, limit: Int): F[Vector[RItem]] =
+      def findDeleted(
+          collective: Ident,
+          maxUpdate: Timestamp,
+          limit: Int
+      ): F[Vector[RItem]] =
         store
-          .transact(RItem.findDeleted(collective, limit))
+          .transact(RItem.findDeleted(collective, maxUpdate, limit))
           .take(limit.toLong)
           .compile
           .toVector

modules/backend/src/main/scala/docspell/backend/ops/OUserTask.scala

@@ -33,6 +33,7 @@ trait OUserTask[F[_]] {
     */
   def submitScanMailbox(
       scope: UserTaskScope,
+      subject: Option[String],
       task: UserTask[ScanMailboxArgs]
   ): F[Unit]
 
@@ -51,6 +52,7 @@ trait OUserTask[F[_]] {
     */
   def submitNotifyDueItems(
       scope: UserTaskScope,
+      subject: Option[String],
       task: UserTask[NotifyDueItemsArgs]
   ): F[Unit]
 
@@ -61,8 +63,8 @@ trait OUserTask[F[_]] {
     * executor's queue. It will not update the corresponding periodic
     * task.
     */
-  def executeNow[A](scope: UserTaskScope, task: UserTask[A])(implicit
-      E: Encoder[A]
+  def executeNow[A](scope: UserTaskScope, subject: Option[String], task: UserTask[A])(
+      implicit E: Encoder[A]
   ): F[Unit]
 }
 
@@ -75,11 +77,11 @@ object OUserTask {
   ): Resource[F, OUserTask[F]] =
     Resource.pure[F, OUserTask[F]](new OUserTask[F] {
 
-      def executeNow[A](scope: UserTaskScope, task: UserTask[A])(implicit
-          E: Encoder[A]
+      def executeNow[A](scope: UserTaskScope, subject: Option[String], task: UserTask[A])(
+          implicit E: Encoder[A]
       ): F[Unit] =
         for {
-          ptask <- task.encode.toPeriodicTask(scope)
+          ptask <- task.encode.toPeriodicTask(scope, subject)
           job   <- ptask.toJob
           _     <- queue.insert(job)
           _     <- joex.notifyAllNodes
@@ -103,10 +105,11 @@ object OUserTask {
 
       def submitScanMailbox(
           scope: UserTaskScope,
+          subject: Option[String],
           task: UserTask[ScanMailboxArgs]
       ): F[Unit] =
         for {
-          _ <- store.updateTask[ScanMailboxArgs](scope, task)
+          _ <- store.updateTask[ScanMailboxArgs](scope, subject, task)
           _ <- joex.notifyAllNodes
         } yield ()
 
@@ -124,10 +127,11 @@ object OUserTask {
 
       def submitNotifyDueItems(
           scope: UserTaskScope,
+          subject: Option[String],
           task: UserTask[NotifyDueItemsArgs]
       ): F[Unit] =
         for {
-          _ <- store.updateTask[NotifyDueItemsArgs](scope, task)
+          _ <- store.updateTask[NotifyDueItemsArgs](scope, subject, task)
           _ <- joex.notifyAllNodes
         } yield ()
     })