264 lines
8.4 KiB
JavaScript
264 lines
8.4 KiB
JavaScript
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const { Client, Events, GatewayIntentBits, Collection } = require('discord.js');
|
|
const { joinVoiceChannel, getVoiceConnection, entersState, VoiceConnectionStatus, EndBehaviorType } = require('@discordjs/voice')
|
|
const { token, media_voice_folder } = require('./config.json');
|
|
const sqlutil = require('./utilities/sqlutil');
|
|
const { Console } = require('node:console');
|
|
const prism = require('prism-media')
|
|
|
|
sqlutil.buildPool()
|
|
|
|
const getAllFiles = function(directoryPath, arrayOfFiles) {
|
|
const files = fs.readdirSync(directoryPath);
|
|
|
|
arrayOfFiles = arrayOfFiles || [];
|
|
|
|
files.forEach(file => {
|
|
if (fs.statSync(directoryPath + path.sep + file).isDirectory()) {
|
|
arrayOfFiles = getAllFiles(directoryPath + path.sep + file, arrayOfFiles);
|
|
}
|
|
else {
|
|
arrayOfFiles.push(path.join(__dirname, directoryPath, path.sep, file));
|
|
}
|
|
});
|
|
|
|
return arrayOfFiles;
|
|
};
|
|
|
|
const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.GuildMembers, GatewayIntentBits.MessageContent, GatewayIntentBits.GuildVoiceStates] });
|
|
|
|
client.commands = new Collection();
|
|
|
|
var activeCalls = []
|
|
|
|
getAllFiles('.' + path.sep + 'commands', [])
|
|
.filter(file => file.endsWith('.js'))
|
|
.forEach(file => {
|
|
const command = require(file);
|
|
|
|
if ('enabled' in command && command.enabled && 'data' in command && 'execute' in command) {
|
|
client.commands.set(command.data.name, command);
|
|
console.log(`[INFO] Loaded command at ${file}`);
|
|
}
|
|
else {
|
|
console.log(`[WARNING] The command at ${file} is missing a required "data" or "execute" property or is not enabled.`);
|
|
}
|
|
});
|
|
|
|
client.on(Events.InteractionCreate, async interaction => {
|
|
if (!interaction.isChatInputCommand()) return;
|
|
|
|
const command = interaction.client.commands.get(interaction.commandName);
|
|
|
|
if (!command) {
|
|
console.error(`No command matching ${interaction.commandName} was found.`);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
await command.execute(interaction);
|
|
}
|
|
catch (error) {
|
|
console.error(error);
|
|
await interaction.reply({ content: 'There was an error while executing this command!', ephemeral: true });
|
|
}
|
|
});
|
|
|
|
client.on(Events.GuildCreate, async guild => {
|
|
if (guild.available) {
|
|
console.log('Got into a server')
|
|
console.log(`The server name is ${guild.name}`)
|
|
console.log(`The server description is ${guild.description}`)
|
|
console.log(`The server snowflake is ${guild.id}`)
|
|
|
|
sqlutil.registerServerIfMissing(guild.id, guild.name, guild.description).then(server_added => {
|
|
if(server_added) {
|
|
console.log(`Server Added ${guild.name}`)
|
|
} else {
|
|
console.log(`Server failed to add ${guild.name}`)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
client.on(Events.VoiceStateUpdate, async (oldState, newState) => {
|
|
console.log("Voice State Update Fired")
|
|
|
|
if (oldState.channel == null && newState.channel != null) {
|
|
if (newState.member.id == client.user.id) {
|
|
return //If the user is breadbot, ignore and exit
|
|
}
|
|
|
|
console.log(`\tChannel Join Detected ${newState.guild.id} - ${newState.channelId} - ${newState.member.id}`)
|
|
|
|
var existingCallID = await sqlutil.inCall(newState.guild.id, newState.channelId)
|
|
|
|
console.log(`\tExisting call ID ${existingCallID}`)
|
|
|
|
if (existingCallID == -1) {
|
|
console.log("\tJoining a call")
|
|
|
|
var newCallID = await sqlutil.registerNewCall(newState.guild.id, newState.channelId, new Date())
|
|
existingCallID = newCallID // To ensure all the stuff that happens after call creation works
|
|
|
|
console.log(`\tNext call ID ${newCallID}`)
|
|
|
|
// This should always have something to do, as all callIDs should be unique
|
|
fs.mkdirSync(media_voice_folder + path.sep + newCallID, {recursive: true})
|
|
|
|
const connection = joinVoiceChannel({
|
|
channelId: newState.channelId,
|
|
guildId: newState.guild.id,
|
|
selfDeaf: false,
|
|
selfMute: true,
|
|
adapterCreator: newState.guild.voiceAdapterCreator
|
|
})
|
|
|
|
try {
|
|
// What the hell does 20e3 mean, is that supposed to be sci notation?
|
|
await entersState(connection, VoiceConnectionStatus.Ready, 20e3)
|
|
const receiver = connection.receiver
|
|
|
|
receiver.speaking.on("start", (user_id) => {
|
|
receiver.subscribe(user_id, {
|
|
end: {
|
|
behavior: EndBehaviorType.AfterSilence,
|
|
duration: 2500
|
|
}
|
|
})
|
|
.pipe(new prism.opus.OggLogicalBitstream({
|
|
opusHead: new prism.opus.OpusHead({
|
|
channelCount: 2,
|
|
sampleRate: 48000
|
|
}),
|
|
pageSizeControl: {
|
|
maxPackets: 10
|
|
}
|
|
}))
|
|
.pipe(fs.createWriteStream(media_voice_folder + path.sep + newCallID + path.sep + `${Date.now()}-${user_id}.ogg`))
|
|
|
|
})
|
|
|
|
receiver.speaking.on("end", (user_id) => {
|
|
console.log(`User ${user_id} stopped speaking`)
|
|
})
|
|
} catch (error) {
|
|
console.warn(error)
|
|
}
|
|
}
|
|
|
|
var userRegistered = await sqlutil.registerUserIfMissing(newState.member.id, newState.member.username, newState.member.displayName)
|
|
|
|
if (userRegistered) {
|
|
var markedUserInCall = await sqlutil.registerUserInCall(existingCallID, newState.member.id)
|
|
|
|
if (!markedUserInCall) {
|
|
console.log(`Something went wrong when marking user in voice call: ${newState.member.id} - ${newState.channelId}`)
|
|
}
|
|
} else {
|
|
console.log(`Something went wrong when registering user for call: ${newState.member.id} - ${newState.member.username}`)
|
|
}
|
|
} else if (oldState.channel != null && newState.channel == null) {
|
|
if (oldState.member.id == client.user.id) {
|
|
return //If the user is breadbot, ignore and exit
|
|
}
|
|
|
|
console.log(`Channel Exit Detected ${oldState.guild.id} - ${oldState.channelId} - ${oldState.member.id}`)
|
|
|
|
var existingCallID = await sqlutil.inCall(oldState.guild.id, oldState.channelId)
|
|
|
|
console.log(`Existing call ID: ${existingCallID}`)
|
|
|
|
if (existingCallID != -1) {
|
|
await sqlutil.deregisterUserInCall(existingCallID, oldState.member.id)
|
|
|
|
var usersInCall = await sqlutil.getNumberUsersInCall(existingCallID)
|
|
|
|
if (usersInCall == 0) {
|
|
const connection = getVoiceConnection(oldState.guild.id)
|
|
connection.disconnect()
|
|
|
|
var didUpdateEndTime = await sqlutil.updateCallEndTime(existingCallID, new Date())
|
|
|
|
if (!didUpdateEndTime) {
|
|
console.log(`Failed to mark call id ${existingCallID} as ended with an end date`)
|
|
}
|
|
}
|
|
} else {
|
|
console.log("Couldn't find a call ID based on the guild and channel info, was Breadbot in the call?")
|
|
}
|
|
}
|
|
})
|
|
|
|
client.on(Events.MessageCreate, async message => {
|
|
console.log("Message Create Fired")
|
|
|
|
var channel_ok = await sqlutil.registerChannelIfMissing(message.channelId, message.channel.guild.id, message.channel.name)
|
|
var user_ok = await sqlutil.registerUserIfMissing(message.author.id, message.author.username, message.author.displayName)
|
|
|
|
console.log(`Channel OK? ${channel_ok}`)
|
|
console.log(`User OK? ${user_ok}`)
|
|
|
|
if (channel_ok && user_ok) {
|
|
await sqlutil.registerMessage(message.id, message.channelId, message.author.id, message.content, message.createdAt).then(async message_add => {
|
|
if(message_add) {
|
|
console.log("Message Added")
|
|
|
|
if (message.attachments.size != 0) {
|
|
const all_attachments = message.attachments.map(attachment => sqlutil.registerAttachmentIfMissing(
|
|
attachment.id,
|
|
message.id,
|
|
attachment.name,
|
|
attachment.description,
|
|
message.createdAt,
|
|
attachment.contentType,
|
|
attachment.url
|
|
))
|
|
|
|
await Promise.all(all_attachments).catch((error) => {
|
|
console.log(error)
|
|
})
|
|
}
|
|
} else {
|
|
console.log("Failed to log message")
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
client.on(Events.MessageUpdate, async (oldMessage, newMessage) => {
|
|
console.log("Message Update Fired")
|
|
console.log(`Old Message Snowflake: ${oldMessage.id}`)
|
|
console.log(`New Message Snowflake: ${newMessage.id}`)
|
|
|
|
await sqlutil.updateMessageContentIfPresent(newMessage.id, newMessage.content, newMessage.editedAt).then(async (updated) => {
|
|
if (updated) {
|
|
if (newMessage.attachments.size != 0) {
|
|
const all_attachments = newMessage.attachments.map(attachment => sqlutil.registerAttachmentIfMissing(
|
|
attachment.id,
|
|
newMessage.id,
|
|
attachment.name,
|
|
attachment.description,
|
|
newMessage.editedAt,
|
|
attachment.contentType,
|
|
attachment.url
|
|
))
|
|
|
|
await Promise.all(all_attachments).catch((error) => {
|
|
console.log(error)
|
|
})
|
|
}
|
|
}
|
|
})
|
|
})
|
|
|
|
client.on(Events.MessageDelete, async deletedMessage => {
|
|
await sqlutil.markMessageDeletedIfPresent(deletedMessage.id)
|
|
})
|
|
|
|
client.once(Events.ClientReady, c => {
|
|
console.log(`Ready! Logged in as ${c.user.tag} - ${c.user.id}`);
|
|
});
|
|
|
|
client.login(token); |