Chat Room search (POST)

Author: simonredfern

obp-api/src/main/scala/code/api/v6_0_0/APIMethods600.scala

@@ -16351,6 +16351,89 @@ trait APIMethods600 {
       }
     }
 
+    // 25b. searchChatRooms
+    staticResourceDocs += ResourceDoc(
+      searchChatRooms,
+      implementedInApiVersion,
+      nameOf(searchChatRooms),
+      "POST",
+      "/chat-rooms/search",
+      "Search Chat Rooms",
+      s"""Search chat rooms the current user is a participant of, filtered by the supplied criteria.
+         |
+         |Currently supports filtering by participant set:
+         |
+         |- `with_user_ids` (array of user_id strings, required): only return rooms where the current user
+         |  AND every listed user_id are participants. Pass an empty list to match all of the current user's rooms.
+         |- `exact_participants` (boolean, optional, default `false`): if `true`, the room's participant set
+         |  must equal exactly `{current user} ∪ with_user_ids` with no extras. Open rooms are excluded
+         |  from exact-participant searches because their participant set is implicitly "everyone".
+         |
+         |Primary use case: a client looking up an existing 1-on-1 direct-message room before creating one,
+         |by calling with `with_user_ids: [<other user_id>]` and `exact_participants: true`.
+         |
+         |The response shape is the same as `Get My Chat Rooms`.
+         |
+         |Authentication is Required
+         |
+         |""".stripMargin,
+      ChatRoomSearchRequestJsonV600(
+        with_user_ids = List("user-id-123"),
+        exact_participants = Some(true)
+      ),
+      ChatRoomsJsonV600(chat_rooms = List(ChatRoomJsonV600(
+        chat_room_id = "chat-room-id-123",
+        bank_id = "",
+        name = "DM with robert.x.0.gh",
+        description = "",
+        joining_key = "abc123key",
+        created_by = "user-id-456",
+        created_by_username = "alice",
+        created_by_provider = "https://github.com",
+        is_open_room = false,
+        is_archived = false,
+        last_message_at = Some(new java.util.Date()),
+        last_message_preview = Some("Hello!"),
+        last_message_sender = Some("alice"),
+        unread_count = Some(0),
+        created_at = new java.util.Date(),
+        updated_at = new java.util.Date()
+      ))),
+      List(
+        $AuthenticatedUserIsRequired,
+        InvalidJsonFormat,
+        UnknownError
+      ),
+      List(apiTagChat),
+      None
+    )
+
+    lazy val searchChatRooms: OBPEndpoint = {
+      case "chat-rooms" :: "search" :: Nil JsonPost json -> _ => {
+        cc => implicit val ec = EndpointContext(Some(cc))
+          for {
+            (Full(u), callContext) <- authenticatedAccess(cc)
+            postJson <- NewStyle.function.tryons(s"$InvalidJsonFormat The Json body should be the $ChatRoomSearchRequestJsonV600", 400, callContext) {
+              json.extract[ChatRoomSearchRequestJsonV600]
+            }
+            rooms <- Future {
+              code.chat.ChatRoomTrait.chatRoomProvider.vend.searchChatRoomsForUserWithParticipants(
+                u.userId,
+                postJson.with_user_ids,
+                postJson.exact_participants.getOrElse(false)
+              )
+            } map {
+              x => unboxFullOrFail(x, callContext, s"$UnknownError Cannot search chat rooms", 400)
+            }
+            unreadCounts <- Future {
+              computeUnreadCounts(rooms, u.userId)
+            }
+          } yield {
+            (JSONFactory600.createChatRoomsJson(rooms, unreadCounts), HttpCode.`200`(callContext))
+          }
+      }
+    }
+
     // 26. getMyUnreadCounts
     staticResourceDocs += ResourceDoc(
       getMyUnreadCounts,

obp-api/src/main/scala/code/api/v6_0_0/JSONFactory6.0.0.scala

@@ -1175,6 +1175,10 @@ case class InvestigationReportJsonV600(
 // Chat / Messaging API case classes
 case class PostChatRoomJsonV600(name: String, description: String)
 case class PutChatRoomJsonV600(name: Option[String], description: Option[String])
+case class ChatRoomSearchRequestJsonV600(
+  with_user_ids: List[String],
+  exact_participants: Option[Boolean] = Some(false)
+)
 case class PostParticipantJsonV600(user_id: Option[String], consumer_id: Option[String], permissions: Option[List[String]], webhook_url: Option[String])
 case class PutParticipantPermissionsJsonV600(permissions: List[String])
 case class PostChatMessageJsonV600(content: String, message_type: Option[String], mentioned_user_ids: Option[List[String]], reply_to_message_id: Option[String], thread_id: Option[String])

obp-api/src/main/scala/code/chat/ChatRoomTrait.scala

@@ -23,6 +23,19 @@ trait ChatRoomProvider {
   def getChatRoomsByBankIdForUser(bankId: String, userId: String): Box[List[ChatRoomTrait]]
   def getChatRoomByJoiningKey(joiningKey: String): Box[ChatRoomTrait]
 
+  /**
+   * Find chat rooms where the given user AND all of `requiredParticipantUserIds`
+   * are participants. If `exactParticipants` is true, the room's participant set
+   * must equal exactly `{userId} ∪ requiredParticipantUserIds` and open rooms
+   * are excluded (their participant set is "everyone" so an exact match is
+   * meaningless).
+   */
+  def searchChatRoomsForUserWithParticipants(
+    userId: String,
+    requiredParticipantUserIds: List[String],
+    exactParticipants: Boolean
+  ): Box[List[ChatRoomTrait]]
+
   def updateChatRoom(
     chatRoomId: String,
     name: Option[String],

obp-api/src/main/scala/code/chat/MappedChatRoom.scala

@@ -63,6 +63,46 @@ object MappedChatRoomProvider extends ChatRoomProvider {
     ChatRoom.find(By(ChatRoom.JoiningKey, joiningKey))
   }
 
+  override def searchChatRoomsForUserWithParticipants(
+    userId: String,
+    requiredParticipantUserIds: List[String],
+    exactParticipants: Boolean
+  ): Box[List[ChatRoomTrait]] = {
+    tryo {
+      // 1. Find every room where the current user is an explicit participant.
+      val myRoomIds = Participant.findAll(By(Participant.UserId, userId))
+        .map(_.chatRoomId)
+        .distinct
+      val myRooms = if (myRoomIds.isEmpty) Nil
+        else ChatRoom.findAll(ByList(ChatRoom.ChatRoomId, myRoomIds))
+
+      // 2. For each candidate room, fetch the full participant set and apply
+      //    the requested filters.
+      val requiredSet = requiredParticipantUserIds.toSet
+      val expectedExactSize = requiredSet.size + 1 // +1 for the current user
+
+      myRooms.filter { room =>
+        // Open rooms have implicit participants ("everyone"), so an exact-match
+        // query is meaningless against them — exclude them in that case.
+        if (exactParticipants && room.isOpenRoom) {
+          false
+        } else {
+          val participantUserIds = Participant.findAll(By(Participant.ChatRoomId, room.chatRoomId))
+            .map(_.userId)
+            .toSet
+          val containsAllRequired = requiredSet.subsetOf(participantUserIds)
+          if (!containsAllRequired) {
+            false
+          } else if (exactParticipants) {
+            participantUserIds.size == expectedExactSize
+          } else {
+            true
+          }
+        }
+      }
+    }
+  }
+
   override def updateChatRoom(
     chatRoomId: String,
     name: Option[String],