Add api docs and cleanup

modules/backend/src/main/scala/docspell/backend/BackendApp.scala

@@ -61,7 +61,7 @@ object BackendApp {
       uploadImpl     <- OUpload(store, queue, cfg.files, joexImpl)
       nodeImpl       <- ONode(store)
       jobImpl        <- OJob(store, joexImpl)
-      itemImpl       <- OItem(store, ftsClient)
+      itemImpl       <- OItem(store, ftsClient, queue, joexImpl)
       itemSearchImpl <- OItemSearch(store)
       fulltextImpl   <- OFulltext(itemSearchImpl, ftsClient, store, queue, joexImpl)
       javaEmil =

modules/backend/src/main/scala/docspell/backend/JobFactory.scala

@@ -25,15 +25,16 @@ object JobFactory {
         now,
         account.user,
         prio,
-        None
+        collective
+          .map(c => c / ConvertAllPdfArgs.taskName)
+          .orElse(ConvertAllPdfArgs.taskName.some)
       )
     } yield job
 
   def reprocessItem[F[_]: Sync](
       args: ReProcessItemArgs,
       account: AccountId,
-      prio: Priority,
-      tracker: Option[Ident]
+      prio: Priority
   ): F[RJob] =
     for {
       id  <- Ident.randomId[F]
@@ -47,7 +48,7 @@ object JobFactory {
         now,
         account.user,
         prio,
-        tracker
+        Some(ReProcessItemArgs.taskName / args.itemId)
       )
     } yield job
 

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

@@ -4,10 +4,12 @@ import cats.data.OptionT
 import cats.effect.{Effect, Resource}
 import cats.implicits._
 
+import docspell.backend.JobFactory
 import docspell.common._
 import docspell.ftsclient.FtsClient
 import docspell.store.UpdateResult
 import docspell.store.queries.{QAttachment, QItem}
+import docspell.store.queue.JobQueue
 import docspell.store.records._
 import docspell.store.{AddResult, Store}
 
@@ -76,11 +78,38 @@ trait OItem[F[_]] {
       name: Option[String],
       collective: Ident
   ): F[AddResult]
+
+  /** Submits the item for re-processing. The list of attachment ids can
+    * be used to only re-process a subset of the item's attachments.
+    * If this list is empty, all attachments are reprocessed. This
+    * call only submits the job into the queue.
+    */
+  def reprocess(
+      item: Ident,
+      attachments: List[Ident],
+      account: AccountId,
+      notifyJoex: Boolean
+  ): F[UpdateResult]
+
+  /** Submits a task that finds all non-converted pdfs and triggers
+    * converting them using ocrmypdf. Each file is converted by a
+    * separate task.
+    */
+  def convertAllPdf(
+      collective: Option[Ident],
+      account: AccountId,
+      notifyJoex: Boolean
+  ): F[UpdateResult]
 }
 
 object OItem {
 
-  def apply[F[_]: Effect](store: Store[F], fts: FtsClient[F]): Resource[F, OItem[F]] =
+  def apply[F[_]: Effect](
+      store: Store[F],
+      fts: FtsClient[F],
+      queue: JobQueue[F],
+      joex: OJoex[F]
+  ): Resource[F, OItem[F]] =
     for {
       otag   <- OTag(store)
       oorg   <- OOrganization(store)
@@ -400,6 +429,35 @@ object OItem {
               )
             )
 
+        def reprocess(
+            item: Ident,
+            attachments: List[Ident],
+            account: AccountId,
+            notifyJoex: Boolean
+        ): F[UpdateResult] =
+          (for {
+            _ <- OptionT(
+              store.transact(RItem.findByIdAndCollective(item, account.collective))
+            )
+            args = ReProcessItemArgs(item, attachments)
+            job <- OptionT.liftF(
+              JobFactory.reprocessItem[F](args, account, Priority.Low)
+            )
+            _ <- OptionT.liftF(queue.insertIfNew(job))
+            _ <- OptionT.liftF(if (notifyJoex) joex.notifyAllNodes else ().pure[F])
+          } yield UpdateResult.success).getOrElse(UpdateResult.notFound)
+
+        def convertAllPdf(
+            collective: Option[Ident],
+            account: AccountId,
+            notifyJoex: Boolean
+        ): F[UpdateResult] =
+          for {
+            job <- JobFactory.convertAllPdfs[F](collective, account, Priority.Low)
+            _   <- queue.insertIfNew(job)
+            _   <- if (notifyJoex) joex.notifyAllNodes else ().pure[F]
+          } yield UpdateResult.success
+
         private def onSuccessIgnoreError(update: F[Unit])(ar: AddResult): F[Unit] =
           ar match {
             case AddResult.Success =>

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

@@ -44,24 +44,6 @@ trait OUpload[F[_]] {
       case Left(srcId) =>
         submit(data, srcId, notifyJoex, itemId)
     }
-
-  /** Submits the item for re-processing. The list of attachment ids can
-    * be used to only re-process a subset of the item's attachments.
-    * If this list is empty, all attachments are reprocessed. This
-    * call only submits the job into the queue.
-    */
-  def reprocess(
-      item: Ident,
-      attachments: List[Ident],
-      account: AccountId,
-      notifyJoex: Boolean
-  ): F[OUpload.UploadResult]
-
-  def convertAllPdf(
-      collective: Option[Ident],
-      account: AccountId,
-      notifyJoex: Boolean
-  ): F[OUpload.UploadResult]
 }
 
 object OUpload {
@@ -177,31 +159,6 @@ object OUpload {
           result <- OptionT.liftF(submit(updata, accId, notifyJoex, itemId))
         } yield result).getOrElse(UploadResult.noSource)
 
-      def reprocess(
-          item: Ident,
-          attachments: List[Ident],
-          account: AccountId,
-          notifyJoex: Boolean
-      ): F[UploadResult] =
-        (for {
-          _ <-
-            OptionT(store.transact(RItem.findByIdAndCollective(item, account.collective)))
-          args = ReProcessItemArgs(item, attachments)
-          job <-
-            OptionT.liftF(JobFactory.reprocessItem[F](args, account, Priority.Low, None))
-          res <- OptionT.liftF(submitJobs(notifyJoex)(Vector(job)))
-        } yield res).getOrElse(UploadResult.noItem)
-
-      def convertAllPdf(
-          collective: Option[Ident],
-          account: AccountId,
-          notifyJoex: Boolean
-      ): F[OUpload.UploadResult] =
-        for {
-          job <- JobFactory.convertAllPdfs(collective, account, Priority.Low)
-          res <- submitJobs(notifyJoex)(Vector(job))
-        } yield res
-
       private def submitJobs(
           notifyJoex: Boolean
       )(jobs: Vector[RJob]): F[OUpload.UploadResult] =