Update index.js

index.js

@@ -1,3 +1,4 @@
+@ -1,281 +1,324 @@
 // index.js
 
 const {
@@ -33,11 +34,6 @@ client.login(process.env.BOT_TOKEN).then(() => {
   console.error('Login failed:', error);
 });
 
-// Handle client errors
-client.on('error', (error) => {
-  console.error('The client encountered an error:', error);
-});
-
 // Function to fetch user data from the API
 async function findUserByUsername(username) {
   try {
@@ -80,38 +76,30 @@ function getBadgeImageUrl(badgeName) {
 client.on('interactionCreate', async (interaction) => {
   if (!interaction.isCommand()) return;
 
-  try {
+  const { commandName } = interaction;
-    console.log(`Interaction received: ${interaction.id} by ${interaction.user.tag}`);
 
-    const { commandName } = interaction;
+  if (commandName === 'ping') {
+    await interaction.reply('Pong!');
+  } else if (commandName === 'finduser') {
+    const username = interaction.options.getString('username');
+    const gameFilter = interaction.options.getString('game');
 
-    if (commandName === 'ping') {
+    await interaction.deferReply();
-      await interaction.reply('Pong!');
-    } else if (commandName === 'finduser') {
-      await interaction.deferReply(); // Defer immediately
 
-      const username = interaction.options.getString('username');
+    // Fetch data from the API using the provided username
-      const gameFilter = interaction.options.getString('game');
+    const userData = await findUserByUsername(username);
-
-      // Fetch data from the API using the provided username
-      const userData = await findUserByUsername(username);
-
-      if (!userData) {
-        await interaction.editReply('An error occurred while fetching data.');
-        return;
-      }
 
+    if (userData && userData.success) {
       let playerData;
-      try {
+      if (typeof userData.player_data === 'string') {
-        if (typeof userData.player_data === 'string') {
+        try {
           playerData = JSON.parse(userData.player_data);
-        } else {
+        } catch (error) {
-          playerData = userData.player_data;
+          await interaction.editReply('Error parsing player data.');
+          return;
         }
-      } catch (parseError) {
+      } else {
-        console.error('Error parsing player data:', parseError);
+        playerData = userData.player_data;
-        await interaction.editReply('Error parsing player data.');
-        return;
       }
 
       if (!playerData || !playerData.profile) {
@@ -124,16 +112,195 @@ client.on('interactionCreate', async (interaction) => {
       const user = playerData.profile || {};
       const badgeImageUrl = getBadgeImageUrl(user.current_level_badge);
 
-      // Declare 'embed' at the appropriate scope
-      let embed;
-
       // Create the embed builder
-      embed = new EmbedBuilder()
+      const embed = new EmbedBuilder()
         .setTitle(`User: ${playerData.username || 'Unknown'}`)
         .setDescription(`Bio: ${user.bio || 'No bio available'}`)
         .setColor('#0099ff');
 
-      // Rest of your code...
+      // Set thumbnail if avatar is available
+      if (user.avatar) {
+        embed.setThumbnail(
+          `https://www.vrbattles.gg/assets/uploads/profile/${user.avatar}`
+        );
+      }
+
+      // Before adding fields to the embed, initialize a counter
+      let totalFields = 0;
+
+      // Add profile fields dynamically
+      const profileFields = [];
+
+      if (user.country)
+        profileFields.push({
+          name: 'Country',
+          value: user.country,
+          inline: true,
+        });
+      if (user.rank)
+        profileFields.push({ name: 'Rank', value: user.rank, inline: true });
+      if (user.level)
+        profileFields.push({
+          name: 'Level',
+          value: user.level.toString(),
+          inline: true,
+        });
+      if (user.prestige)
+        profileFields.push({
+          name: 'Prestige',
+          value: user.prestige.toString(),
+          inline: true,
+        });
+      if (user.xp)
+        profileFields.push({
+          name: 'Total XP',
+          value: user.xp.toString(),
+          inline: true,
+        });
+
+      if (profileFields.length > 0) {
+        embed.addFields(profileFields);
+        totalFields += profileFields.length;
+      }
+
+      // Set badge image if available
+      if (badgeImageUrl) {
+        embed.setImage(badgeImageUrl);
+      }
+
+      // Dynamically add game statistics
+      const games = playerData.stats?.games;
+      if (games && Object.keys(games).length > 0 && totalFields < 25) {
+        if (totalFields + 1 <= 25) {
+          embed.addFields({ name: '\u200B', value: '**Game Statistics**' });
+          totalFields += 1;
+        }
+
+        for (const [gameName, gameData] of Object.entries(games)) {
+          if (
+            gameFilter &&
+            gameName.toLowerCase() !== gameFilter.toLowerCase()
+          ) {
+            continue; // Skip games that don't match the filter
+          }
+
+          for (const [modeName, modeStats] of Object.entries(gameData)) {
+            const statsFields = [];
+
+            // Collect stats for the mode
+            if (modeStats.matches)
+              statsFields.push({
+                name: 'Matches',
+                value: modeStats.matches.toString(),
+                inline: true,
+              });
+            if (modeStats.wins)
+              statsFields.push({
+                name: 'Wins',
+                value: modeStats.wins.toString(),
+                inline: true,
+              });
+            if (modeStats.losses)
+              statsFields.push({
+                name: 'Losses',
+                value: modeStats.losses.toString(),
+                inline: true,
+              });
+            if (modeStats.win_rate)
+              statsFields.push({
+                name: 'Win Rate',
+                value: modeStats.win_rate,
+                inline: true,
+              });
+            if (modeStats.mmr)
+              statsFields.push({
+                name: 'MMR',
+                value: modeStats.mmr.toString(),
+                inline: true,
+              });
+
+            // Calculate the number of fields to be added
+            const fieldsToAdd = 1 + statsFields.length; // 1 for the section header
+
+            // Check if adding these fields would exceed the limit
+            if (totalFields + fieldsToAdd > 25) {
+              // You can choose to skip adding these fields or break the loop
+              break; // Stops adding more fields
+            }
+
+            // Add the section header
+            embed.addFields({
+              name: '\u200B',
+              value: `**${gameName} - ${modeName}**`,
+            });
+            totalFields += 1;
+
+            // Add the stats fields
+            embed.addFields(statsFields);
+            totalFields += statsFields.length;
+
+            // Check after each addition
+            if (totalFields >= 25) {
+              break;
+            }
+          }
+
+          if (totalFields >= 25) {
+            break;
+          }
+        }
+      }
+
+      // Add teams dynamically
+      const teams = playerData.teams;
+      if (teams && Object.keys(teams).length > 0 && totalFields < 25) {
+        const teamList = Object.values(teams)
+          .map(
+            (team) =>
+              `- **${team.team_name}** (${team.game_name} - ${team.game_mode})`
+          )
+          .join('\n');
+
+        const teamsField = [
+          { name: '\u200B', value: '**Teams**' },
+          { name: 'Team List', value: teamList || 'No teams available' },
+        ];
+
+        // Check if adding these fields would exceed the limit
+        const fieldsToAdd = teamsField.length;
+        if (totalFields + fieldsToAdd <= 25) {
+          embed.addFields(teamsField);
+          totalFields += fieldsToAdd;
+        }
+      }
+
+      // Add recent matches dynamically
+      const matches = playerData.matches;
+      if (matches && Object.keys(matches).length > 0 && totalFields < 25) {
+        const matchList = Object.values(matches)
+          .sort((a, b) => new Date(b.start_time) - new Date(a.start_time)) // Sort by date descending
+          .slice(0, 3) // Limit to recent 3 matches
+          .map((match) => {
+            const date = new Date(match.start_time).toLocaleDateString();
+            const team1 = match.team1_name || 'Team 1';
+            const team2 = match.team2_name || 'Team 2';
+            const score = match.score || 'N/A';
+            return `- **${team1}** vs **${team2}** on ${date} - Result: ${score}`;
+          })
+          .join('\n');
+
+        const matchesField = [
+          { name: '\u200B', value: '**Recent Matches**' },
+          { name: 'Match History', value: matchList || 'No recent matches' },
+        ];
+
+        // Check if adding these fields would exceed the limit
+        const fieldsToAdd = matchesField.length;
+        if (totalFields + fieldsToAdd <= 25) {
+          embed.addFields(matchesField);
+          totalFields += fieldsToAdd;
+        }
+      }
 
       // Add action buttons
       const row = new ActionRowBuilder().addComponents(
@@ -147,24 +314,11 @@ client.on('interactionCreate', async (interaction) => {
           .setURL('https://discord.gg/j3DKVATPGQ') // Replace with your Discord invite URL
       );
 
-      // Ensure 'embed' is defined before using it
+      await interaction.editReply({ embeds: [embed], components: [row] });
-      if (embed) {
+    } else {
-        await interaction.editReply({ embeds: [embed], components: [row] });
+      await interaction.editReply(
-      } else {
+        'User not found or an error occurred while fetching data.'
-        await interaction.editReply('No data available to display.');
+      );
-      }
-    }
-  } catch (error) {
-    console.error('Error handling interaction:', error);
-
-    try {
-      if (interaction.deferred || interaction.replied) {
-        await interaction.followUp({ content: 'An error occurred while processing your request.', ephemeral: true });
-      } else {
-        await interaction.reply({ content: 'An error occurred while processing your request.', ephemeral: true });
-      }
-    } catch (replyError) {
-      console.error('Error sending error message:', replyError);
     }
   }
-});
+});