add filter for discord server

VovaStelmashchuk · VovaStelmashchuk · commit ed1f6605ab6f · 2025-10-19T18:19:18.000+03:00
diff --git a/server/api/karma/give.post.ts b/server/api/karma/give.post.ts
diff --git a/server/core/discord/bot.ts b/server/core/discord/bot.ts
@@ -1,9 +1,11 @@
-import { Client, GatewayIntentBits, Events, ChatInputCommandInteraction } from 'discord.js'
+import { Client, GatewayIntentBits, Events, ChatInputCommandInteraction, MessageFlags } from 'discord.js'
 import { useNitroApp, useRuntimeConfig } from '#imports'
 import { KarmaService } from './karma'
 
 export function createDiscordBot() {
     const logger = useNitroApp().logger
+    const runtimeConfig = useRuntimeConfig()
+    const allowedGuildId = runtimeConfig.public.discordGuildId
 
     const client = new Client({
         intents: [
@@ -13,11 +15,21 @@ export function createDiscordBot() {
 
     client.once(Events.ClientReady, (readyClient) => {
         logger.info(`Discord bot ready! Logged in as ${readyClient.user.tag}`)
+        logger.info(`Bot will only respond to commands from guild: ${allowedGuildId}`)
     })
 
     client.on(Events.InteractionCreate, async (interaction) => {
         if (!interaction.isChatInputCommand()) return
 
+        if (interaction.guildId !== allowedGuildId) {
+            logger.warn(`Ignored command from unauthorized guild: ${interaction.guildId}`)
+            await interaction.reply({
+                content: '❌ This bot is not configured for this server.',
+                flags: MessageFlags.Ephemeral
+            }).catch(() => { })
+            return
+        }
+
         if (interaction.commandName === 'karma') {
             await handleKarmaCommand(interaction)
         }
@@ -30,47 +42,40 @@ async function handleKarmaCommand(interaction: ChatInputCommandInteraction) {
     const logger = useNitroApp().logger
 
     try {
-        // Get the user who invoked the command
+        await interaction.deferReply()
+
         const giver = interaction.user
 
-        // Get all mentioned users from the command
-        const users = interaction.options.resolved?.users
+        const receiverUser = interaction.options.getUser('user', true)
 
-        if (!users || users.size === 0) {
-            await interaction.reply({
-                content: '❌ Please mention at least one user to give karma!',
-                ephemeral: true
+        const reason = interaction.options.getString('reason', false) || undefined
+
+        logger.info('Karma command received:', { giver: giver.id, receiver: receiverUser.id, reason: reason || 'No reason provided' })
+
+        if (!receiverUser) {
+            await interaction.editReply({
+                content: '❌ Please mention a user to give karma!'
             })
             return
         }
 
-        // Extract user IDs
-        const receiverIds = Array.from(users.values()).map(user => user.id)
-
-        // Defer reply for longer processing
-        await interaction.deferReply()
-
-        // Call karma service directly
         const karmaService = new KarmaService()
-        const result = await karmaService.giveKarma(giver.id, receiverIds)
+        const result = await karmaService.giveKarma(giver.id, receiverUser.id, reason)
 
-        // Format success message
-        const userMentions = Array.from(users.values())
-            .map(user => `<@${user.id}>`)
-            .join(', ')
+        let message = `✅ Karma given to <@${receiverUser.id}>!\n\n<@${receiverUser.id}>: **${result.total_karma}** karma`
 
-        const karmaDetails = result.karma_counts
-            .map(kc => `<@${kc.receiver_discord_id}>: **${kc.total_karma}** karma`)
-            .join('\n')
+        if (reason) {
+            message += `\n\n💬 Reason: ${reason}`
+        }
 
         await interaction.editReply({
-            content: `✅ Karma given to ${userMentions}!\n\n${karmaDetails}`
+            content: message
         })
 
-        logger.info(`Karma given by ${giver.id} to ${receiverIds.join(', ')}`)
+        logger.info(`Karma given by ${giver.id} to ${receiverUser.id}${reason ? ` with reason: ${reason}` : ''}`)
 
     } catch (error) {
-        logger.error('Error handling karma command:', error)
+        logger.info('Error handling karma:', error)
 
         const errorMessage = error instanceof Error ? error.message : 'An error occurred while processing your request.'
         const userFriendlyMessage = `❌ ${errorMessage}`
@@ -82,7 +87,7 @@ async function handleKarmaCommand(interaction: ChatInputCommandInteraction) {
         } else {
             await interaction.reply({
                 content: userFriendlyMessage,
-                ephemeral: true
+                flags: MessageFlags.Ephemeral
             })
         }
     }
diff --git a/server/core/discord/karma.ts b/server/core/discord/karma.ts
@@ -8,7 +8,8 @@ export type KarmaCount = {
 
 export type GiveKarmaResult = {
     success: boolean
-    karma_counts: KarmaCount[]
+    receiver_discord_id: string
+    total_karma: number
     timestamp: string
 }
 
@@ -22,68 +23,68 @@ export class KarmaService {
     }
 
     /**
-     * Give karma from one user to multiple receivers
+     * Give karma from one user to a receiver
      * @param giverDiscordId - Discord ID of the user giving karma
-     * @param receiverDiscordIds - Array of Discord IDs receiving karma
-     * @returns Result containing karma counts for each receiver
+     * @param receiverDiscordId - Discord ID of the user receiving karma
+     * @param reason - Optional reason for giving karma
+     * @returns Result containing karma count for the receiver
      * @throws Error if validation fails or database operation fails
      */
     async giveKarma(
         giverDiscordId: string,
-        receiverDiscordIds: string[]
+        receiverDiscordId: string,
+        reason?: string
     ): Promise<GiveKarmaResult> {
-        // Validate inputs
         if (!giverDiscordId) {
             throw new Error('giver_discord_id is required')
         }
 
-        if (!receiverDiscordIds || !Array.isArray(receiverDiscordIds) || receiverDiscordIds.length === 0) {
-            throw new Error('receiver_discord_ids must be a non-empty array')
+        if (!receiverDiscordId) {
+            throw new Error('receiver_discord_id is required')
         }
 
-        if (receiverDiscordIds.includes(giverDiscordId)) {
+        if (receiverDiscordId === giverDiscordId) {
             throw new Error('Хтось пробує сам собі дати карму!')
         }
 
         try {
             const timestamp = new Date()
-            const karmaCounts: KarmaCount[] = []
 
-            this.logger.info('Giving karma to receivers:', { giverDiscordId: giverDiscordId, receiverDiscordIds: receiverDiscordIds })
+            this.logger.info('Giving karma to receiver:', {
+                giverDiscordId,
+                receiverDiscordId,
+                reason: reason || 'No reason provided'
+            })
 
-            // Check if receivers exist in discord_members collection
-            const existingMembers = await this.db.collection('discord_members').find({
-                discordId: { $in: receiverDiscordIds }
-            }).project({ discordId: 1 }).toArray()
+            const existingMember = await this.db.collection('discord_members').findOne({
+                discordId: receiverDiscordId
+            })
 
-            const existingIds = new Set(existingMembers.map((m: any) => m.discordId))
-            const filteredDiscordIds = receiverDiscordIds.filter(id => existingIds.has(id))
+            if (!existingMember) {
+                throw new Error('Receiver not found in discord_members')
+            }
 
-            if (filteredDiscordIds.length === 0) {
-                throw new Error('No valid receiver_discord_ids found in discord_members')
+            const karmaEvent: any = {
+                giver_discord_id: giverDiscordId,
+                receiver_discord_id: receiverDiscordId,
+                amount: 1,
+                timestamp: timestamp
             }
 
-            for (const receiverId of filteredDiscordIds) {
-                await this.db.collection('karma_events').insertOne({
-                    giver_discord_id: giverDiscordId,
-                    receiver_discord_id: receiverId,
-                    amount: 1,
-                    timestamp: timestamp
-                })
+            if (reason) {
+                karmaEvent.reason = reason
+            }
 
-                const totalKarma = await this.getTotalKarma(receiverId)
+            await this.db.collection('karma_events').insertOne(karmaEvent)
 
-                karmaCounts.push({
-                    receiver_discord_id: receiverId,
-                    total_karma: totalKarma
-                })
+            const totalKarma = await this.getTotalKarma(receiverDiscordId)
 
-                this.logger.info(`Karma given: ${giverDiscordId} -> ${receiverId}, new total: ${totalKarma}`)
-            }
+            this.logger.info(`Karma given: ${giverDiscordId} -> ${receiverDiscordId}, new total: ${totalKarma}${reason ? `, reason: ${reason}` : ''}`)
 
             return {
                 success: true,
-                karma_counts: karmaCounts,
+                receiver_discord_id: receiverDiscordId,
+                total_karma: totalKarma,
                 timestamp: timestamp.toISOString()
             }
         } catch (error) {
diff --git a/server/core/discord/register-commands.ts b/server/core/discord/register-commands.ts
@@ -17,36 +17,18 @@ export async function registerDiscordCommands() {
     const commands = [
         {
             name: 'karma',
-            description: 'Give karma to users',
+            description: 'Give karma to a user',
             options: [
                 {
-                    name: 'user1',
-                    description: 'First user to give karma',
+                    name: 'user',
+                    description: 'User to give karma',
                     type: ApplicationCommandOptionType.User,
                     required: true,
                 },
                 {
-                    name: 'user2',
-                    description: 'Second user to give karma',
-                    type: ApplicationCommandOptionType.User,
-                    required: false,
-                },
-                {
-                    name: 'user3',
-                    description: 'Third user to give karma',
-                    type: ApplicationCommandOptionType.User,
-                    required: false,
-                },
-                {
-                    name: 'user4',
-                    description: 'Fourth user to give karma',
-                    type: ApplicationCommandOptionType.User,
-                    required: false,
-                },
-                {
-                    name: 'user5',
-                    description: 'Fifth user to give karma',
-                    type: ApplicationCommandOptionType.User,
+                    name: 'reason',
+                    description: 'Reason for giving karma',
+                    type: ApplicationCommandOptionType.String,
                     required: false,
                 },
             ],
