Fix friend search and status

Sources/src/main/kotlin/allin/data/FriendDataSource.kt

@@ -1,6 +1,7 @@
 package allin.data
 
 import allin.dto.UserDTO
+import allin.model.FriendStatus
 
 interface FriendDataSource {
     fun addFriend(sender: String, receiver: String)
@@ -8,4 +9,11 @@ interface FriendDataSource {
     fun deleteFriend(senderId: String, receiverId: String): Boolean
     fun isFriend(firstUser: String, secondUser: String): Boolean
     fun filterUsersByUsername(fromUserId: String, search: String): List<UserDTO>
+
+    fun getFriendStatus(firstUser: String, secondUser: String) =
+        if (isFriend(firstUser, secondUser)) {
+            if (isFriend(secondUser, firstUser)) {
+                FriendStatus.FRIEND
+            } else FriendStatus.REQUESTED
+        } else FriendStatus.NOT_FRIEND
 }

Sources/src/main/kotlin/allin/data/mock/MockFriendDataSource.kt

@@ -18,9 +18,12 @@ class MockFriendDataSource(private val mockData: MockDataSource.MockData) : Frie
         friends.map { Friend(sender = it.sender, receiver = it.receiver) }
             .filter { it.sender == id }
             .mapNotNull {
-                users
-                    .find { usr -> it.receiver == usr.id }
-                    ?.toDto(friendStatus = FriendStatus.FRIEND)
+                users.find { usr -> it.receiver == usr.id }
+                    ?.toDto(
+                        friendStatus = if (isFriend(it.receiver, id)) {
+                            FriendStatus.FRIEND
+                        } else FriendStatus.REQUESTED
+                    )
             }
 
     override fun deleteFriend(senderId: String, receiverId: String) =
@@ -28,27 +31,12 @@ class MockFriendDataSource(private val mockData: MockDataSource.MockData) : Frie
 
 
     override fun isFriend(firstUser: String, secondUser: String) =
-        friends
-            .filter { (it.sender == firstUser) and (it.receiver == secondUser) }
-            .map { Friend(sender = it.sender, receiver = it.receiver) }
-            .isNotEmpty()
+        friends.any { (it.sender == firstUser) and (it.receiver == secondUser) }
 
 
     override fun filterUsersByUsername(fromUserId: String, search: String): List<UserDTO> =
         users.filter { (it.username.contains(search, ignoreCase = true)) }
             .map { user ->
-                user.toDto(
-                    friendStatus = friends.filter { friend ->
-                        friend.sender == fromUserId && friend.receiver == user.id
-                    }.let {
-                        if (it.isEmpty()) FriendStatus.NOT_FRIEND
-                        else friends.filter { friend ->
-                            friend.sender == user.id && friend.receiver == fromUserId
-                        }.let {
-                            if (it.isEmpty()) FriendStatus.REQUESTED
-                            else FriendStatus.FRIEND
-                        }
-                    }
-                )
+                user.toDto(friendStatus = getFriendStatus(fromUserId, user.id))
             }
 }

Sources/src/main/kotlin/allin/data/postgres/PostgresDataSource.kt

@@ -3,6 +3,7 @@ package allin.data.postgres
 import allin.data.*
 import allin.ext.execute
 import org.ktorm.database.Database
+import org.ktorm.support.postgresql.PostgreSqlDialect
 
 class PostgresDataSource : AllInDataSource() {
 
@@ -20,7 +21,8 @@ class PostgresDataSource : AllInDataSource() {
         database = Database.connect(
             url = url,
             user = dbUser,
-            password = dbPassword
+            password = dbPassword,
+            dialect = PostgreSqlDialect()
         )
 
         database.execute(

Sources/src/main/kotlin/allin/data/postgres/PostgresFriendDataSource.kt

@@ -3,14 +3,15 @@ package allin.data.postgres
 import allin.data.FriendDataSource
 import allin.data.postgres.entities.FriendEntity
 import allin.data.postgres.entities.friends
-import allin.data.postgres.entities.getFriendStatus
 import allin.data.postgres.entities.users
 import allin.dto.UserDTO
+import allin.ext.toLowerCase
 import allin.model.FriendStatus
 import org.ktorm.database.Database
 import org.ktorm.dsl.and
 import org.ktorm.dsl.eq
 import org.ktorm.dsl.like
+import org.ktorm.dsl.notEq
 import org.ktorm.entity.*
 
 class PostgresFriendDataSource(private val database: Database) : FriendDataSource {
@@ -29,7 +30,11 @@ class PostgresFriendDataSource(private val database: Database) : FriendDataSourc
             .mapNotNull {
                 database.users.find { usr ->
                     usr.id eq it.receiver
-                }?.toUserDTO(friendStatus = FriendStatus.FRIEND)
+                }?.toUserDTO(
+                    friendStatus = if (isFriend(it.receiver, id)) {
+                        FriendStatus.FRIEND
+                    } else FriendStatus.REQUESTED
+                )
             }
 
 
@@ -39,18 +44,10 @@ class PostgresFriendDataSource(private val database: Database) : FriendDataSourc
     }
 
     override fun isFriend(firstUser: String, secondUser: String) =
-        database.friends
-            .filter { (it.sender eq firstUser) and (it.receiver eq secondUser) }
-            .map { it.toFriend() }
-            .isNotEmpty()
+        database.friends.any { (it.sender eq firstUser) and (it.receiver eq secondUser) }
 
     override fun filterUsersByUsername(fromUserId: String, search: String): List<UserDTO> =
-        database.users.filter {
-            it.username like "%$search%"
-        }
-            .map { user ->
-                user.toUserDTO(
-                    friendStatus = database.getFriendStatus(fromUserId, user.id)
-                )
-            }
+        database.users
+            .filter { (it.username.toLowerCase() like "%$search%") and (it.id notEq fromUserId) }
+            .map { user -> user.toUserDTO(friendStatus = getFriendStatus(fromUserId, user.id)) }
 }

Sources/src/main/kotlin/allin/data/postgres/entities/FriendEntity.kt

@@ -1,13 +1,8 @@
 package allin.data.postgres.entities
 
 import allin.model.Friend
-import allin.model.FriendStatus
 import org.ktorm.database.Database
-import org.ktorm.dsl.and
-import org.ktorm.dsl.eq
 import org.ktorm.entity.Entity
-import org.ktorm.entity.filter
-import org.ktorm.entity.isEmpty
 import org.ktorm.entity.sequenceOf
 import org.ktorm.schema.Table
 import org.ktorm.schema.varchar
@@ -31,18 +26,3 @@ object FriendsEntity : Table<FriendEntity>("friend") {
 }
 
 val Database.friends get() = this.sequenceOf(FriendsEntity)
-fun Database.getFriendStatus(ofUserId: String, withUserId: String) =
-    this.friends
-        .filter { (it.receiver eq withUserId) and (it.sender eq ofUserId) }
-        .let {
-            if (it.isEmpty()) {
-                FriendStatus.NOT_FRIEND
-            } else {
-                this.friends
-                    .filter { (it.receiver eq ofUserId) and (it.sender eq withUserId) }
-                    .let {
-                        if (it.isEmpty()) FriendStatus.REQUESTED
-                        else FriendStatus.FRIEND
-                    }
-            }
-        }

Sources/src/main/kotlin/allin/ext/DatabaseExt.kt

@@ -1,6 +1,9 @@
 package allin.ext
 
 import org.ktorm.database.Database
+import org.ktorm.expression.FunctionExpression
+import org.ktorm.schema.ColumnDeclaring
+import org.ktorm.schema.VarcharSqlType
 import java.sql.ResultSet
 
 fun Database.executeWithResult(request: String): ResultSet? {
@@ -27,3 +30,19 @@ fun Database.execute(request: String) {
             connection.commit()
         }
 }
+
+fun ColumnDeclaring<String>.toLowerCase(): FunctionExpression<String> {
+    return FunctionExpression(
+        functionName = "LOWER",
+        arguments = listOf(this.asExpression()),
+        sqlType = VarcharSqlType
+    )
+}
+
+fun ColumnDeclaring<String>.toUpperCase(): FunctionExpression<String> {
+    return FunctionExpression(
+        functionName = "UPPER",
+        arguments = listOf(this.asExpression()),
+        sqlType = VarcharSqlType
+    )
+}