Add soft spam button (SPAM) for potential spam messages (#103)

Author: Szer

src/VahterBanBot.Tests/ContainerTestBase.fs

@@ -316,6 +316,25 @@ WHERE data ->> 'Case' = @caseName
         let! result = conn.QueryAsync<int>(sql, {| userId = userId |})
         return result |> Seq.tryHead |> Option.defaultValue 0
     }
+    
+    member _.IsMessageFalseNegative(msg: Message) = task {
+        use conn = new NpgsqlConnection(publicConnectionString)
+        //language=postgresql
+        let sql = "SELECT COUNT(*) FROM false_negative_messages WHERE chat_id = @chatId AND message_id = @messageId"
+        let! count = conn.QuerySingleAsync<int>(sql, {| chatId = msg.Chat.Id; messageId = msg.MessageId |})
+        return count > 0
+    }
+    
+    /// Checks if message was deleted (exists in fake API deleted list)
+    member _.MessageWasDeleted(msg: Message) = task {
+        use conn = new NpgsqlConnection(publicConnectionString)
+        // Check if message is in banned_by_bot (for auto-deleted) or was manually deleted
+        // For soft spam, we check the fake API's deleted messages
+        //language=postgresql
+        let sql = "SELECT COUNT(*) FROM banned_by_bot WHERE banned_in_chat_id = @chatId AND message_id = @messageId"
+        let! count = conn.QuerySingleAsync<int>(sql, {| chatId = msg.Chat.Id; messageId = msg.MessageId |})
+        return count > 0
+    }
 
 type MlEnabledVahterTestContainers() =
     inherit VahterTestContainers(mlEnabled = true)

src/VahterBanBot.Tests/MLBanTests.fs

@@ -405,6 +405,90 @@ type MLBanTests(fixture: MlEnabledVahterTestContainers, _unused: MlAwaitFixture)
         let! dbMsg = fixture.TryGetDbMessage msgUpdate.Message
         Assert.Equal("Hello!\nb", dbMsg.Value.text)
     }
+    
+    [<Fact>]
+    let ``MarkAsSpam (soft spam) button does NOT ban user`` () = task {
+        // This test verifies the critical behavior that MarkAsSpam (soft spam)
+        // deletes the message and marks it as spam for ML, but does NOT ban the user
+        let user = Tg.user()
+        let msgUpdate = Tg.quickMsg(chat = fixture.ChatsToMonitor[0], text = "77", from = user)
+        let! _ = fixture.SendMessage msgUpdate
+        
+        // User should NOT be banned initially
+        let! userBannedBefore = fixture.UserBanned user.Id
+        Assert.False(userBannedBefore, "User should not be banned initially")
+        
+        // Click MarkAsSpam button (soft spam) - uses the new third button
+        let! callbackId = fixture.GetCallbackId msgUpdate.Message "MarkAsSpam"
+        let msgCallback = Tg.callback(string callbackId, from = fixture.Vahters[0])
+        let! _ = fixture.SendMessage msgCallback
+        
+        // CRITICAL: User should still NOT be banned after MarkAsSpam button
+        // This is the main assertion - soft spam should NOT ban the user
+        let! userBannedAfter = fixture.UserBanned user.Id
+        Assert.False(userBannedAfter, "User should NOT be banned after MarkAsSpam - this is soft delete only!")
+        
+        // Message should be marked as false negative (spam for ML training)
+        let! isFalseNegative = fixture.IsMessageFalseNegative msgUpdate.Message
+        Assert.True(isFalseNegative, "Message should be marked as false negative for ML")
+    }
+    
+    [<Fact>]
+    let ``Only vahter can click MarkAsSpam button`` () = task {
+        // Similar to "Only vahter can press THE BUTTON(s)" test
+        // Verifies non-vahter clicking MarkAsSpam has no effect
+        let user = Tg.user()
+        let msgUpdate = Tg.quickMsg(chat = fixture.ChatsToMonitor[0], text = "77", from = user)
+        let! _ = fixture.SendMessage msgUpdate
+        
+        // Try to click MarkAsSpam as regular user (not vahter)
+        let! callbackId = fixture.GetCallbackId msgUpdate.Message "MarkAsSpam"
+        let msgCallback = Tg.callback(string callbackId, from = user) // regular user, not vahter
+        let! _ = fixture.SendMessage msgCallback
+        
+        // Message should NOT be marked as false negative (action was rejected)
+        let! isFalseNegative = fixture.IsMessageFalseNegative msgUpdate.Message
+        Assert.False(isFalseNegative, "Non-vahter should not be able to mark message as spam")
+    }
+    
+    [<Fact>]
+    let ``User will be autobanned after consecutive MarkAsSpam clicks`` () = task {
+        // Tests that karma system works with MarkAsSpam
+        // After enough soft spam marks, user gets auto-banned
+        // ML_SPAM_AUTOBAN_SCORE_THRESHOLD is -4.0
+        // socialScore <= threshold triggers ban, so:
+        // - After 1st: score=-1, -1 > -4 → no ban
+        // - After 2nd: score=-2, -2 > -4 → no ban
+        // - After 3rd: score=-3, -3 > -4 → no ban
+        // - After 4th: score=-4, -4 <= -4 → BAN!
+        let user = Tg.user()
+        
+        // First 3 messages should NOT trigger ban
+        for i in 1..3 do
+            let msgUpdate = Tg.quickMsg(chat = fixture.ChatsToMonitor[0], text = "77", from = user)
+            let! _ = fixture.SendMessage msgUpdate
+            
+            // Click MarkAsSpam (soft spam)
+            let! callbackId = fixture.GetCallbackId msgUpdate.Message "MarkAsSpam"
+            let msgCallback = Tg.callback(string callbackId, from = fixture.Vahters[0])
+            let! _ = fixture.SendMessage msgCallback
+            
+            // User should not be banned yet (score is -1, -2, -3)
+            let! userBanned = fixture.UserBanned user.Id
+            Assert.False(userBanned, $"User should not be banned after {i} soft spam marks (score={-i})")
+        
+        // 4th soft spam should trigger auto-ban (score becomes -4 which is <= -4.0 threshold)
+        let finalMsg = Tg.quickMsg(chat = fixture.ChatsToMonitor[0], text = "77", from = user)
+        let! _ = fixture.SendMessage finalMsg
+        
+        let! callbackId = fixture.GetCallbackId finalMsg.Message "MarkAsSpam"
+        let msgCallback = Tg.callback(string callbackId, from = fixture.Vahters[0])
+        let! _ = fixture.SendMessage msgCallback
+        
+        // Now user should be auto-banned due to low karma (score=-4 <= threshold=-4)
+        let! userBanned = fixture.UserBanned user.Id
+        Assert.True(userBanned, "User should be auto-banned after reaching karma threshold via soft spam")
+    }
 
     interface IAssemblyFixture<MlEnabledVahterTestContainers>
     interface IClassFixture<MlAwaitFixture>

src/VahterBanBot/Bot.fs

@@ -497,11 +497,13 @@ let killSpammerAutomated
                 InlineKeyboardButton.WithCallbackData("✅ NOT a spam", string callback.id)
             ]
         else
-            // Potential spam → two callbacks
+            // Potential spam → three callbacks
             let! killCallback = DB.newCallbackPending (CallbackMessage.Spam { message = message }) message.From.Id channelId
+            let! softSpamCallback = DB.newCallbackPending (CallbackMessage.MarkAsSpam { message = message }) message.From.Id channelId
             let! notSpamCallback = DB.newCallbackPending (CallbackMessage.NotASpam { message = message }) message.From.Id channelId
-            return [killCallback.id; notSpamCallback.id], InlineKeyboardMarkup [|
+            return [killCallback.id; softSpamCallback.id; notSpamCallback.id], InlineKeyboardMarkup [|
                 InlineKeyboardButton.WithCallbackData("🚫 KILL", string killCallback.id);
+                InlineKeyboardButton.WithCallbackData("⚠️ SPAM", string softSpamCallback.id);
                 InlineKeyboardButton.WithCallbackData("✅ NOT SPAM", string notSpamCallback.id)
             |]
     }
@@ -526,31 +528,45 @@ let killSpammerAutomated
     logger.LogInformation logMsg
 }
 
-let autoBan
+/// Checks user's social score and triggers auto-ban if below threshold
+/// Returns true if user was auto-banned, false otherwise
+let checkAndAutoBan
     (botUser: DbUser)
     (botClient: ITelegramBotClient)
     (botConfig: BotConfiguration)
     (message: Message)
     (logger: ILogger) = task {
-    use banOnReplyActivity = botActivity.StartActivity("autoBan")
-    %banOnReplyActivity
-        .SetTag("spammerId", message.From.Id)
-        .SetTag("spammerUsername", message.From.Username)
-    
-    let! userStats = DB.getUserStatsByLastNMessages botConfig.MlSpamAutobanCheckLastMsgCount message.From.Id
-    let socialScore = userStats.good - userStats.bad
-    
-    %banOnReplyActivity.SetTag("socialScore", socialScore)
-    
-    if double socialScore <= botConfig.MlSpamAutobanScoreThreshold then
-        // ban user in all monitored chats
-        do! totalBan botClient botConfig message botUser logger
-        let msg = $"Auto-banned user {prependUsername message.From.Username} ({message.From.Id}) due to the low social score {socialScore}"
-        logger.LogInformation msg
-        do! botClient.SendTextMessageAsync(
-                chatId = ChatId(botConfig.AllLogsChannelId),
-                text = msg
-            ) |> taskIgnore
+    if not botConfig.MlSpamAutobanEnabled then
+        return false
+    else
+        use banOnReplyActivity = botActivity.StartActivity("checkAndAutoBan")
+        %banOnReplyActivity
+            .SetTag("spammerId", message.From.Id)
+            .SetTag("spammerUsername", message.From.Username)
+        
+        let! userStats = DB.getUserStatsByLastNMessages botConfig.MlSpamAutobanCheckLastMsgCount message.From.Id
+        let socialScore = userStats.good - userStats.bad
+        
+        %banOnReplyActivity.SetTag("socialScore", socialScore)
+        
+        if double socialScore <= botConfig.MlSpamAutobanScoreThreshold then
+            // ban user in all monitored chats
+            do! totalBan botClient botConfig message botUser logger
+            let msg = $"Auto-banned user {prependUsername message.From.Username} ({message.From.Id}) due to the low social score {socialScore}"
+            logger.LogInformation msg
+            do! botClient.SendTextMessageAsync(
+                    chatId = ChatId(botConfig.AllLogsChannelId),
+                    text = msg
+                ) |> taskIgnore
+            return true
+        else
+            return false
+}
+
+/// Wrapper for backward compatibility - calls checkAndAutoBan and ignores result
+let autoBan botUser botClient botConfig message logger = task {
+    let! _ = checkAndAutoBan botUser botClient botConfig message logger
+    return ()
 }
 
 let totalBanByReaction
@@ -744,10 +760,8 @@ let justMessage
                 if prediction.Score >= botConfig.MlSpamThreshold then
                     // delete message
                     do! killSpammerAutomated botClient botConfig message logger botConfig.MlSpamDeletionEnabled prediction.Score
-
-                    if botConfig.MlSpamAutobanEnabled then
-                        // trigger auto-ban check
-                        do! autoBan botUser botClient botConfig message logger
+                    // trigger auto-ban check (checkAndAutoBan handles MlSpamAutobanEnabled internally)
+                    do! autoBan botUser botClient botConfig message logger
                 elif prediction.Score >= botConfig.MlWarningThreshold then
                     // just warn
                     do! killSpammerAutomated botClient botConfig message logger false prediction.Score
@@ -985,8 +999,50 @@ let vahterMarkedAsSpam
                 logger
 }
 
+/// Soft spam handler - deletes message and marks as spam for ML, but does NOT ban user
+/// User may get auto-banned if karma threshold is reached
+let vahterSoftSpam
+    (botUser: DbUser)
+    (botClient: ITelegramBotClient)
+    (botConfig: BotConfiguration)
+    (logger: ILogger)
+    (vahter: DbUser)
+    (message: MessageWrapper) = task {
+    let msg = message.message
+    let msgId = msg.MessageId
+    let chatId = msg.Chat.Id
+    let chatName = msg.Chat.Username
+    use _ =
+        botActivity
+            .StartActivity("vahterSoftSpam")
+            .SetTag("messageId", msgId)
+            .SetTag("chatId", chatId)
+    
+    // 1. Delete the message from original chat
+    recordDeletedMessage chatId chatName "softSpam"
+    do! botClient.DeleteMessageAsync(ChatId(chatId), msgId)
+        |> safeTaskAwait (fun e -> logger.LogWarning($"Failed to delete message {msgId} from chat {chatId}", e))
+    
+    // 2. Mark as false negative (for ML training + karma)
+    do! DB.markMessageAsFalseNegative chatId msgId
+    
+    // 3. Log the action
+    let vahterUsername = vahter.username |> Option.defaultValue null
+    let logMsg = $"Vahter {prependUsername vahterUsername} ({vahter.id}) marked message {msgId} in {prependUsername chatName}({chatId}) as SPAM (soft, no ban)\n{msg.TextOrCaption}"
+    do! botClient.SendTextMessageAsync(
+            chatId = ChatId(botConfig.AllLogsChannelId),
+            text = logMsg
+        ) |> taskIgnore
+    logger.LogInformation logMsg
+    
+    // 4. Check auto-ban using shared logic (karma system)
+    let! _ = checkAndAutoBan botUser botClient botConfig msg logger
+    ()
+}
+
 // just an aux function to reduce indentation in onCallback and prevent FS3511
 let onCallbackAux
+    (botUser: DbUser)
     (botClient: ITelegramBotClient)
     (botConfig: BotConfiguration)
     (logger: ILogger)
@@ -995,12 +1051,13 @@ let onCallbackAux
     (dbCallback: DbCallback)
     (callbackQuery: CallbackQuery)= task {
     let callback = dbCallback.data
-    let msg = match callback with NotASpam m | Spam m -> m
+    let msg = match callback with NotASpam m | Spam m | MarkAsSpam m -> m
 
     // Determine action type based on callback data and channel
     let actionType = 
         match callback with
         | Spam _ -> "potential_kill"
+        | MarkAsSpam _ -> "potential_soft_spam"
         | NotASpam _ -> 
             if dbCallback.action_channel_id = Some botConfig.DetectedSpamChannelId 
             then "detected_not_spam"
@@ -1021,6 +1078,9 @@ let onCallbackAux
         | Spam msg ->
             %onCallbackActivity.SetTag("type", "Spam")
             do! vahterMarkedAsSpam botClient botConfig logger vahter msg
+        | MarkAsSpam msg ->
+            %onCallbackActivity.SetTag("type", "MarkAsSpam")
+            do! vahterSoftSpam botUser botClient botConfig logger vahter msg
 
         do! botClient.AnswerCallbackQueryAsync(callbackQuery.Id, "Done! +1 🎯")
     else
@@ -1044,6 +1104,7 @@ let onCallbackAux
 }
 
 let onCallback
+    (botUser: DbUser)
     (botClient: ITelegramBotClient)
     (botConfig: BotConfiguration)
     (logger: ILogger)
@@ -1078,6 +1139,7 @@ let onCallback
                 do! botClient.AnswerCallbackQueryAsync(callbackQuery.Id, "Not authorized")
             else
                 do! onCallbackAux
+                        botUser
                         botClient
                         botConfig
                         logger
@@ -1165,7 +1227,7 @@ let onUpdate
     (update: Update) = task {
     use _ = botActivity.StartActivity("onUpdate")
     if update.CallbackQuery <> null then
-        do! onCallback botClient botConfig logger update.CallbackQuery
+        do! onCallback botUser botClient botConfig logger update.CallbackQuery
     elif update.MessageReaction <> null then
         do! onMessageReaction botClient botConfig logger update.MessageReaction
     elif update.EditedOrMessage <> null then

src/VahterBanBot/DB.fs

@@ -297,6 +297,24 @@ ON CONFLICT DO NOTHING;
         return! conn.ExecuteAsync(sql, message)
     }
 
+/// Marks a message as false negative (spam that was not auto-detected)
+/// Used for soft spam marking - counts toward karma but doesn't ban
+let markMessageAsFalseNegative (chatId: int64) (messageId: int): Task =
+    task {
+        use conn = new NpgsqlConnection(connString)
+
+        //language=postgresql
+        let sql =
+            """
+INSERT INTO false_negative_messages (chat_id, message_id)
+VALUES (@chatId, @messageId)
+ON CONFLICT DO NOTHING;
+            """
+
+        let! _ = conn.ExecuteAsync(sql, {| chatId = chatId; messageId = messageId |})
+        return ()
+    }
+
 /// Creates a callback without action_message_id (first phase of two-phase insert)
 let newCallbackPending (data: CallbackMessage) (targetUserId: int64) (channelId: int64): Task<DbCallback> =
     task {

src/VahterBanBot/Types.fs

@@ -153,7 +153,8 @@ type MessageWrapper= { message: Message }
 // as it is used to (de)serialize the button callback data
 type CallbackMessage =
     | NotASpam of MessageWrapper
-    | Spam of MessageWrapper
+    | Spam of MessageWrapper // hard kill - delete all messages and ban user in all chats
+    | MarkAsSpam of MessageWrapper  // soft spam - delete message but no ban
 
 [<CLIMutable>]
 type DbCallback =