Final release

build.sbt

@@ -16,6 +16,7 @@ val circeVersion = "0.14.14"
 
 lazy val root = (project in file("."))
   .settings(
+    scalacOptions ++= Seq("-Xmax-inlines", "64"),
     name := "CookCookHnya-backend",
     scalacOptions ++= Seq(
       "-Wunused:imports"

src/main/scala/api/EndpointErrorVariants.scala

@@ -9,6 +9,7 @@ import domain.{
   StorageAccessForbidden,
   StorageNotFound,
   UserNotFound,
+  PublicationRequestNotFound
 }
 
 import io.circe.{Decoder, Encoder}
@@ -28,6 +29,7 @@ extension (sc: StatusCode)
 object EndpointErrorVariants:
   val ingredientNotFoundVariant = NotFound.variantJson[IngredientNotFound]
   val storageNotFoundVariant = NotFound.variantJson[StorageNotFound]
+  val publicationRequestNotFound = NotFound.variantJson[PublicationRequestNotFound]
   val storageAccessForbiddenVariant = Forbidden.variantJson[StorageAccessForbidden]
   val recipeAccessForbiddenVariant = NotFound.variantJson[RecipeAccessForbidden]
   val userNotFoundVariant = NotFound.variantJson[UserNotFound]

src/main/scala/api/Endpoints.scala

@@ -6,7 +6,7 @@ import api.users.usersEndpoints
 import api.recipes.recipeEndpoints
 import api.shoppinglist.shoppingListEndpoints
 import api.invitations.invitationEndpoints
-
+import api.moderation.moderationEndpoints
 import sttp.tapir.ztapir.ZServerEndpoint
 import sttp.tapir.ztapir.RichZServerEndpoint
 
@@ -18,3 +18,5 @@ object AppEndpoints:
     ++ recipeEndpoints.map(_.widen)
     ++ shoppingListEndpoints.map(_.widen)
     ++ invitationEndpoints.map(_.widen)
+    ++ moderationEndpoints.map(_.widen)
+    :+ getPublicationRequestsHistory.widen

src/main/scala/api/GetPublicationRequestsHistory.scala

@@ -0,0 +1,68 @@
+package api
+
+import api.Authentication.{AuthenticatedUser, zSecuredServerLogic}
+import api.EndpointErrorVariants.serverErrorVariant
+import api.common.search.PaginationParams
+import api.moderation.ModerationHistoryResponse
+import db.repositories.{IngredientPublicationRequestsRepo, RecipePublicationRequestsRepo}
+import db.tables.{DbIngredient, DbRecipe}
+import db.tables.publication.{DbIngredientPublicationRequest, DbRecipePublicationRequest}
+import domain.InternalServerError
+import io.circe.Decoder
+import io.circe.derivation.Configuration
+import io.circe.generic.auto.*
+import sttp.tapir.generic.auto.*
+import sttp.tapir.json.circe.*
+import sttp.tapir.ztapir.*
+import zio.ZIO
+
+private type GetPublicationRequestsHistoryEnv
+  = RecipePublicationRequestsRepo
+  & IngredientPublicationRequestsRepo
+
+val getPublicationRequestsHistory: ZServerEndpoint[GetPublicationRequestsHistoryEnv, Any] =
+  endpoint
+    .get
+    .in("publication-requests" / PaginationParams.query)
+    .errorOut(oneOf(serverErrorVariant))
+    .out(jsonBody[List[ModerationHistoryResponse]])
+    .zSecuredServerLogic(getPublicationRequestsHistoryHandler)
+
+def getPublicationRequestsHistoryHandler(paginationParams: PaginationParams):
+  ZIO[
+    AuthenticatedUser & GetPublicationRequestsHistoryEnv,
+    InternalServerError,
+    List[ModerationHistoryResponse]
+  ] =
+  for
+    dbRecipeRequests     <- ZIO.serviceWithZIO[RecipePublicationRequestsRepo](_
+      .getAllCreatedBy
+      .orElseFail(InternalServerError())
+    )
+    recipeRequests = dbRecipeRequests.map {
+      case (dbRecipeReq: DbRecipePublicationRequest, recipe: DbRecipe) => ModerationHistoryResponse(
+        recipe.name,
+        "recipe",
+        dbRecipeReq.createdAt,
+        dbRecipeReq.updatedAt,
+        PublicationRequestStatusResp.fromDomain(dbRecipeReq.status.toDomain(dbRecipeReq.reason)),
+        dbRecipeReq.reason
+      )
+    }
+
+    dbIngredientRequests <- ZIO.serviceWithZIO[IngredientPublicationRequestsRepo](_
+      .getAllCreatedBy
+      .orElseFail(InternalServerError())
+    )
+    ingredientRequests = dbIngredientRequests.map {
+        case (dbRecipeReq: DbIngredientPublicationRequest, ingredient: DbIngredient) => ModerationHistoryResponse(
+          ingredient.name,
+          "ingredient",
+          dbRecipeReq.createdAt,
+          dbRecipeReq.updatedAt,
+          PublicationRequestStatusResp.fromDomain(dbRecipeReq.status.toDomain(dbRecipeReq.reason)),
+          dbRecipeReq.reason
+        )
+      }
+  yield (recipeRequests ++ ingredientRequests)
+    .sortBy(_.updatedAt)

src/main/scala/api/PublicationRequestStatusResp.scala

@@ -0,0 +1,35 @@
+package api
+
+import domain.PublicationRequestStatus
+import io.circe.{Decoder, DecodingFailure, Encoder, HCursor, Json}
+
+enum PublicationRequestStatusResp:
+  case Pending
+  case Accepted
+  case Rejected(reason: Option[String])
+
+object PublicationRequestStatusResp:
+  def fromDomain(domainModel: PublicationRequestStatus): PublicationRequestStatusResp =
+    domainModel match
+      case PublicationRequestStatus.Accepted         => Accepted
+      case PublicationRequestStatus.Pending          => Pending
+      case PublicationRequestStatus.Rejected(reason) => Rejected(reason)
+
+  given Encoder[PublicationRequestStatusResp] = Encoder.instance {
+    case Pending => Json.obj("type" -> Json.fromString("pending"))
+    case Accepted => Json.obj("type" -> Json.fromString("accepted"))
+    case Rejected(reason) =>
+      val baseObj = Json.obj("type" -> Json.fromString("rejected"))
+      reason match
+        case Some(r) => baseObj.deepMerge(Json.obj("reason" -> Json.fromString(r)))
+        case None => baseObj
+  }
+
+  given Decoder[PublicationRequestStatusResp] = (c: HCursor) =>
+    c.downField("type").as[String].flatMap {
+      case "pending" => Right(Pending)
+      case "accepted" => Right(Accepted)
+      case "rejected" =>
+        c.downField("reason").as[Option[String]].map(Rejected.apply)
+      case other => Left(DecodingFailure(s"Unknown status type: $other", c.history))
+    }

src/main/scala/api/common/search/PaginationParams.scala

@@ -1,6 +1,6 @@
 package api.common.search
 
-import scala.collection.immutable.IndexedSeqOps
+import scala.collection.IterableOps
 import sttp.tapir
 
 case class PaginationParams(
@@ -15,7 +15,7 @@ object PaginationParams:
         (PaginationParams.apply.tupled)
         {case PaginationParams(size, offset) => (size, offset)}
 
-extension[A, CC[_], C](seq: IndexedSeqOps[A, CC, C])
+extension[A, CC[_], C](seq: IterableOps[A, CC, C])
   def paginate(paginationParams: PaginationParams): C =
     seq.slice(paginationParams.offset, paginationParams.offset + paginationParams.size)
 

src/main/scala/api/ingredients/Create.scala

@@ -17,6 +17,7 @@ import sttp.tapir.ztapir.*
 import zio.ZIO
 
 private type CreateEnv = IngredientsRepo & DataSource
+
 private val create: ZServerEndpoint[CreateEnv, Any] =
   ingredientsEndpoint
     .post
@@ -42,4 +43,4 @@ private def createHandler(reqBody: CreateIngredientReqBody):
       .map(_.id)
       .orElseFail(InternalServerError())
     )
-  yield ingredientId
+  yield ingredientId

src/main/scala/api/ingredients/Endpoints.scala

@@ -3,6 +3,7 @@ package api.ingredients
 import sttp.tapir.Endpoint
 import sttp.tapir.ztapir.*
 
+import api.ingredients.admin.adminIngredientsEndpoints
 import api.ingredients.public.publicEndpoints
 import api.TapirExtensions.subTag
 
@@ -21,5 +22,7 @@ val ingredientsEndpoints = List(
   search.widen,
   searchForRecipe.widen,
   searchForStorage.widen,
+  searchForShoppingList.widen,
   requestPublication.widen
 ) ++ publicEndpoints.map(_.widen)
+  ++ adminIngredientsEndpoints.map(_.widen)

src/main/scala/api/ingredients/IngredientResp.scala

@@ -1,10 +1,15 @@
 package api.ingredients
 
 import api.common.search.Searchable
+import api.PublicationRequestStatusResp
 import domain.IngredientId
 import db.tables.DbIngredient
 
-final case class IngredientResp(id: IngredientId, name: String) extends Searchable
+final case class IngredientResp(
+  id: IngredientId,
+  name: String,
+  moderationStatus: Option[PublicationRequestStatusResp] = None
+) extends Searchable
 
 object IngredientResp:
   def fromDb(dbIngredient: DbIngredient): IngredientResp =

src/main/scala/api/ingredients/RequestPublication.scala

@@ -4,52 +4,54 @@ import api.Authentication.{AuthenticatedUser, zSecuredServerLogic}
 import api.variantJson
 import api.EndpointErrorVariants.{ingredientNotFoundVariant, serverErrorVariant}
 import db.repositories.{
-  IngredientPublicationRequestsRepo, IngredientsQueries,
+  IngredientPublicationRequestsRepo,
   IngredientsRepo, IngredientPublicationRequestsQueries
 }
-import domain.{IngredientId, IngredientNotFound, InternalServerError, RecipeId}
-import db.tables.publication.DbPublicationRequestStatus.given
+import domain.{IngredientId, IngredientNotFound, InternalServerError, PublicationRequestId}
 import db.QuillConfig.provideDS
 import db.QuillConfig.ctx.*
 
+import io.circe.generic.auto.*
 import io.getquill.*
 import javax.sql.DataSource
-import io.circe.generic.auto.*
-import sttp.model.StatusCode.BadRequest
+import sttp.model.StatusCode.{BadRequest, Created}
 import sttp.tapir.generic.auto.*
 import sttp.tapir.ztapir.*
 import zio.ZIO
 
-private final case class IngredientAlreadyPublished(
+final case class IngredientAlreadyPublished(
   ingredientId: IngredientId,
   message: String = "Ingredient already published",
 )
 object IngredientAlreadyPublished:
   val variant = BadRequest.variantJson[IngredientAlreadyPublished]
 
-private final case class IngredientAlreadyPending(
+final case class IngredientAlreadyPending(
   ingredientId: IngredientId,
   message: String = "Ingredient already pending"
 )
 object IngredientAlreadyPending:
   val variant = BadRequest.variantJson[IngredientAlreadyPending]
 
 private type RequestPublicationEnv = IngredientPublicationRequestsRepo & IngredientsRepo & DataSource
+
 private val requestPublication: ZServerEndpoint[RequestPublicationEnv, Any] =
   ingredientsEndpoint
     .post
     .in(path[IngredientId]("ingredientId") / "request-publication")
+    .out(statusCode(Created) and plainBody[PublicationRequestId])
     .errorOut(oneOf(
       serverErrorVariant, IngredientAlreadyPublished.variant,
       IngredientAlreadyPending.variant, ingredientNotFoundVariant
     ))
     .zSecuredServerLogic(requestPublicationHandler)
 
-def requestPublicationHandler(ingredientId: IngredientId):
+private def requestPublicationHandler(ingredientId: IngredientId):
   ZIO[
     AuthenticatedUser & RequestPublicationEnv,
-    InternalServerError | IngredientAlreadyPublished | IngredientAlreadyPending | IngredientNotFound,
-    Unit
+    InternalServerError | IngredientAlreadyPublished
+    | IngredientAlreadyPending | IngredientNotFound,
+    PublicationRequestId
   ] =
   for
     ingredient <- ZIO.serviceWithZIO[IngredientsRepo](_
@@ -58,19 +60,19 @@ def requestPublicationHandler(ingredientId: IngredientId):
     )
 
     _ <- ZIO.fail(IngredientAlreadyPublished(ingredientId))
-    .when(ingredient.isPublished)
+      .when(ingredient.isPublished)
 
     dataSource <- ZIO.service[DataSource]
     alreadyPending <- run(
       IngredientPublicationRequestsQueries
-        .pendingRequestsByIdQ(lift(ingredientId)).nonEmpty
+        .pendingRequestsByIngredientIdQ(lift(ingredientId)).nonEmpty
     ).provideDS(using dataSource)
       .orElseFail(InternalServerError())
     _ <- ZIO.fail(IngredientAlreadyPending(ingredientId))
       .when(alreadyPending)
 
-    _ <- ZIO.serviceWithZIO[IngredientPublicationRequestsRepo](_
+    reqId <- ZIO.serviceWithZIO[IngredientPublicationRequestsRepo](_
       .requestPublication(ingredientId)
       .orElseFail(InternalServerError())
     )
-  yield ()
+  yield reqId

src/main/scala/api/ingredients/Search.scala

@@ -1,13 +1,14 @@
 package api.ingredients
 
-import api.Authentication.{zSecuredServerLogic, AuthenticatedUser}
-import api.common.search.{PaginationParams, paginate, SearchParams, Searchable}
+import api.Authentication.{AuthenticatedUser, zSecuredServerLogic}
+import api.common.search.{PaginationParams, SearchParams, Searchable, paginate}
 import api.EndpointErrorVariants.serverErrorVariant
-import db.repositories.{IngredientsRepo, StorageIngredientsRepo}
+import api.ingredients.SearchIngredientsFilter.Custom
+import api.PublicationRequestStatusResp
+import db.repositories.{IngredientPublicationRequestsRepo, IngredientsRepo, StorageIngredientsRepo}
 import domain.{IngredientId, InternalServerError}
-
 import io.circe.generic.auto.*
-import sttp.tapir.{Codec, Schema, Validator, EndpointInput}
+import sttp.tapir.{Codec, EndpointInput, Schema, Validator}
 import sttp.tapir.generic.auto.*
 import sttp.tapir.json.circe.*
 import sttp.tapir.ztapir.*
@@ -25,7 +26,7 @@ object SearchIngredientsFilter:
   given Codec.PlainCodec[SearchIngredientsFilter] =
     Codec.derivedEnumeration.defaultStringBased
 
-private type SearchEnv = IngredientsRepo & StorageIngredientsRepo
+private type SearchEnv = IngredientsRepo & StorageIngredientsRepo & IngredientPublicationRequestsRepo
 
 private val search: ZServerEndpoint[SearchEnv, Any] =
   ingredientsEndpoint
@@ -41,7 +42,17 @@ private def searchHandler(
   searchParams: SearchParams,
   paginationParams: PaginationParams,
   filter: SearchIngredientsFilter,
-): ZIO[AuthenticatedUser & SearchEnv, InternalServerError, SearchResp[IngredientResp]] =
+): ZIO[AuthenticatedUser & SearchEnv, InternalServerError, SearchResp[IngredientResp]] = {
+
+  def getLastPublicationRequestStatus(ingredientId: IngredientId) =
+    ZIO.serviceWithZIO[IngredientPublicationRequestsRepo](
+      _.getAllRequestsForIngredient(ingredientId).map(
+        _.sortBy(_.updatedAt).lastOption.map(
+          req => PublicationRequestStatusResp.fromDomain(req.status.toDomain(req.reason))
+        )
+      )
+    )
+
   for
     getIngredients <- ZIO.serviceWith[IngredientsRepo](filter match
       case SearchIngredientsFilter.Custom => _.getAllCustom
@@ -52,4 +63,10 @@ private def searchHandler(
       .map(_.map(IngredientResp.fromDb))
       .orElseFail(InternalServerError())
     res = Searchable.search(Vector.from(allIngredients), searchParams)
-  yield SearchResp(res.paginate(paginationParams), res.length)
+    res <- ZIO.foreach(res) { resp =>
+      getLastPublicationRequestStatus(resp.id)
+        .map(status => resp.copy(moderationStatus = status))
+        .orElseFail(InternalServerError())
+    }.when(filter == Custom).someOrElse(res)
+  yield SearchResp(res.paginate(paginationParams), res.length)
+}