From 232baf5858f394a13d7dff8e810c0e61489286f9 Mon Sep 17 00:00:00 2001 From: eikek Date: Mon, 14 Mar 2022 16:54:39 +0100 Subject: [PATCH] Add routes to link items --- .../scala/docspell/backend/BackendApp.scala | 3 + .../docspell/backend/ops/OItemLink.scala | 89 +++++++++++++ .../scala/docspell/query/ItemQueryDsl.scala | 2 + .../src/main/resources/docspell-openapi.yml | 109 ++++++++++++++++ .../docspell/restserver/RestAppImpl.scala | 1 + .../restserver/conv/Conversions.scala | 6 +- .../restserver/routes/ItemLinkRoutes.scala | 82 ++++++++++++ .../migration/h2/V1.34.0__item_relation.sql | 11 ++ .../mariadb/V1.34.0__item_relation.sql | 11 ++ .../postgresql/V1.34.0__item_relation.sql | 11 ++ .../main/scala/docspell/store/qb/DML.scala | 7 + .../docspell/store/records/RItemLink.scala | 120 ++++++++++++++++++ 12 files changed, 449 insertions(+), 3 deletions(-) create mode 100644 modules/backend/src/main/scala/docspell/backend/ops/OItemLink.scala create mode 100644 modules/restserver/src/main/scala/docspell/restserver/routes/ItemLinkRoutes.scala create mode 100644 modules/store/src/main/resources/db/migration/h2/V1.34.0__item_relation.sql create mode 100644 modules/store/src/main/resources/db/migration/mariadb/V1.34.0__item_relation.sql create mode 100644 modules/store/src/main/resources/db/migration/postgresql/V1.34.0__item_relation.sql create mode 100644 modules/store/src/main/scala/docspell/store/records/RItemLink.scala diff --git a/modules/backend/src/main/scala/docspell/backend/BackendApp.scala b/modules/backend/src/main/scala/docspell/backend/BackendApp.scala index 5d5dc532..2413b37c 100644 --- a/modules/backend/src/main/scala/docspell/backend/BackendApp.scala +++ b/modules/backend/src/main/scala/docspell/backend/BackendApp.scala @@ -50,6 +50,7 @@ trait BackendApp[F[_]] { def notification: ONotification[F] def bookmarks: OQueryBookmarks[F] def fileRepository: OFileRepository[F] + def itemLink: OItemLink[F] } object BackendApp { @@ -106,6 +107,7 @@ object BackendApp { notifyImpl <- ONotification(store, notificationMod) bookmarksImpl <- OQueryBookmarks(store) fileRepoImpl <- OFileRepository(store, schedulerModule.jobs, joexImpl) + itemLinkImpl <- Resource.pure(OItemLink(store, itemSearchImpl)) } yield new BackendApp[F] { val pubSub = pubSubT val login = loginImpl @@ -134,5 +136,6 @@ object BackendApp { val notification = notifyImpl val bookmarks = bookmarksImpl val fileRepository = fileRepoImpl + val itemLink = itemLinkImpl } } diff --git a/modules/backend/src/main/scala/docspell/backend/ops/OItemLink.scala b/modules/backend/src/main/scala/docspell/backend/ops/OItemLink.scala new file mode 100644 index 00000000..16077b10 --- /dev/null +++ b/modules/backend/src/main/scala/docspell/backend/ops/OItemLink.scala @@ -0,0 +1,89 @@ +/* + * Copyright 2020 Eike K. & Contributors + * + * SPDX-License-Identifier: AGPL-3.0-or-later + */ + +package docspell.backend.ops + +import cats.data.NonEmptyList +import cats.effect._ +import cats.implicits._ + +import docspell.backend.ops.OItemLink.LinkResult +import docspell.common.{AccountId, Ident} +import docspell.query.ItemQuery +import docspell.query.ItemQueryDsl._ +import docspell.store.qb.Batch +import docspell.store.queries.Query +import docspell.store.records.RItemLink +import docspell.store.{AddResult, Store} + +trait OItemLink[F[_]] { + + def addAll(cid: Ident, target: Ident, related: NonEmptyList[Ident]): F[LinkResult] + + def removeAll(cid: Ident, target: Ident, related: NonEmptyList[Ident]): F[Unit] + + def getRelated( + account: AccountId, + item: Ident, + batch: Batch + ): F[Vector[OItemSearch.ListItemWithTags]] +} + +object OItemLink { + + sealed trait LinkResult + object LinkResult { + + /** When the target item is in the related list. */ + case object LinkTargetItemError extends LinkResult + case object Success extends LinkResult + + def linkTargetItemError: LinkResult = LinkTargetItemError + } + + def apply[F[_]: Sync](store: Store[F], search: OItemSearch[F]): OItemLink[F] = + new OItemLink[F] { + def getRelated( + accountId: AccountId, + item: Ident, + batch: Batch + ): F[Vector[OItemSearch.ListItemWithTags]] = + store + .transact(RItemLink.findLinked(accountId.collective, item)) + .map(ids => NonEmptyList.fromList(ids.toList)) + .flatMap { + case Some(nel) => + val expr = Q.itemIdsIn(nel.map(_.id)) + val query = Query( + Query + .Fix(accountId, Some(ItemQuery.Expr.ValidItemStates), None), + Query.QueryExpr(expr) + ) + search.findItemsWithTags(0)(query, batch) + + case None => + Vector.empty[OItemSearch.ListItemWithTags].pure[F] + } + + def addAll(cid: Ident, target: Ident, related: NonEmptyList[Ident]): F[LinkResult] = + if (related.contains_(target)) LinkResult.linkTargetItemError.pure[F] + else related.traverse(addSingle(cid, target, _)).as(LinkResult.Success) + + def removeAll(cid: Ident, target: Ident, related: NonEmptyList[Ident]): F[Unit] = + store.transact(RItemLink.deleteAll(cid, target, related)).void + + def addSingle(cid: Ident, target: Ident, related: Ident): F[Unit] = { + val exists = RItemLink.exists(cid, target, related) + val insert = RItemLink.insertNew(cid, target, related) + store.add(insert, exists).flatMap { + case AddResult.Success => ().pure[F] + case AddResult.EntityExists(_) => ().pure[F] + case AddResult.Failure(ex) => + Sync[F].raiseError(ex) + } + } + } +} diff --git a/modules/query/shared/src/main/scala/docspell/query/ItemQueryDsl.scala b/modules/query/shared/src/main/scala/docspell/query/ItemQueryDsl.scala index e1d92309..0fb9ea22 100644 --- a/modules/query/shared/src/main/scala/docspell/query/ItemQueryDsl.scala +++ b/modules/query/shared/src/main/scala/docspell/query/ItemQueryDsl.scala @@ -78,5 +78,7 @@ object ItemQueryDsl { def tagsEq(values: NonEmptyList[String]): Expr = Expr.TagsMatch(TagOperator.AllMatch, values) + def itemIdsIn(values: NonEmptyList[String]): Expr = + Expr.InExpr(Attr.ItemId, values) } } diff --git a/modules/restapi/src/main/resources/docspell-openapi.yml b/modules/restapi/src/main/resources/docspell-openapi.yml index ed349c57..98f71bb2 100644 --- a/modules/restapi/src/main/resources/docspell-openapi.yml +++ b/modules/restapi/src/main/resources/docspell-openapi.yml @@ -3675,6 +3675,99 @@ paths: schema: $ref: "#/components/schemas/BasicResult" + /sec/itemlink/{itemId}: + get: + operationId: "sec-itemlink-get" + tags: [ Item ] + summary: Get related items + description: | + Returns a list of related items for the given one. + security: + - authTokenHeader: [] + parameters: + - $ref: "#/components/parameters/itemId" + responses: + 422: + description: BadRequest + 200: + description: Ok + content: + application/json: + schema: + $ref: "#/components/schemas/ItemLightGroup" + + /sec/itemlink/{itemId}/{id}: + delete: + operationId: "sec-itemlink-delete" + tags: [Item] + summary: Delete an item from the list of related items + description: | + Deletes the item `id` from the list of related items on + `itemId`. + security: + - authTokenHeader: [] + parameters: + - $ref: "#/components/parameters/itemId" + - $ref: "#/components/parameters/id" + responses: + 422: + description: BadRequest + 200: + description: Ok + content: + application/json: + schema: + $ref: "#/components/schemas/BasicResult" + + /sec/itemlink/addAll: + post: + operationId: "sec-itemlink-appendall-post" + tags: [ Item ] + summary: Add more items as related + description: | + Add one or more items to anothers list of related items. + Duplicates are ignored. + security: + - authTokenHeader: [] + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/ItemLinkData" + responses: + 422: + description: BadRequest + 200: + description: Ok + content: + application/json: + schema: + $ref: "#/components/schemas/BasicResult" + + /sec/itemlink/removeAll: + post: + operationId: "sec-itemlink-removeall-post" + tags: [ Item ] + summary: Remove items from the list of related items + description: | + Remove all given items from the list of related items + security: + - authTokenHeader: [] + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/ItemLinkData" + responses: + 422: + description: BadRequest + 200: + description: Ok + content: + application/json: + schema: + $ref: "#/components/schemas/BasicResult" + /sec/items/merge: post: @@ -5486,6 +5579,22 @@ paths: components: schemas: + ItemLinkData: + description: | + Data for changing the list of related items. + required: + - item + - related + properties: + item: + type: string + format: ident + related: + type: array + items: + type: string + format: ident + FileIntegrityCheckRequest: description: | Data for running a file integrity check diff --git a/modules/restserver/src/main/scala/docspell/restserver/RestAppImpl.scala b/modules/restserver/src/main/scala/docspell/restserver/RestAppImpl.scala index 6b0f87b8..7e6c7025 100644 --- a/modules/restserver/src/main/scala/docspell/restserver/RestAppImpl.scala +++ b/modules/restserver/src/main/scala/docspell/restserver/RestAppImpl.scala @@ -128,6 +128,7 @@ final class RestAppImpl[F[_]: Async]( "queue" -> JobQueueRoutes(backend, token), "item" -> ItemRoutes(config, backend, token), "items" -> ItemMultiRoutes(config, backend, token), + "itemlink" -> ItemLinkRoutes(token.account, backend.itemLink), "attachment" -> AttachmentRoutes(backend, token), "attachments" -> AttachmentMultiRoutes(backend, token), "upload" -> UploadRoutes.secured(backend, config, token), diff --git a/modules/restserver/src/main/scala/docspell/restserver/conv/Conversions.scala b/modules/restserver/src/main/scala/docspell/restserver/conv/Conversions.scala index 5f2b6a71..13791be3 100644 --- a/modules/restserver/src/main/scala/docspell/restserver/conv/Conversions.scala +++ b/modules/restserver/src/main/scala/docspell/restserver/conv/Conversions.scala @@ -188,7 +188,7 @@ trait Conversions { ItemLightGroup(g._1, g._2.map(mkItemLight).toList) val gs = - groups.map(mkGroup _).toList.sortWith((g1, g2) => g1.name.compareTo(g2.name) >= 0) + groups.map(mkGroup).toList.sortWith((g1, g2) => g1.name.compareTo(g2.name) >= 0) ItemLightList(gs) } @@ -199,7 +199,7 @@ trait Conversions { ItemLightGroup(g._1, g._2.map(mkItemLightWithTags).toList) val gs = - groups.map(mkGroup _).toList.sortWith((g1, g2) => g1.name.compareTo(g2.name) >= 0) + groups.map(mkGroup).toList.sortWith((g1, g2) => g1.name.compareTo(g2.name) >= 0) ItemLightList(gs) } @@ -210,7 +210,7 @@ trait Conversions { ItemLightGroup(g._1, g._2.map(mkItemLightWithTags).toList) val gs = - groups.map(mkGroup _).toList.sortWith((g1, g2) => g1.name.compareTo(g2.name) >= 0) + groups.map(mkGroup).toList.sortWith((g1, g2) => g1.name.compareTo(g2.name) >= 0) ItemLightList(gs) } diff --git a/modules/restserver/src/main/scala/docspell/restserver/routes/ItemLinkRoutes.scala b/modules/restserver/src/main/scala/docspell/restserver/routes/ItemLinkRoutes.scala new file mode 100644 index 00000000..2469c99e --- /dev/null +++ b/modules/restserver/src/main/scala/docspell/restserver/routes/ItemLinkRoutes.scala @@ -0,0 +1,82 @@ +/* + * Copyright 2020 Eike K. & Contributors + * + * SPDX-License-Identifier: AGPL-3.0-or-later + */ + +package docspell.restserver.routes + +import cats.data.{NonEmptyList, OptionT} +import cats.effect._ +import cats.implicits._ + +import docspell.backend.ops.OItemLink +import docspell.backend.ops.OItemLink.LinkResult +import docspell.common._ +import docspell.joexapi.model.BasicResult +import docspell.restapi.model.{ItemLightGroup, ItemLinkData} +import docspell.restserver.conv.Conversions +import docspell.store.qb.Batch + +import org.http4s.HttpRoutes +import org.http4s.circe.CirceEntityCodec._ +import org.http4s.dsl.Http4sDsl + +class ItemLinkRoutes[F[_]: Async](account: AccountId, backend: OItemLink[F]) + extends Http4sDsl[F] { + def get: HttpRoutes[F] = + HttpRoutes.of { + case GET -> Root / Ident(id) => + for { + results <- backend.getRelated(account, id, Batch.all) + conv = results.map(Conversions.mkItemLightWithTags) + res = ItemLightGroup("related", conv.toList) + resp <- Ok(res) + } yield resp + + case DELETE -> Root / Ident(target) / Ident(id) => + for { + _ <- backend.removeAll(account.collective, target, NonEmptyList.of(id)) + resp <- Ok(BasicResult(true, "Related items removed")) + } yield resp + + case req @ POST -> Root / "addAll" => + for { + input <- req.as[ItemLinkData] + related = NonEmptyList.fromList(input.related) + res <- OptionT + .fromOption[F](related) + .semiflatMap(backend.addAll(account.collective, input.item, _)) + .value + resp <- Ok(convertResult(res)) + } yield resp + + case req @ POST -> Root / "removeAll" => + for { + input <- req.as[ItemLinkData] + related = NonEmptyList.fromList(input.related) + _ <- related + .map(backend.removeAll(account.collective, input.item, _)) + .getOrElse( + BadRequest(BasicResult(false, "List of related items must not be empty")) + ) + resp <- Ok(BasicResult(true, "Related items removed")) + } yield resp + } + + private def convertResult(r: Option[LinkResult]): BasicResult = + r match { + case Some(LinkResult.Success) => BasicResult(true, "Related items added") + case Some(LinkResult.LinkTargetItemError) => + BasicResult(false, "Items cannot be related to itself.") + case None => + BasicResult(false, "List of related items must not be empty") + } + +} + +object ItemLinkRoutes { + + def apply[F[_]: Async](account: AccountId, itemLink: OItemLink[F]): HttpRoutes[F] = + new ItemLinkRoutes[F](account, itemLink).get +} diff --git a/modules/store/src/main/resources/db/migration/h2/V1.34.0__item_relation.sql b/modules/store/src/main/resources/db/migration/h2/V1.34.0__item_relation.sql new file mode 100644 index 00000000..4fee15c4 --- /dev/null +++ b/modules/store/src/main/resources/db/migration/h2/V1.34.0__item_relation.sql @@ -0,0 +1,11 @@ +create table "item_link" ( + "id" varchar(254) not null primary key, + "cid" varchar(254) not null, + "item1" varchar(254) not null, + "item2" varchar(254) not null, + "created" timestamp not null, + unique ("cid", "item1", "item2"), + foreign key ("cid") references "collective"("cid") on delete cascade, + foreign key ("item1") references "item"("itemid") on delete cascade, + foreign key ("item2") references "item"("itemid") on delete cascade +); diff --git a/modules/store/src/main/resources/db/migration/mariadb/V1.34.0__item_relation.sql b/modules/store/src/main/resources/db/migration/mariadb/V1.34.0__item_relation.sql new file mode 100644 index 00000000..d1904a62 --- /dev/null +++ b/modules/store/src/main/resources/db/migration/mariadb/V1.34.0__item_relation.sql @@ -0,0 +1,11 @@ +create table `item_link` ( + `id` varchar(254) not null primary key, + `cid` varchar(254) not null, + `item1` varchar(254) not null, + `item2` varchar(254) not null, + `created` timestamp not null, + unique (`cid`, `item1`, `item2`), + foreign key (`cid`) references `collective`(`cid`) on delete cascade, + foreign key (`item1`) references `item`(`itemid`) on delete cascade, + foreign key (`item2`) references `item`(`itemid`) on delete cascade +); diff --git a/modules/store/src/main/resources/db/migration/postgresql/V1.34.0__item_relation.sql b/modules/store/src/main/resources/db/migration/postgresql/V1.34.0__item_relation.sql new file mode 100644 index 00000000..4fee15c4 --- /dev/null +++ b/modules/store/src/main/resources/db/migration/postgresql/V1.34.0__item_relation.sql @@ -0,0 +1,11 @@ +create table "item_link" ( + "id" varchar(254) not null primary key, + "cid" varchar(254) not null, + "item1" varchar(254) not null, + "item2" varchar(254) not null, + "created" timestamp not null, + unique ("cid", "item1", "item2"), + foreign key ("cid") references "collective"("cid") on delete cascade, + foreign key ("item1") references "item"("itemid") on delete cascade, + foreign key ("item2") references "item"("itemid") on delete cascade +); diff --git a/modules/store/src/main/scala/docspell/store/qb/DML.scala b/modules/store/src/main/scala/docspell/store/qb/DML.scala index 311b78f3..5d77b8ed 100644 --- a/modules/store/src/main/scala/docspell/store/qb/DML.scala +++ b/modules/store/src/main/scala/docspell/store/qb/DML.scala @@ -27,6 +27,13 @@ object DML extends DoobieMeta { def insert(table: TableDef, cols: Nel[Column[_]], values: Fragment): ConnectionIO[Int] = insertFragment(table, cols, List(values)).update.run + def insertSilent( + table: TableDef, + cols: Nel[Column[_]], + values: Fragment + ): ConnectionIO[Int] = + insertFragment(table, cols, List(values)).update(LogHandler.nop).run + def insertMany( table: TableDef, cols: Nel[Column[_]], diff --git a/modules/store/src/main/scala/docspell/store/records/RItemLink.scala b/modules/store/src/main/scala/docspell/store/records/RItemLink.scala new file mode 100644 index 00000000..8270a34a --- /dev/null +++ b/modules/store/src/main/scala/docspell/store/records/RItemLink.scala @@ -0,0 +1,120 @@ +/* + * Copyright 2020 Eike K. & Contributors + * + * SPDX-License-Identifier: AGPL-3.0-or-later + */ + +package docspell.store.records + +import cats.Order +import cats.data.NonEmptyList +import cats.effect.Sync +import cats.implicits._ + +import docspell.common._ +import docspell.store.qb.DSL._ +import docspell.store.qb._ + +import doobie._ +import doobie.implicits._ + +final case class RItemLink( + id: Ident, + cid: Ident, + item1: Ident, + item2: Ident, + created: Timestamp +) + +object RItemLink { + def create[F[_]: Sync](cid: Ident, item1: Ident, item2: Ident): F[RItemLink] = + for { + id <- Ident.randomId[F] + now <- Timestamp.current[F] + } yield RItemLink(id, cid, item1, item2, now) + + final case class Table(alias: Option[String]) extends TableDef { + val tableName = "item_link" + + val id: Column[Ident] = Column("id", this) + val cid: Column[Ident] = Column("cid", this) + val item1: Column[Ident] = Column("item1", this) + val item2: Column[Ident] = Column("item2", this) + val created: Column[Timestamp] = Column("created", this) + + val all: NonEmptyList[Column[_]] = + NonEmptyList.of(id, cid, item1, item2, created) + } + + def as(alias: String): Table = + Table(Some(alias)) + + val T: Table = Table(None) + + private def orderIds(item1: Ident, item2: Ident): (Ident, Ident) = { + val i1 = Order[Ident].min(item1, item2) + val i2 = Order[Ident].max(item1, item2) + (i1, i2) + } + + def insert(r: RItemLink): ConnectionIO[Int] = { + val (i1, i2) = orderIds(r.item1, r.item2) + DML.insertSilent(T, T.all, sql"${r.id},${r.cid},$i1,$i2,${r.created}") + } + + def insertNew(cid: Ident, item1: Ident, item2: Ident): ConnectionIO[Int] = + create[ConnectionIO](cid, item1, item2).flatMap(insert) + + def update(r: RItemLink): ConnectionIO[Int] = { + val (i1, i2) = orderIds(r.item1, r.item2) + DML.update( + T, + T.id === r.id && T.cid === r.cid, + DML.set( + T.item1.setTo(i1), + T.item2.setTo(i2) + ) + ) + } + + def exists(cid: Ident, item1: Ident, item2: Ident): ConnectionIO[Boolean] = { + val (i1, i2) = orderIds(item1, item2) + Select( + select(count(T.id)), + from(T), + T.cid === cid && T.item1 === i1 && T.item2 === i2 + ).build.query[Int].unique.map(_ > 0) + } + + def findLinked(cid: Ident, item: Ident): ConnectionIO[Vector[Ident]] = + union( + Select( + select(T.item1), + from(T), + T.cid === cid && T.item2 === item + ), + Select( + select(T.item2), + from(T), + T.cid === cid && T.item1 === item + ) + ).build.query[Ident].to[Vector] + + def deleteAll( + cid: Ident, + item: Ident, + related: NonEmptyList[Ident] + ): ConnectionIO[Int] = + DML.delete( + T, + T.cid === cid && ( + (T.item1 === item && T.item2.in(related)) || + (T.item2 === item && T.item1.in(related)) + ) + ) + + def delete(cid: Ident, item1: Ident, item2: Ident): ConnectionIO[Int] = { + val (i1, i2) = orderIds(item1, item2) + DML.delete(T, T.cid === cid && T.item1 === i1 && T.item2 === i2) + } +}