block users using amber

quartz/src/main/java/com/vitorpamplona/quartz/events/GeneralListEvent.kt

@@ -70,6 +70,10 @@ abstract class GeneralListEvent(
         return privateTags(privKey) ?: emptyList()
     }
 
+    fun privateTagsOrEmpty(content: String): List<List<String>> {
+        return privateTags(content) ?: emptyList()
+    }
+
     fun privateTaggedUsers(privKey: ByteArray) = privateTags(privKey)?.filter { it.size > 1 && it[0] == "p" }?.map { it[1] }
     fun privateTaggedUsers(content: String) = privateTags(content)?.filter { it.size > 1 && it[0] == "p" }?.map { it[1] }
     fun privateHashtags(privKey: ByteArray) = privateTags(privKey)?.filter { it.size > 1 && it[0] == "t" }?.map { it[1] }

quartz/src/main/java/com/vitorpamplona/quartz/events/PeopleListEvent.kt

@@ -18,6 +18,7 @@ class PeopleListEvent(
     content: String,
     sig: HexKey
 ) : GeneralListEvent(id, pubKey, createdAt, kind, tags, content, sig) {
+    var decryptedContent: String? = null
     var publicAndPrivateUserCache: ImmutableSet<HexKey>? = null
 
     fun publicAndPrivateUsers(privateKey: ByteArray?): ImmutableSet<HexKey> {
@@ -35,6 +36,20 @@ class PeopleListEvent(
         return publicAndPrivateUserCache ?: persistentSetOf()
     }
 
+    fun publicAndPrivateUsers(decryptedContent: String): ImmutableSet<HexKey> {
+        publicAndPrivateUserCache?.let {
+            return it
+        }
+
+        val privateUserList = privateTagsOrEmpty(decryptedContent).filter { it.size > 1 && it[0] == "p" }.map { it[1] }.toSet()
+
+        val publicUserList = tags.filter { it.size > 1 && it[0] == "p" }.map { it[1] }.toSet()
+
+        publicAndPrivateUserCache = (privateUserList + publicUserList).toImmutableSet()
+
+        return publicAndPrivateUserCache ?: persistentSetOf()
+    }
+
     fun isTaggedUser(idHex: String, isPrivate: Boolean, privateKey: ByteArray): Boolean {
         return if (isPrivate) {
             privateTagsOrEmpty(privKey = privateKey).any { it.size > 1 && it[0] == "p" && it[1] == idHex }
@@ -43,6 +58,14 @@ class PeopleListEvent(
         }
     }
 
+    fun isTaggedUser(idHex: String, isPrivate: Boolean, content: String): Boolean {
+        return if (isPrivate) {
+            privateTagsOrEmpty(content).any { it.size > 1 && it[0] == "p" && it[1] == idHex }
+        } else {
+            isTaggedUser(idHex)
+        }
+    }
+
     companion object {
         const val kind = 30000
         const val blockList = "mute"
@@ -65,6 +88,24 @@ class PeopleListEvent(
             }
         }
 
+        fun createListWithUser(name: String, pubKeyHex: String, isPrivate: Boolean, pubKey: HexKey, encryptedContent: String, createdAt: Long = TimeUtils.now()): PeopleListEvent {
+            return if (isPrivate) {
+                create(
+                    content = encryptedContent,
+                    tags = listOf(listOf("d", name)),
+                    pubKey = pubKey,
+                    createdAt = createdAt
+                )
+            } else {
+                create(
+                    content = "",
+                    tags = listOf(listOf("d", name), listOf("p", pubKeyHex)),
+                    pubKey = pubKey,
+                    createdAt = createdAt
+                )
+            }
+        }
+
         fun addUsers(earlierVersion: PeopleListEvent, listPubKeyHex: List<String>, isPrivate: Boolean, privateKey: ByteArray, createdAt: Long = TimeUtils.now()): PeopleListEvent {
             return if (isPrivate) {
                 create(
@@ -94,6 +135,24 @@ class PeopleListEvent(
             }
         }
 
+        fun addUser(earlierVersion: PeopleListEvent, pubKeyHex: String, isPrivate: Boolean, pubKey: HexKey, encryptedContent: String, createdAt: Long = TimeUtils.now()): PeopleListEvent {
+            return if (isPrivate) {
+                create(
+                    content = encryptedContent,
+                    tags = earlierVersion.tags,
+                    pubKey = pubKey,
+                    createdAt = createdAt
+                )
+            } else {
+                create(
+                    content = earlierVersion.content,
+                    tags = earlierVersion.tags.plus(element = listOf("p", pubKeyHex)),
+                    pubKey = pubKey,
+                    createdAt = createdAt
+                )
+            }
+        }
+
         fun addUser(earlierVersion: PeopleListEvent, pubKeyHex: String, isPrivate: Boolean, privateKey: ByteArray, createdAt: Long = TimeUtils.now()): PeopleListEvent {
             if (earlierVersion.isTaggedUser(pubKeyHex, isPrivate, privateKey)) return earlierVersion
 
@@ -146,5 +205,10 @@ class PeopleListEvent(
             val sig = CryptoUtils.sign(id, privateKey)
             return PeopleListEvent(id.toHexKey(), pubKey, createdAt, tags, content, sig.toHexKey())
         }
+
+        fun create(content: String, tags: List<List<String>>, pubKey: HexKey, createdAt: Long = TimeUtils.now()): PeopleListEvent {
+            val id = generateId(pubKey, createdAt, kind, tags, content)
+            return PeopleListEvent(id.toHexKey(), pubKey, createdAt, tags, content, "")
+        }
     }
 }