fix/update victim stats after explosive death

Update/nitrado improvements

.github/FUNDING.yml

@@ -1,15 +1 @@
-# These are supported funding model platforms
+github: SowinskiBraeden 
-
-github: SowinskiBraeden # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
-polar: # Replace with a single Polar username
-buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
-thanks_dev: # Replace with a single thanks.dev username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Execute command '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -4,12 +4,10 @@ node_modules/*
 # Testing/dev related
 *_test.js
 dev-*.js
+commands/debug.js
 
 # Logs
 logs/*
 
 # env
 .env
-
-# Admin Script backups
-admin/backup/*

bot.js

@@ -0,0 +1,33 @@
+const DayzR = require('./src/DayzRBot');
+const config = require('./config/config');
+const { GatewayIntentBits } = require('discord.js');
+
+const path = require("path");
+const fs = require('fs');
+const { HandleActivePlayersList } = require('./util/LogsHandler');
+
+// Log all uncaught exceptions before killing process.
+process.on('uncaughtException', async (error) => {
+	console.trace(error);
+	let d = new Date();
+	// Asynchronously write the error message to a log file using Promises
+	await new Promise((resolve, reject) => {
+		if (HandleActivePlayersList.lastSendMessage) HandleActivePlayersList.lastSendMessage.delete().catch(error => client.sendError(channel, `HandleActivePlayersList Error: \n${error}`));  // Remove previous embed message before closing
+		fs.appendFile(path.join(__dirname, "./logs/Logs.log"), 
+		`{"level":"error","message":"${d.getHours()}:${d.getMinutes()} - ${d.getMonth()+1}:${d.getDate()}:${d.getFullYear()} | uncaughtException: ${error.stack}"}`, (logErr) => {
+			if (logErr) {
+				console.error('Error writing uncaughtException to log file:', logErr);
+				reject(logErr);
+				process.exit()
+			} else {
+				resolve();
+			}
+		});
+	});
+
+	// Now gracefully close the program
+	process.exit()
+});
+
+let client = new DayzR({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.GuildMembers] }, config);
+client.build()

commands/config.js

@@ -100,6 +100,12 @@ module.exports = {
           description: "Clears all configured channels",
           value: "clear",
           type: CommandOptions.SubCommand,   
+        },
+        {
+          name: "view",
+          description: "View configured allowed channels",
+          value: "view",
+          type: CommandOptions.SubCommand,
         }
       ]
     },
@@ -160,31 +166,46 @@ module.exports = {
       name: "bot_admin_role",
       description: "Set/remove bot admin role",
       value: "bot_admin_role",
-      type: CommandOptions.SubCommand,
+      type: CommandOptions.SubCommandGroup,
       options: [
         {
-          name: "action",
+          name: "add",
-          description: "Set or remove a role to be a bot administrator",
+          description: "Configure role to be bot admin",
-          value: "action",
+          value: "add",
-          type: CommandOptions.String,
+          type: CommandOptions.SubCommand,
-          choices: [
+          options: [{
-            { name: 'add', value: 'add' }, { name: 'remove', value: 'remove' },
-          ],
-          required: true,
-        },
-        {
             name: "role",
-          description: "Role to configure",
+            description: "Role to confiure",
             value: "role",
             type: CommandOptions.Role,
             required: true,
+          }]
         },
+        {
+          name: "remove",
+          description: "Remove configured role as bot admin",
+          value: "remove",
+          type: CommandOptions.SubCommand,
+          options: [{
+            name: "role",
+            description: "Role to remove",
+            value: "role",
+            type: CommandOptions.Role,
+            required: true,
+          }]
+        },
+        {
+          name: "view",
+          description: "View the configured bot admin roles",
+          value: "view",
+          type: CommandOptions.SubCommand,
+        }
       ]
     },
     {
-      name: "admin_role",
+      name: "admin_ping_role",
       description: "Admin role to ping in admin logs channel",
-      value: "admin_role",
+      value: "admin_ping_role",
       type: CommandOptions.SubCommand,
       options: [{
         name: "role",
@@ -196,26 +217,41 @@ module.exports = {
     },
     {
       name: "exclude",
-      description: "Exclude roles that users can use to claim an armband",
+      description: "Exclude roles that can be used to claim armbands",
       value: "exclude",
-      type: CommandOptions.SubCommand,
+      type: CommandOptions.SubCommandGroup,
       options: [
          {
-          name: "action",
+          name: "add",
-          description: "Add or remove a role from the exclude list.",
+          description: "Configure role to be excluded",
-          value: "action",
+          value: "add",
-          type: CommandOptions.String,
+          type: CommandOptions.SubCommand,
-          choices: [
+          options: [{
-            { name: 'add', value: 'add' }, { name: 'remove', value: 'remove' },
-          ],
-          required: true,
-        },
-        {
             name: "role",
-          description: "The role to manage",
+            description: "Role to confiure",
             value: "role",
             type: CommandOptions.Role,
             required: true,
+          }]
+        },
+        {
+          name: "remove",
+          description: "Remove configured role thats excluded",
+          value: "remove",
+          type: CommandOptions.SubCommand,
+          options: [{
+            name: "role",
+            description: "Role to remove",
+            value: "role",
+            type: CommandOptions.Role,
+            required: true,
+          }]
+        },
+        {
+          name: "view",
+          description: "View the configured excluded roles",
+          value: "view",
+          type: CommandOptions.SubCommand,
         },
       ]
     },
@@ -478,11 +514,36 @@ module.exports = {
             return interaction.send({ embeds: [promptClearChannels], components: [optClearChannels], flags: (1 << 6) });
             
 
+          } else if (channels_config == 'view') {
+            
+            if (!GuildDB.customChannelStatus) {
+              const noConfiguredChannels = new EmbedBuilder()
+                .setColor(client.config.Colors.Default)
+                .setTitle('Channels')
+                .setDescription('> There are no configured channels');
+
+              return interaction.send({ embeds: [noConfiguredChannels] });
+            }
+
+            const configuredChannels = new EmbedBuilder()
+              .setColor(client.config.Colors.Default)
+              .setTitle('Channels')
+
+            let des = '';
+            for (let i = 0; i < GuildDB.allowedChannels.length; i++) {
+              if (i == 0) des += `> <#${GuildDB.allowedChannels[i]}>`;
+              else des += `\n> <#${GuildDB.allowedChannels[i]}>`;
+            }
+            configuredChannels.setDescription(des);
+
+            return interaction.send({ embeds: [configuredChannels] });
+          
           }
 
         case 'bot_admin_role':
-          if (args[0].options[0].value == 'add') {
+          const bot_admin_config = args[0].options[0].name;
-            const botAdminRoleId = args[0].options[1].value;
+          const botAdminRoleId = ['add', 'remove'].includes(bot_admin_config) ? args[0].options[0].options[0].value : null;
+          if (bot_admin_config == 'add') {
 
             client.dbo.collection("guilds").updateOne({"server.serverID":GuildDB.serverID},{$push: {"server.botAdminRoles": botAdminRoleId}}, (err, res) => {
               if (err) return client.sendInternalError(interaction, err);
@@ -494,7 +555,7 @@ module.exports = {
       
             return interaction.send({ embeds: [successSetBotAdminRoleEmbed] });    
 
-          } else if (args[0].options[0].value== 'remove') {
+          } else if (bot_admin_config == 'remove') {
 
             if (!GuildDB.botAdminRoles.includes(botAdminRoleId)) {
               const nonAdminRoleEmbed = new EmbedBuilder()
@@ -521,9 +582,33 @@ module.exports = {
               )
 
             return interaction.send({ embeds: [promptRemoveAdminRole], components: [optRemoveAdminRole], flags: (1 << 6) });
+          
+          } else if (bot_admin_config == 'view') {
+
+            if (GuildDB.botAdminRoles.length == 0) {
+              const noBotAdminRoles = new EmbedBuilder()
+                .setColor(client.config.Colors.Default)
+                .setTitle('Admin Roles')
+                .setDescription('> There have been no configured admin roles');
+
+              return interaction.send({ embeds: [noBotAdminRoles] });
             }
 
-        case 'admin_role':
+            const botAdminRolesEmbed = new EmbedBuilder()
+              .setColor(client.config.Colors.Default)
+              .setTitle('Admin Roles')
+
+            let des = '';
+            for (let i = 0; i < GuildDB.botAdminRoles.length; i++) {
+              des += `\n> <@&${GuildDB.botAdminRoles[i]}>`;
+            }
+            botAdminRolesEmbed.setDescription(des);
+
+            return interaction.send({ embeds: [botAdminRolesEmbed] });
+
+          }
+
+        case 'admin_ping_role':
           client.dbo.collection("guilds").updateOne({"server.serverID":GuildDB.serverID},{$set: {"server.adminRole": args[0].options[0].value}}, (err, res) => {
             if (err) return client.sendInternalError(interaction, err);
           });
@@ -535,27 +620,54 @@ module.exports = {
           return interaction.send({ embeds: [successSetAdminRoleEmbed] });
 
         case 'exclude':
-          if (args[0].options[0].value == 'add') {
+          const exclude_config = args[0].options[0].name;
-            client.dbo.collection('guilds').updateOne({'server.serverID': GuildDB.serverID}, {$push: {'server.excludedRoles': args[0].options[1].value}}, (err, res) => {
+          const exclude_roleid = ['add', 'remove'].includes(exclude_config) ? args[0].options[0].options[0].value : null;
+          
+          if (exclude_config == 'add') {
+            client.dbo.collection('guilds').updateOne({'server.serverID': GuildDB.serverID}, {$push: {'server.excludedRoles': exclude_roleid}}, (err, res) => {
               if (err) return client.sendInternalError(interaction, err);
             })
 
             const successExcludeEmbed = new EmbedBuilder()
               .setColor(client.config.Colors.Green)
-              .setDescription(`**Done!**\n> Successfully added <@&${args[0].options[1].value}> to list of excluded roles.`)
+              .setDescription(`**Done!**\n> Successfully added <@&${exclude_roleid}> to list of excluded roles.`)
 
             return interaction.send({ embeds: [successExcludeEmbed] });
 
-          } else if (args[0].options[0].value == 'remove') {
+          } else if (exclude_config == 'remove') {
-            client.dbo.collection('guilds').updateOne({'server.serverID': GuildDB.serverID}, {$pull: {'server.excludedRoles': args[0].options[1].value}}, (err, res) => {
+            client.dbo.collection('guilds').updateOne({'server.serverID': GuildDB.serverID}, {$pull: {'server.excludedRoles': exclude_roleid}}, (err, res) => {
               if (err) return client.sendInternalError(interaction, err);
             })
 
             const successRemoveExcludeEmbed = new EmbedBuilder()
               .setColor(client.config.Colors.Green)
-              .setDescription(`**Done!**\n> Successfully removed <@&${args[0].options[1].value}> to list of excluded roles.`)
+              .setDescription(`**Done!**\n> Successfully removed <@&${exclude_roleid}> to list of excluded roles.`)
 
             return interaction.send({ embeds: [successRemoveExcludeEmbed] });
+          
+          } else if (exclude_config == "view") {
+
+            if (GuildDB.excludedRoles.length == 0) {
+              const noExcludedRoles = new EmbedBuilder()
+                .setColor(client.config.Colors.Default)
+                .setTitle('Excluded Roles')
+                .setDescription('> There have been no excluded roles');
+
+              return interaction.send({ embeds: [noExcludedRoles] });
+            }
+
+            const excludedRolesEmbed = new EmbedBuilder()
+              .setColor(client.config.Colors.Default)
+              .setTitle('Excluded Roles')
+
+            let des = '';
+            for (let i = 0; i < GuildDB.excludedRoles.length; i++) {
+              des += `\n> <@&${GuildDB.excludedRoles[i]}>`;
+            }
+            excludedRolesEmbed.setDescription(des);
+
+            return interaction.send({ embeds: [excludedRolesEmbed] });
+
           }
 
         case 'reset':
@@ -579,24 +691,67 @@ module.exports = {
           return interaction.send({ embeds: [promptReset], components: [optReset], flags: (1 << 6) });
       
         case 'view':
-          const channelsInfo = GuildDB.customChannelStatus ? '\n╚➤ \`/channels\` to view' : '';
-          const channelColor = GuildDB.customChannelStatus ? '+ ' : '- ';
-          let botAdminRoles = '';
-          for (let i = 0; i < GuildDB.botAdminRoles.length; i++) {
-            botAdminRoles += `\n╚➤ <@&${GuildDB.botAdminRoles[i]}>`;
-          }
-          const botAdminRoleColor = GuildDB.hasBotAdmin ? `+ ` : '- ';
-          const excludedRolesColor = GuildDB.excludedRoles.length > 0 ? `+ ` : '- ';
-          const excludedRolesInfo = GuildDB.excludedRoles.length > 0 ? '\n╚➤ \`/excluded\` to view' : '';
 
+          // wrappers
+          const w = "\`\`\`";
+          const a = "ansi\n";
+          const f = "fix\n";
+          const m = "arm\n"
+          const g = "";
+          const r = "";
+
+          // boolean display
+          const autoRestart             = GuildDB.autoRestart        ? `${g}true` : `${r}false`;
+          const showKillfeedCoords      = GuildDB.showKillfeedCoords ? `${g}true` : `${r}false`;
+          const showKillfeedWeapon      = GuildDB.showKillfeedWeapon ? `${g}true` : `${r}false`;
+          const purchaseUAV             = GuildDB.purchaseUAV        ? `${g}true` : `${r}false`;
+          const purchaseEMP             = GuildDB.purchaseEMP        ? `${g}true` : `${r}false`;
+          const adminRoles              = GuildDB.hasBotAdmin        ? `${g}true` : `${r}false`
+          const excludedRoles           = GuildDB.hasExcludedRoles   ? `${g}true` : `${r}false`; 
+
+          // Role / channel display
+          const NONE                    = `${w}${m}none${w}`;
+          const channelsInfo            = GuildDB.customChannelStatus                  ? '\`</channels:1225869620813107246>\` to view' : NONE;
+          const killfeedChannel         = client.exists(GuildDB.killfeedChannel)       ? `<#${GuildDB.killfeedChannel}>`               : NONE;
+          const connectionLogs          = client.exists(GuildDB.connectionLogsChannel) ? `<#${GuildDB.connectionLogsChannel}>`         : NONE;
+          const activePlayers           = client.exists(GuildDB.activePlayersChannel)  ? `<#${GuildDB.activePlayersChannel}>`          : NONE;
+          const welcomeChannel          = client.exists(GuildDB.welcomeChannel)        ? `<#${GuildDB.welcomeChannel}>`                : NONE;
+          const linkedGTRole            = client.exists(GuildDB.linkedGamertagRole)    ? `<@&${GuildDB.linkedGamertagRole}>`           : NONE;
+          const memberRole              = client.exists(GuildDB.memberRole)            ? `<@&${GuildDB.memberRole}>`                   : NONE;
+
+          // value display
+          const incomeLimiter           = `${GuildDB.incomeLimiter} hours`;
+          const startingBalance         = `$${GuildDB.startingBalance.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2})}`;
+          const uavPrice                = `$${GuildDB.uavPrice.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2})}`;
+          const empPrice                = `$${GuildDB.empPrice.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2})}`;
+          const combatLogTimer          = `${GuildDB.combatLogTimer} minutes`;
+
+          // Ugly below but kinda nice above
           const settingsEmbed = new EmbedBuilder()
             .setColor(client.config.Colors.Default)
             .setTitle('Current Guild Configurations')
             .addFields(
-              { name: 'Guild ID', value: `\`\`\`arm\n${GuildDB.serverID}\`\`\``, inline: true },
+              { name: 'Guild ID',                value: `${w}${f}${GuildDB.serverID}${w}`,   inline: true },
-              { name: 'Has Allowed Channels?', value: `\`\`\`diff\n${channelColor}${GuildDB.customChannelStatus}\`\`\`${channelsInfo}`, inline: true },
+              { name: 'Server Name',             value: `${w}${f}${GuildDB.serverName}${w}`, inline: true },
-              { name: 'Has bot admin role?', value: `\`\`\`diff\n${botAdminRoleColor}${client.exists(GuildDB.botAdmin)}\`\`\`${botAdminRoles}`, inline: true },
+              { name: 'Auto Restart',            value: `${w}${a}${autoRestart}${w}`,        inline: true },
-              { name: 'Excluded roles?', value: `\`\`\`diff\n${excludedRolesColor}${GuildDB.excludedRoles.length > 0}\`\`\`${excludedRolesInfo}` },
+              { name: 'UAVs Enabled',            value: `${w}${a}${purchaseUAV}${w}`,        inline: true },
+              { name: 'EMPs Enabled',            value: `${w}${a}${purchaseEMP}${w}`,        inline: true },
+              { name: 'Show Killfeed Coords',    value: `${w}${a}${showKillfeedCoords}${w}`, inline: true },
+              { name: 'Show Killfeed Weapons',   value: `${w}${a}${showKillfeedWeapon}${w}`, inline: true },
+              { name: 'Has Admin Rols',          value: `${w}${a}${adminRoles}${w}`,         inline: true },
+              { name: 'Has Excluded Roles',      value: `${w}${a}${excludedRoles}${w}`,      inline: true },
+              { name: 'Allowed Channels',        value: `${channelsInfo}`,                   inline: true },
+              { name: 'Killfeed Channel',        value: `${killfeedChannel}`,                inline: true },
+              { name: 'Connection Logs Channel', value: `${connectionLogs}`,                 inline: true },
+              { name: 'Player List Channel',     value: `${activePlayers}`,                  inline: true },
+              { name: 'Welcome Channel',         value: `${welcomeChannel}`,                 inline: true },
+              { name: 'Linked Gamertag Role',    value: `${linkedGTRole}`,                   inline: true },
+              { name: 'Member Role',             value: `${memberRole}`,                     inline: true },
+              { name: 'Income Limiter',          value: `${w}${f}${incomeLimiter}${w}`,      inline: true },
+              { name: 'Starting Balance',        value: `${w}${f}${startingBalance}${w}`,    inline: true },
+              { name: 'UAV Price',               value: `${w}${f}${uavPrice}${w}`,           inline: true },
+              { name: 'EMP Price',               value: `${w}${f}${empPrice}${w}`,           inline: true },
+              { name: 'Combat Log Timer',        value: `${w}${f}${combatLogTimer}${w}`,     inline: true },
             );
 
           return interaction.send({ embeds: [settingsEmbed] });

commands/debug.js

@@ -1,30 +0,0 @@
-const { EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
-const CommandOptions = require('../util/CommandOptionTypes').CommandOptionTypes;
-
-module.exports = {
-  name: "debug",
-  debug: true,
-  global: false,
-  description: "debugging...",
-  usage: "",
-  permissions: {
-    channel: ["VIEW_CHANNEL", "SEND_MESSAGES", "EMBED_LINKS"],
-    member: [],
-  },
-  options: [],
-  SlashCommand: {
-    /**
-     *
-     * @param {require("../structures/QuarksBot")} client
-     * @param {import("discord.js").Message} message
-     * @param {string[]} args
-     * @param {*} param3
-    */
-    run: async (client, interaction, args, { GuildDB }) => {
-      if (!client.config.Admins.includes(interaction.member.user.id)) return interaction.send({ content: 'Only developers can access this command.', flags: (1 << 6) })
-      
-      return interaction.send({ content: `Hello ${interaction.member.user.id}, you are my creator!!` })
-    },
-  },
-  Interactions: {}
-}

commands/excluded.js

@@ -24,7 +24,7 @@ module.exports = {
         let noExcludes = new EmbedBuilder()
           .setColor(client.config.Colors.Default)
           .setTitle('Excluded Roles')
-          .setDescription('> There have been no configured channels');
+          .setDescription('> There have been no excluded roles');
 
         return interaction.send({ embeds: [noExcludes] });
       }

commands/help.js

@@ -133,17 +133,25 @@ module.exports = {
         return interaction.send({ embeds: [creditsEmbed] })
       } else if (args[0].name == 'stats') {
         const end = new Date().getTime();
+        
+        const totalGuilds = await client.shard.fetchClientValues("guilds.cache.size").then(results => {
+          return results.reduce((acc, guildCount) => acc + guildCount, 0);
+        });
+        
+        const totalUsers = await client.shard.broadcastEval(c => {
+          c.guilds.cache.reduce((acc, guild) => acc + guild.memberCount, 0);
+        }).then(data => data.reduce((acc, memberCount) => acc + memberCount, 0));
+        
         const stats = new EmbedBuilder()
           .setColor(client.config.Colors.Default)
           .setTitle('DayZ Reforger Bot Statistics')
           .addFields(
-            { name: 'Guilds', value: `${client.guilds.cache.size}`, inline: true },
+            { name: 'Guilds',          value: `\`\`\`${totalGuilds}\`\`\``,                                       inline: true },
-            { name: 'Users', value: `${client.users.cache.size}`, inline: true },
+            { name: 'Users',           value: `\`\`\`${totalUsers}\`\`\``,                                        inline: true },
-            { name: 'Latency', value: `${end - start}ms`, inline: true },
+            { name: 'Latency',         value: `\`\`\`${end - start}ms\`\`\``,                                     inline: true },
-            { name: 'Uptime', value: `${client.secondsToDhms(process.uptime().toFixed(2))}`, inline: true },
+            { name: 'Uptime',          value: `\`\`\`${client.secondsToDhms(process.uptime().toFixed(2))}\`\`\``, inline: true },
-            { name: 'Bot Version', value: `${client.config.Dev} v${client.config.Version}`, inline: true },
+            { name: 'Bot Version',     value: `\`\`\`${client.config.Dev} v${client.config.Version}\`\`\``,       inline: true },
-            { name: 'Discord Version', value: `Discord.js ${package.dependencies["discord.js"]}`, inline: true },
+            { name: 'Discord Version', value: `\`\`\`Discord.js ${package.dependencies["discord.js"]}\`\`\``,     inline: true },
-            { name: 'MongoDB Version', value: `MongoDB    ${package.dependencies.mongodb}`, inline: true},
           );
 
         return interaction.send({ embeds: [stats] })

commands/server.js

@@ -1,7 +1,7 @@
 const { EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, ModalBuilder, TextInputBuilder, TextInputStyle } = require('discord.js');
 const CommandOptions = require('../util/CommandOptionTypes').CommandOptionTypes;
 const bitfieldCalculator = require('discord-bitfield-calculator');
-const { BanPlayer, UnbanPlayer, RestartServer, CheckServerStatus, DisableBaseDamage, DisableContainerDamage } = require('../util/NitradoAPI');
+const { BanPlayer, UnbanPlayer, RestartServer, CheckServerStatus, DisableBaseDamage, DisableContainerDamage, NitradoCredentialStatus } = require('../util/NitradoAPI');
 const { encrypt, decrypt } = require('../util/Cryptic');
 
 module.exports = {
@@ -20,6 +20,24 @@ module.exports = {
     value: "initialize",
     type: CommandOptions.SubCommand,
   },
+  {
+    name: "disconnect",
+    description: "Delete your Nitrado server from the bot database",
+    value: "disconnect",
+    type: CommandOptions.SubCommand,
+  },
+  {
+    name: "credentials-status",
+    description: "Check the status of your Nitrado Credentials",
+    value: "credentials-status",
+    type: CommandOptions.SubCommand,
+  },
+  {
+    name: "retry-credentials",
+    description: "If your credentials are marked as FAILED, try retreiving Nitrado logs again.",
+    value: "retry-credentials",
+    type: CommandOptions.SubCommand,
+  },
   {
     name: "ban-player",
     description: "Ban a player from the DayZ server",
@@ -150,11 +168,55 @@ module.exports = {
 
         return interaction.showModal(NitradoCredentials);
 
+      } else if (args[0].name == 'disconnect') {
+
+        const prompt = new EmbedBuilder()
+          .setTitle(`Delete your Nitrado Server?`)
+          .setDescription('**Notice:** This will completely delete your configured Nitrado server from the bot database.')
+          .setColor(client.config.Colors.Yellow)
+
+        const opt = new ActionRowBuilder()
+          .addComponents(
+            new ButtonBuilder()
+            .setCustomId(`DeleteNitrado-yes-${interaction.member.user.id}`)
+              .setLabel("Yes")
+              .setStyle(ButtonStyle.Danger),
+            new ButtonBuilder()
+              .setCustomId(`DeleteNitrado-no-${interaction.member.user.id}`)
+              .setLabel("No")
+              .setStyle(ButtonStyle.Success)
+          )
+
+        return interaction.send({ embeds: [prompt], components: [opt], flags: (1 << 6) });
       }
       
       if (!client.exists(GuildDB.Nitrado) || !client.exists(GuildDB.Nitrado.ServerID)) return interaction.send({ embeds: [new EmbedBuilder().setColor(client.config.Colors.Red).setDescription(`**Notice:**\nThis Discord guild has not been configured with a Nitrado DayZ server. To configure your guild, use </server initialize:1166877457559851011>`)] });
 
-      if (args[0].name == 'ban-player') {
+      if (args[0].name == 'credentials-status') {
+
+        const ok = GuildDB.Nitrado.Status == NitradoCredentialStatus.OK;
+        const notice = ok ? "Your provided Nitrado Credentials are working correctly, logs are being checked." : "Your provided Nitrado Credentials are not working. They may be incorrect, or your server may be down. Ensure your DayZ server is online, and try to initialize your server again and verify your credentials are correct."
+        const statusEmbed = new EmbedBuilder()
+          .setColor(ok ? client.config.Colors.Green : client.config.Colors.Red)
+          .setTitle("Nitrado Credentials Status")
+          .setDescription(`**Status:** \`${GuildDB.Nitrado.Status}\`\n> ${notice}`);
+
+        return interaction.send({ embeds: [statusEmbed] });
+
+      } else if (args[0].name == 'retry-credentials') {
+
+        client.dbo.collection("guilds").updateOne({"server.serverID": GuildDB.serverID}, {$set:{"Nitrado.Status": NitradoCredentialStatus.OK}}, (err, _) => {
+          if (err) return client.sendInternalError(interaction, err);
+        });
+
+        const updatedEmbed = new EmbedBuilder()
+          .setColor(client.config.Colors.Green)
+          .setTitle("Updated Nitrado Credentials Status")
+          .setDescription(`**Success**\n> Successfully retrying your existing Nitrado Credentials to check DayZ logs.`);
+
+        return interaction.send({ embeds: [updatedEmbed] });
+
+      } else if (args[0].name == 'ban-player') {
 
         let data = await BanPlayer(GuildDB.Nitrado, client, args[0].options[0].value);
 
@@ -260,6 +322,7 @@ module.exports = {
                       client.key,
                       client.encryptionIV
                     ), // Encrypt the Authentication Token
+          Status:   NitradoCredentialStatus.OK, // Indicate if these credentials dont work
         };
 
         await client.dbo.collection('guilds').updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "Nitrado": Nitrado } }, (err, res) => {
@@ -312,7 +375,40 @@ module.exports = {
           return interaction.update({ embeds: [], components: [], content: 'Cancelled Overwriting Nitrado Server Information', flags: (1 << 6) });
         }
       }
+    },
+
+    DeleteNitrado: {
+      run: async(client, interaction, GuildDB) => {
+        if (!interaction.customId.endsWith(interaction.member.user.id))
+          return interaction.reply({ content: 'This interaction is not for you', flags: (1 << 6) });
+
+        if (interaction.customId.split('-')[1] == 'yes') {
+          await client.dbo.collection('guilds').updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "Nitrado": null } }, (err, _) => {
+            if (err) client.sendInternalError(interaction, err);
+          });
+
+          return interaction.update({
+            embeds: [
+              new EmbedBuilder()
+                .setColor(client.config.Colors.Green)
+                .setDescription(`**Success**\n> Successfully removed your Nitrado credentials from the database.`)
+            ],
+            components: [],
+            flags: (1 << 6)
+          });
+        } else {
+          return interaction.update({
+            embeds: [
+              new EmbedBuilder()
+                .setColor(client.config.Colors.Green)
+                .setDescription(`**Cancelled**\n> Your Nitrado credentials were not removed from the database.`)
+            ],
+            components: [],
+            flags: (1 << 6)
+          });
         }
+      }
+    },
 
   }
 }

database/guild.js

@@ -37,6 +37,7 @@ module.exports = {
       factionArmbands:       guild.server.factionArmbands,
       usedArmbands:          guild.server.usedArmbands,
       excludedRoles:         guild.server.excludedRoles,
+      hasExcludedRoles:      guild.server.excludedRoles.length > 0 ? true : false,
       botAdminRoles:         guild.server.botAdminRoles,
             
       alarms:                guild.server.alarms,

index.js

@@ -1,33 +1,8 @@
-const DayzR = require('./src/DayzRBot');
+const { ShardingManager } = require('discord.js');
 const config = require('./config/config');
-const { GatewayIntentBits } = require('discord.js');
 
-const path = require("path");
+const manager = new ShardingManager('./bot.js', { token: config.Token });
-const fs = require('fs');
-const { HandleActivePlayersList } = require('./util/LogsHandler');
 
-// Log all uncaught exceptions before killing process.
+manager.on('shardCreate', shard => console.log(`Launched shard ${shard.id}`));
-process.on('uncaughtException', async (error) => {
-	console.trace(error);
-	let d = new Date();
-	// Asynchronously write the error message to a log file using Promises
-	await new Promise((resolve, reject) => {
-		if (HandleActivePlayersList.lastSendMessage) HandleActivePlayersList.lastSendMessage.delete().catch(error => client.sendError(channel, `HandleActivePlayersList Error: \n${error}`));  // Remove previous embed message before closing
-		fs.appendFile(path.join(__dirname, "./logs/Logs.log"), 
-		`{"level":"error","message":"${d.getHours()}:${d.getMinutes()} - ${d.getMonth()+1}:${d.getDate()}:${d.getFullYear()} | uncaughtException: ${error.stack}"}`, (logErr) => {
-			if (logErr) {
-				console.error('Error writing uncaughtException to log file:', logErr);
-				reject(logErr);
-				process.exit()
-			} else {
-				resolve();
-			}
-		});
-	});
 
-	// Now gracefully close the program
+manager.spawn();
-	process.exit()
-});
-
-let client = new DayzR({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.GuildMembers] }, config);
-client.build()

package.json

@@ -1,6 +1,6 @@
 {
   "name": "dayzr-bot",
-  "version": "13.2.0",
+  "version": "13.3.21",
   "description": "A General Purpose Discord Bot for DayZ Nitrado Servers.",
   "main": "index.js",
   "nodemonConfig": {

src/DayzRBot.js

@@ -6,11 +6,12 @@ const Logger = require("../util/Logger");
 const crypto = require('crypto');
 
 // custom util imports
-const { DownloadNitradoFile, CheckServerStatus, FetchServerSettings, PostServerSettings } = require('../util/NitradoAPI');
+const { DownloadNitradoFile, CheckServerStatus, FetchServerSettings, PostServerSettings, NitradoCredentialStatus } = require('../util/NitradoAPI');
 const { HandlePlayerLogs, HandleActivePlayersList } = require('../util/LogsHandler');
 const { HandleKillfeed, UpdateLastDeathDate } = require('../util/KillfeedHandler');
 const { HandleExpiredUAVs, HandleEvents, PlaceFireplaceInAlarm } = require('../util/AlarmsHandler');
 const { decrypt } = require('../util/Cryptic');
+const { GetWebhook, WebhookSend } = require("../util/WebhookHandler");
 
 // Data structures imports
 const { getDefaultPlayer, UpdatePlayer } = require('../database/player');
@@ -66,12 +67,15 @@ class DayzRBot extends Client {
 
     this.db;
     this.dbo;
+
     this.databaseConnected = false;
     this.arInterval        = arInterval;
     this.arIntervalIds     = new Map();
     this.playerSessions    = new Map();
     this.logHistory        = new Map();
     this.alarmPingQueue    = new Map();
+    this.playerListMsgIds  = new Map();
+
     this.initialize();
     this.LoadCommandsAndInteractionHandlers();
     this.LoadEvents();
@@ -99,18 +103,16 @@ class DayzRBot extends Client {
         // Free unused armbands for related commands
         if (['armbands', 'claim', 'factions'].includes(command)) {
           for (const [factionID, data] of Object.entries(GuildDB.factionArmbands)) {
-            const guild = client.guilds.cache.get(GuildDB.serverID);
+            const guild = this.guilds.cache.get(GuildDB.serverID);
             const role = guild.roles.cache.find(role => role.id == factionID);
             if (!role) {
               let query = {
                 $pull: { 'server.usedArmbands': data.armband },
                 $unset: { [`server.factionArmbands.${factionID}`]: "" },
               };
-              await client.dbo.collection("guilds").updateOne({ 'server.serverID': GuildDB.serverID }, query, (err, res) => {
+              this.dbo.collection("guilds").updateOne({ 'server.serverID': GuildDB.serverID }, query, (err, res) => {
-                if (err) return client.sendInternalError(interaction, err);
+                if (err) return this.sendInternalError(interaction, err);
               });
-            } else {
-              newFactionArmbands[`${factionID}`] = data;
             }
           }
         }
@@ -215,17 +217,25 @@ class DayzRBot extends Client {
     const maxEmbed = 10;
 
     this.alarmPingQueue.forEach(queue => {
-      queue.forEach((data, channel_id) => {
+      queue.forEach(async (data, channel_id) => {
         const channel = this.GetChannel(channel_id);
         if (!channel) return;
-        data.forEach((embeds, role) => {
+
+        const NAME = "DayZ.R Zone Alert";
+        const webhook = await GetWebhook(this, NAME, channel_id);   
+
+        data.forEach(async (embeds, role) => {
           let embedArrays = [];
           while (embeds.length > 0);
             embedArrays.push(embeds.splice(0, maxEmbed));
 
           for (let i = 0; i < embedArrays.length; i++) { 
-            if (role == '-no-role-ping-') channel.send({ embeds: embedArrays[i] });
+            let content = { embeds: embedArrays[i] };
-            else channel.send({ content: `<@&${role}>`, embeds: embedArrays[i] });
+            if (role != '-no-role-ping-') content.content = `<@&${role}>`;
+            WebhookSend(this, webhook, content);
+            
+            // if (role == '-no-role-ping-') channel.send({ embeds: embedArrays[i] });
+            // else channel.send({ content: `<@&${role}>`, embeds: embedArrays[i] });
           }
         });
       });
@@ -308,6 +318,7 @@ class DayzRBot extends Client {
       */
 
       if (!c.exists(GuildDB.Nitrado)) return; // Continue if no nitrado credentials
+      if (GuildDB.Nitrado.Status == NitradoCredentialStatus.FAILED) return; // Continue if these credentials are marked as failed
 
       const NitradoCred = {
         ServerID: GuildDB.Nitrado.ServerID, 
@@ -317,17 +328,22 @@ class DayzRBot extends Client {
           c.config.EncryptionMethod,
           c.key,
           c.encryptionIV
-        )
+        ),
       };
 
       const response = await FetchServerSettings(NitradoCred, c, "logsUpdateTimer").then(res => res);
-      if (response == 1) return;
+      if (response == 1) {
+        c.dbo.collection("guilds").updateOne({"server.serverID": GuildDB.serverID }, {$set: { "Nitrado.Status": NitradoCredentialStatus.FAILED }}, (err, _) => {
+          if (err) this.error(`Failed to update Nitrado status to failed. [${GuildDB.serverID}]`);
+        });
+        return;
+      };
       const settings = response.data.gameserver;
 
       // Update Nitrado DayZ Mission if change is detected
       if (GuildDB.Nitrado.Mission !== Missions[settings.settings.config.mission]) {
         c.dbo.collection("guilds").updateOne({"server.serverID": GuildDB.serverID}, {$set: { "Nitrado.Mission": Missions[settings.settings.config.mission] }}, (err, res) => {
-          if (err) this.error(`Failed to save mission to guild config [${guild.serverID}] for nitrado server [${guild.Nitrado.ServerID}]`);
+          if (err) this.error(`Failed to save mission to guild config [${GuildDB.serverID}] for nitrado server [${GuildDB.Nitrado.ServerID}]`);
         });
       }
 
@@ -381,7 +397,9 @@ class DayzRBot extends Client {
       this.databaseConnected = true;
     } catch (err) {
       databaselogs.attempts++; 
-      let db = (mongoURI.includes("@") ? mongoURI.split("@")[1] : mongoURI.split("//")[1]).endsWith("/") ? mongoURI.slice(0, -1) : mongoURI;
+      databaselogs.connected = false; 
+      let db = mongoURI.includes("@") ? mongoURI.split("@")[1] : mongoURI.split("//")[1];
+      db = db.includes("/") ? db.split("/")[0] : db;
       this.error(`Failed to connect to mongodb (mongodb://${db}/${dbo}): attempt ${databaselogs.attempts} - ${err}`);
       failed = true;
     }
@@ -396,6 +414,7 @@ class DayzRBot extends Client {
     // Wait for MongoDB to connect
     await this.connectMongo(this.config.mongoURI, this.config.dbo);
 
+    if (!this.databaseConnected) return;
     let guilds = await this.dbo.collection("guilds").find({}).toArray();
    
     /*
@@ -420,6 +439,8 @@ class DayzRBot extends Client {
       }
       this.logHistory.set(guilds[i].Nitrado.ServerID, guilds[i].server.lastLog); // Using Nitrado Server ID over guild ID in case of future support for multiple nitrado servers in a single guild
       this.playerSessions.set(guilds[i].Nitrado.ServerID, new Map());            // Same reason here as named above.
+      this.alarmPingQueue.set(guilds[i].serverID, new Map());                    // Initialize alarm queue to be empty
+      this.playerListMsgIds.set(guilds[i].serverID, "");                         // Initialize player list message ids
       this.log(`[${guilds[i].server.serverID}] Initialized existing Nitrado`);
     }
   }

util/AdminLogsHandler.js

@@ -1,11 +1,13 @@
 const { EmbedBuilder } = require('discord.js');
 const { nearest } = require('../database/destinations');
+const { GetWebhook, WebhookSend } = require("../util/WebhookHandler");
 
 module.exports = {
 
   SendConnectionLogs: async (client, guild, data) => {
     if (!client.exists(guild.connectionLogsChannel)) return;
     const channel = client.GetChannel(guild.connectionLogsChannel);
+    if (!channel) return;
   
     let newDt = await client.getDateEST(data.time);
     let unixTime = Math.floor(newDt.getTime() / 1000);
@@ -14,6 +16,9 @@ module.exports = {
       .setColor(data.connected ? client.config.Colors.Green : client.config.Colors.Red)
       .setDescription(`**${data.connected ? 'Connect' : 'Disconnect'} Event - <t:${unixTime}>\n${data.player} ${data.connected ? 'Connected' : 'Disconnected'}**`);
 
+    const NAME = "DayZ.R Admin Logs";
+    const webhook = await GetWebhook(client, NAME, guild.connectionLogsChannel);
+
     if (!data.connected) {
       if (data.lastConnectionDate != null) {
         let oldUnixTime = Math.floor(data.lastConnectionDate.getTime() / 1000);
@@ -22,17 +27,20 @@ module.exports = {
       } else connectionLog.addFields({ name: '**Session Time**', value: `**Unknown**`, inline: false });
     }
 
-    if (client.exists(channel)) await channel.send({ embeds: [connectionLog] });
+    // if (client.exists(channel)) await channel.send({ embeds: [connectionLog] });
+    await WebhookSend(client, webhook, {embeds: [connectionLog]});
   },
 
   DetectCombatLog: async (client, guild, data) => {
     if (!client.exists(data.lastDamageDate)) return;
     if (!client.exists(guild.connectionLogsChannel)) return;
+    const channel = client.GetChannel(guild.connectionLogsChannel);
+    if (!channel) return; // Ensure channel exists
 
     const newDt = await client.getDateEST(data.time);
     const diffSeconds = Math.round((newDt.getTime() - data.lastDamageDate.getTime()) / 1000);
 
-    // If diff is greater than 5 minutes, not a combat log
+    // If diff is greater than configured time in minutes, not a combat log
     // or if death after last combat
     if (diffSeconds > (data.combatLogTimer * 60)) return;
     if (data.lastDamageDate <= data.lastDeathDate) return;
@@ -42,9 +50,6 @@ module.exports = {
     let attacker = await client.dbo.collection("players").findOne({"gamertag": data.lastHitBy});
     if (attacker.lastDeathDate > data.lastDamageDate) return;    
 
-    const channel = client.GetChannel(guild.connectionLogsChannel);
-    if (!channel) return;
-
     let unixTime = Math.floor(newDt.getTime() / 1000);
     const destination = nearest(data.pos, guild.Nitrado.Mission);
 
@@ -52,8 +57,12 @@ module.exports = {
       .setColor(client.config.Colors.Red)
       .setDescription(`**NOTICE:**\n**${data.player}** has combat logged at <t:${unixTime}> when fighting **${data.lastHitBy}\nLocation [${data.pos[0]}, ${data.pos[1]}](https://www.izurvive.com/chernarusplussatmap/#location=${data.pos[0]};${data.pos[1]})**\n${destination}`);
 
-    if (client.exists(guild.adminRole)) channel.send({ content: `<@&${guild.adminRole}>` });
+    const NAME = "DayZ.R Admin Logs";
+    const webhook = await GetWebhook(client, NAME, guild.connectionLogsChannel);
     
-    return channel.send({ embeds: [combatLog] });
+    let content = { embeds: [combatLog] };
+    if (client.exists(guild.adminRole)) content.content = `<@&${guild.adminRole}>`;
+    WebhookSend(client, webhook, content);
+    // return channel.send({ embeds: [combatLog] });
   }
 };

util/AlarmsHandler.js

@@ -2,6 +2,7 @@ const { BanPlayer, UnbanPlayer } = require('./NitradoAPI');
 const { EmbedBuilder } = require('discord.js');
 const { nearest } = require('../database/destinations');
 const { GetGuild } = require('../database/guild');
+const { GetWebhook, WebhookSend } = require("../util/WebhookHandler");
 
 // Private functions (only called locally)
 
@@ -20,6 +21,10 @@ const ExpireEvent = async(client, guild, e) => {
 }
 
 const HandlePlayerTrackEvent = async (client, guild, e) => {
+  if (!client.exists(e.channel)) return ExpireEvent(client, guild, e); // Expire event since it has invalid channel.
+  const channel = client.GetChannel(e.channel);
+  if (!channel) return;
+
   let player = await client.dbo.collection("players").findOne({"gamertag": e.gamertag});
 
   let newDt = await client.getDateEST(player.time);
@@ -31,10 +36,15 @@ const HandlePlayerTrackEvent = async (client, guild, e) => {
     .setColor(client.config.Colors.Default)
     .setDescription(`**${e.name} Event**\n${e.gamertag} was located at **[${player.pos[0]}, ${player.pos[1]}](https://www.izurvive.com/chernarusplussatmap/#location=${player.pos[0]};${player.pos[1]})** at <t:${unixTime}>\n${destination}`);
 
-  if (!client.exists(e.channel)) return ExpireEvent(client, guild, e); // Expire event since it has invalid channel.
+  const NAME = "DayZ.R Player Tracker";
-  const channel = client.GetChannel(e.channel);
+  const webhook = await GetWebhook(client, NAME, e.channel);
-  if (e.role) channel.send({ content: `<@&${e.role}>`, embeds: [trackEvent] });
+
-  else channel.send({ embeds: [trackEvent] });
+  let content = { embeds: [trackEvent] };
+  if (client.exists(guild.adminRole)) content.content = `<@&${e.role}>`;
+  WebhookSend(client, webhook, content);
+
+  // if (e.role) channel.send({ content: `<@&${e.role}>`, embeds: [trackEvent] });
+  // else channel.send({ embeds: [trackEvent] });
 
   let now = new Date();
   let diff = ((now - e.creationDate) / 1000) / 60;
@@ -157,6 +167,7 @@ module.exports = {
 
       if (distance < alarm.radius) {
         const channel = client.GetChannel(alarm.channel);
+        if (!channel) continue;
 
         let newDt = await client.getDateEST(data.time);
         let unixTime = Math.floor(newDt.getTime()/1000);
@@ -166,7 +177,13 @@ module.exports = {
           .setDescription(`**Zone Ping - <t:${unixTime}>**\n**${data.killer}** was located within **${distance} meters** of the Zone **${alarm.name}** __and has been banned for killing **${data.victim}**.__`)
           .addFields({ name: '**Location**', value: `**[${data.killerPOS[0]}, ${data.killerPOS[1]}](https://www.izurvive.com/chernarusplussatmap/#location=${data.killerPOS[0]};${data.killerPOS[1]})**`, inline: false })
       
-        channel.send({ content: `<@&${alarm.role}>`, embeds: [alarmEmbed] });
+        const NAME = "DayZ.R Zone Alert";
+        const webhook = await GetWebhook(client, NAME, alarm.channel);
+        
+        let content = { content: `<@&${alarm.role}>`, embeds: [alarmEmbed] };
+        WebhookSend(client, webhook, content);
+
+        // channel.send({ content: `<@&${alarm.role}>`, embeds: [alarmEmbed] });
 
         BanPlayer(client, data.killer);
         break;
@@ -198,6 +215,7 @@ module.exports = {
 
       if (distance < alarm.radius) {
         const channel = client.GetChannel(alarm.channel);
+        if (!channel) return;
 
         let newDt = await client.getDateEST(info.time);
         let unixTime = Math.floor(newDt.getTime()/1000);
@@ -207,7 +225,13 @@ module.exports = {
           .setDescription(`**Zone Ping - <t:${unixTime}>**\n**${info.player}** was located within **${distance} meters** of the Zone **${alarm.name}** __and has been banned for **placing a fireplace**.__`)
           .addFields({ name: '**Location**', value: `**[${info.playerPOS[0]}, ${info.playerPOS[1]}](https://www.izurvive.com/chernarusplussatmap/#location=${info.playerPOS[0]};${info.playerPOS[1]})**`, inline: false })
       
-        channel.send({ content: `<@&${alarm.role}>`, embeds: [alarmEmbed] });
+        const NAME = "DayZ.R Zone Alert";
+        const webhook = await GetWebhook(client, NAME, alarm.channel);
+        
+        let content = { content: `<@&${alarm.role}>`, embeds: [alarmEmbed] };
+        WebhookSend(client, webhook, content);
+
+        // channel.send({ content: `<@&${alarm.role}>`, embeds: [alarmEmbed] });
 
         BanPlayer(client, info.player);
         break;

util/KillfeedHandler.js

@@ -5,6 +5,7 @@ const { nearest } = require('../database/destinations');
 const { getDefaultPlayer, UpdatePlayer } = require('../database/player');
 const { calculateNewCombatRating } = require('./CombatRatingHandler');
 const { weapons, weaponClassOf } = require('../database/weapons');
+const { GetWebhook, WebhookSend } = require("../util/WebhookHandler");
 
 const Templates = {
   Killed:       1,
@@ -80,6 +81,7 @@ module.exports = {
 
   HandleKillfeed: async (NitradoServerID, client, guild, line) => {
   
+    const NAME = "DayZ.R Killfeed";
     const channel = client.GetChannel(guild.killfeedChannel);
     
     const killedBy = line.includes('hit by Player') && line.includes('(DEAD)') && line.includes('meters') ? Templates.HitByAndDead :
@@ -133,6 +135,11 @@ module.exports = {
     if (killedBy == Templates.LandMine || killedBy == Templates.Explosion || killedBy == Templates.Vehicle) {
       let victimStat = await client.dbo.collection("players").findOne({"playerID": info.victimID});
       if (!client.exists(victimStat)) victimStat = getDefaultPlayer(info.victim, info.victimID, NitradoServerID);
+      victimStat.deaths++;
+      victimStat.deathStreak++;
+      victimStat.worstDeathStreak = victimStat.deathStreak > victimStat.worstDeathStreak ? victimStat.deathStreak : victimStat.worstDeathStreak;
+      victimStat.KDR = victimStat.kills / (victimStat.deaths == 0 ? 1 : victimStat.deaths); // prevent division by 0
+      victimStat.killStreak = 0;
       victimStat.lastDeathDate = newDt;
       
       const cod = killedBy == Templates.LandMine ? `Land Mine Trap` : 
@@ -144,9 +151,14 @@ module.exports = {
         .setColor(client.config.Colors.Default)
         .setDescription(`**Death Event** - <t:${unixTime}>\n**${info.victim}** ${killMessage} a **${cod}.**${coord}`);
 
-      if (client.exists(channel)) await channel.send({ embeds: [killEvent] });
       await UpdatePlayer(client, victimStat);
-      return
+      
+      if (!channel) return;
+      const webhook = await GetWebhook(this, NAME, guild.killfeedChannel);
+      WebhookSend(client, webhook, { embeds: [killEvent]});
+
+      // if (client.exists(channel)) await channel.send({ embeds: [killEvent] });
+      return;
     }
 
     KillInAlarm(client, guild.serverID, info); // check if kill happened in a no kill zone
@@ -263,8 +275,15 @@ module.exports = {
       killEvent.setThumbnail(weapons[weaponClass][weapon])
     }
     
-    if (client.exists(channel)) await channel.send({ embeds: [killEvent] });
+    if (!channel) return;
-    if (client.exists(receivedBounty) && client.exists(channel)) await channel.send({ content: `<@${killerStat.discordID}>`, embeds: [receivedBounty] });
+
+    const webhook = await GetWebhook(this, NAME, guild.killfeedChannel);
+
+    WebhookSend(client, webhook, { embeds: [killEvent] });
+    if (client.exists(receivedBounty) && client.exists(channel)) WebhookSend(client, webhook, { content: `<@${killerStat.discordID}>`, embeds: [receivedBounty] });
+
+    // if (client.exists(channel)) await channel.send({ embeds: [killEvent] });
+    // if (client.exists(receivedBounty) && client.exists(channel)) await channel.send({ content: `<@${killerStat.discordID}>`, embeds: [receivedBounty] });
     
     return;
   }

util/LogsHandler.js

@@ -5,8 +5,7 @@ const { getDefaultPlayer } = require('../database/player');
 const { FetchServerSettings } = require('../util/NitradoAPI');
 const { UpdatePlayer, insertPVPstats, createWeaponStats } = require('../database/player')
 const { Missions } = require('../database/destinations');
-
+const { GetWebhook, WebhookSend, WebhookMessageEdit } = require("../util/WebhookHandler");
-let lastSendMessage;
 
 module.exports = {
 
@@ -208,6 +207,7 @@ module.exports = {
 
     if (!client.exists(guild.activePlayersChannel)) return;
     const channel = client.GetChannel(guild.activePlayersChannel);
+    if (!channel) return;
 
     const data = await FetchServerSettings(nitrado_cred, client, 'HandleActivePlayersList');  // Fetch server status
     const e = data && data !== 1; // Check if data exists
@@ -251,10 +251,15 @@ module.exports = {
       .setTitle(`Players Online:`)
       .setDescription(des || (nodes ? "No Players Online :(" : ""));
       
-    if (lastSendMessage) lastSendMessage.delete().catch(error => client.sendError(channel, `HandleActivePlayersList Error: \n${error}`));  // Remove previous message before reprinting
+    const NAME = "DayZ.R Admin Logs";
+    const webhook = await GetWebhook(client, NAME, guild.connectionLogsChannel);
     
-    return channel.send({ embeds: [serverEmbed, activePlayersEmbed] }).then(sentMessage =>
+    let id = client.playerListMsgIds.get(guild.serverID);
-      lastSendMessage = sentMessage
+    if (id == "") {
-    );
+      id = await WebhookSend(client, webhook, { embeds: [serverEmbed, activePlayersEmbed] }).id;
+      client.playerListMsgIds.set(guild.serverID, id);
+    } else {
+      WebhookMessageEdit(client, webhook, id, { embeds: [serverEmbed, activePlayersEmbed] });
+    }
   }
 };

util/NitradoAPI.js

@@ -301,5 +301,10 @@ module.exports = {
     if (uploaded == 1) return 1;
    
     return 0;
-  }
+  },
+
+  NitradoCredentialStatus: {
+    FAILED:  "FAILED",
+    OK:      "OK",
+  },
 }

util/WebhookHandler.js

@@ -0,0 +1,56 @@
+const { makeURLSearchParams } = require('@discordjs/rest');
+const { REST } = require('@discordjs/rest');
+const { Routes } = require('discord.js');
+
+const createWebhook = async (client, channel_id, name, avatar) => {
+  const rest = new REST({ version: '10' }).setToken(client.config.Token);
+  return await rest.post(Routes.channelWebhooks(channel_id), {
+    body: {
+      name: name,
+      avatar: avatar
+    }
+  });
+};
+
+module.exports = {
+  GetWebhook: async (client, webhookName, channel_id) => {
+    // Get all webhooks from configured channel
+    const rest = new REST({ version: '10' }).setToken(client.config.Token);
+    const webhooks = await rest.get(Routes.channelWebhooks(channel_id));
+
+    let webhook = null;
+    if (webhooks.length == 0) {
+      // If no webhook exists, create new webhook with given name for this channel
+      webhook = createWebhook(client, channel_id, webhookName, client.config.AvatarData);
+    } else {
+      // Check existing webhooks for one with given name
+      let exists = false;
+      for (let i = 0; i < webhooks.length; i++) {
+        if (webhooks[i].name == webhookName) {
+          webhook = webhooks[i];
+          exists = true;
+          break;
+        }
+      }
+
+      if (!exists) webhook = createWebhook(client, channel_id, webhookName, client.config.AvatarData);
+    }
+
+    return webhook;
+  },
+
+  WebhookSend: async (client, webhook, content) => {
+    const rest = new REST({ version: '10' }).setToken(client.config.Token);
+    return await rest.post(Routes.webhook(webhook.id, webhook.token), {
+      body: content,
+      query: makeURLSearchParams({ wait: true })
+    });
+  },
+
+  WebhookMessageEdit: async (client, webhook, message_id, content) => {
+    const rest = new REST({ version: '10' }).setToken(client.config.Token);
+    return rest.patch(Routes.webhookMessage(webhook.id, webhook.token, message_id), {
+      body: content
+    });
+  }
+}