Reorder correspondent person suggestion based on org relationship

modules/common/src/main/scala/docspell/common/PersonRef.scala

@@ -0,0 +1,18 @@
+package docspell.common
+
+import io.circe._
+import io.circe.generic.semiauto._
+
+case class PersonRef(id: Ident, name: String, organization: Option[Ident]) {
+
+  def toIdRef: IdRef =
+    IdRef(id, name)
+}
+
+object PersonRef {
+
+  implicit val jsonEncoder: Encoder[PersonRef] =
+    deriveEncoder[PersonRef]
+  implicit val jsonDecoder: Decoder[PersonRef] =
+    deriveDecoder[PersonRef]
+}

modules/joex/src/main/scala/docspell/joex/process/EvalProposals.scala

@@ -6,8 +6,8 @@ import cats.effect.Sync
 import cats.implicits._
 
 import docspell.common._
-import docspell.joex.scheduler.Task
+import docspell.joex.scheduler.{Context, Task}
-import docspell.store.records.RAttachmentMeta
+import docspell.store.records.{RAttachmentMeta, RPerson}
 
 /** Calculate weights for candidates that adds the most likely
   * candidate a lower number.
@@ -15,21 +15,40 @@ import docspell.store.records.RAttachmentMeta
 object EvalProposals {
 
   def apply[F[_]: Sync](data: ItemData): Task[F, ProcessItemArgs, ItemData] =
-    Task { _ =>
+    Task { ctx =>
-      Timestamp
+      for {
-        .current[F]
+        now        <- Timestamp.current[F]
-        .map { now =>
+        personRefs <- findOrganizationRelation[F](data, ctx)
-          val metas = data.metas.map(calcCandidateWeight(now.toUtcDate))
+        metas = data.metas.map(calcCandidateWeight(now.toUtcDate, personRefs))
-          data.copy(metas = metas)
+      } yield data.copy(metas = metas)
-        }
     }
 
-  def calcCandidateWeight(now: LocalDate)(rm: RAttachmentMeta): RAttachmentMeta = {
+  def findOrganizationRelation[F[_]: Sync](
-    val list = rm.proposals.change(mp => mp.addWeights(weight(rm, mp, now)))
+      data: ItemData,
+      ctx: Context[F, _]
+  ): F[Map[Ident, PersonRef]] = {
+    val corrPersIds = data.metas
+      .flatMap(_.proposals.find(MetaProposalType.CorrPerson))
+      .flatMap(_.values.toList.map(_.ref.id))
+      .toSet
+    ctx.store
+      .transact(RPerson.findOrganization(corrPersIds))
+      .map(_.map(p => (p.id, p)).toMap)
+  }
+
+  def calcCandidateWeight(now: LocalDate, personRefs: Map[Ident, PersonRef])(
+      rm: RAttachmentMeta
+  ): RAttachmentMeta = {
+    val list = rm.proposals.change(mp => mp.addWeights(weight(rm, mp, now, personRefs)))
     rm.copy(proposals = list.sortByWeights)
   }
 
-  def weight(rm: RAttachmentMeta, mp: MetaProposal, ref: LocalDate)(
+  def weight(
+      rm: RAttachmentMeta,
+      mp: MetaProposal,
+      ref: LocalDate,
+      personRefs: Map[Ident, PersonRef]
+  )(
       cand: MetaProposal.Candidate
   ): Double =
     mp.proposalType match {
@@ -51,7 +70,27 @@ object EvalProposals {
         val words    = cand.origin.map(_.label.split(' ').length).max.toDouble
         val nerFac =
           cand.origin.map(label => nerTagFactor(label.tag, mp.proposalType)).min
-        (1 / words) * (1 / tagCount) * positionWeight(pos, textLen) * nerFac
+        val corrPerFac = corrOrgPersonFactor(rm, mp, personRefs, cand)
+        (1 / words) * (1 / tagCount) * positionWeight(pos, textLen) * nerFac * corrPerFac
+    }
+
+  def corrOrgPersonFactor(
+      rm: RAttachmentMeta,
+      mp: MetaProposal,
+      personRefs: Map[Ident, PersonRef],
+      cand: MetaProposal.Candidate
+  ): Double =
+    mp.proposalType match {
+      case MetaProposalType.CorrPerson =>
+        (for {
+          currentOrg <- rm.proposals
+            .find(MetaProposalType.CorrOrg)
+            .map(_.values.head.ref.id)
+          personOrg <- personRefs.get(cand.ref.id).flatMap(_.organization)
+          fac = if (currentOrg == personOrg) 0.5 else 1
+        } yield fac).getOrElse(1)
+      case _ =>
+        1
     }
 
   def positionWeight(pos: Int, total: Int): Double =

modules/store/src/main/scala/docspell/store/records/RPerson.scala

@@ -1,6 +1,8 @@
 package docspell.store.records
 
 import cats.Eq
+import cats.data.NonEmptyList
+import cats.effect._
 import fs2.Stream
 
 import docspell.common.{IdRef, _}
@@ -167,4 +169,14 @@ object RPerson {
 
   def delete(personId: Ident, coll: Ident): ConnectionIO[Int] =
     deleteFrom(table, and(pid.is(personId), cid.is(coll))).update.run
+
+  def findOrganization(ids: Set[Ident]): ConnectionIO[Vector[PersonRef]] = {
+    val cols = Seq(pid, name, oid)
+    NonEmptyList.fromList(ids.toList) match {
+      case Some(nel) =>
+        selectSimple(cols, table, pid.isIn(nel)).query[PersonRef].to[Vector]
+      case None =>
+        Sync[ConnectionIO].pure(Vector.empty)
+    }
+  }
 }