282 lines
11 KiB
JavaScript
282 lines
11 KiB
JavaScript
const { Setting } = require('../../../../interfaces/');
|
|
|
|
class MessageLogsSetting extends Setting {
|
|
|
|
constructor(client) {
|
|
|
|
super(client, {
|
|
name: 'messageLog',
|
|
module: 'moderation',
|
|
aliases: [
|
|
'chatLog',
|
|
'chatLogs',
|
|
'msgLogs',
|
|
'messageLogs',
|
|
'msgLog'
|
|
],
|
|
tags: ['log', 'logs', 'logging'],
|
|
usage: '<method|value> [value..]',
|
|
resolve: 'GUILD',
|
|
examples: [
|
|
'messagelogs roles <add|remove|list> <role>',
|
|
'messagelogs channels <add|remove|list> <role>',
|
|
'messagelogs reset',
|
|
'messagelogs off',
|
|
'messagelogs attachments <on|off>',
|
|
'messagelogs #channel'
|
|
],
|
|
default: {
|
|
messageLog: {
|
|
channel: null,
|
|
ignoredChannels: [],
|
|
ignoredRoles: [],
|
|
attachments: false,
|
|
webhook: null
|
|
}
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
async handle(message, params) {
|
|
|
|
// eslint-disable-next-line init-declarations
|
|
let index, changes, action;
|
|
// eslint-disable-next-line prefer-const
|
|
let [method, ...args] = params;
|
|
method = method.toLowerCase();
|
|
|
|
const setting = message.guild._settings[this.index] || this.default[this.index];
|
|
const { guild } = message;
|
|
|
|
if (['roles', 'role', 'ignoredrole', 'ignoredroles'].includes(method)) {
|
|
|
|
if (!args.length) return {
|
|
msg: message.format('MISSING_ARGS'),
|
|
error: true
|
|
};
|
|
const response = await this.resolveMethod(args, undefined, setting.ignoredRoles, guild.resolveRoles.bind(guild));
|
|
|
|
if (response) {
|
|
|
|
if (response.method === 'add') {
|
|
|
|
const roles = response.resolved;
|
|
if (!roles.length) return { error: true, msg: message.format('ERR_ROLERESOLVE') }
|
|
setting.ignoredRoles = [...setting.ignoredRoles, ...roles.filter((r) => !setting.ignoredRoles.includes(r.id)).map((r) => r.id)];
|
|
|
|
action = 'GENERAL_ADDED';
|
|
index = 'S_MESSAGELOG_ROLES';
|
|
changes = roles.map((r) => r.name);
|
|
|
|
} else if (response.method === 'remove') {
|
|
|
|
const roles = response.resolved;
|
|
if (!roles.length) return { error: true, msg: message.format('ERR_ROLERESOLVE') }
|
|
const _roles = roles.map((r) => r.id);
|
|
setting.ignoredRoles = setting.ignoredRoles.filter((r) => !_roles.includes(r));
|
|
|
|
action = 'GENERAL_REMOVED';
|
|
index = 'S_MESSAGELOG_ROLES';
|
|
changes = roles.map((r) => r.name);
|
|
|
|
} else if (response.method === 'list') {
|
|
|
|
const roles = await guild.resolveRoles(setting.ignoredRoles);
|
|
return {
|
|
msg: message.format('S_MESSAGELOG_ROLES_LIST', { roles: roles.map((r) => r.name).join(', ') })
|
|
};
|
|
|
|
}
|
|
|
|
} else {
|
|
return {
|
|
msg: message.format('ERR_INVALID_METHOD', { method }),
|
|
error: true
|
|
};
|
|
}
|
|
|
|
} else if (['channels', 'channel', 'ignoredchannels', 'ignoredchannel'].includes(method)) {
|
|
|
|
if (!args.length) return {
|
|
msg: message.format('MISSING_ARGS'),
|
|
error: true
|
|
};
|
|
const response = await this.resolveMethod(args, null, setting.ignoredChannels, guild.resolveChannels.bind(guild));
|
|
|
|
if (response) {
|
|
|
|
if (response.method === 'add') {
|
|
|
|
const channels = response.resolved; //await guild.resolveChannels(response.rest);
|
|
if (!channels.length) return { error: true, msg: message.format('ERR_CHRESOLVE') }
|
|
setting.ignoredChannels = [...setting.ignoredChannels, ...channels.filter((c) => !setting.ignoredChannels.includes(c.id)).map((c) => c.id)];
|
|
|
|
action = 'GENERAL_ADDED';
|
|
index = 'S_MESSAGELOG_CHANNELS';
|
|
changes = channels.map((c) => c.name);
|
|
|
|
} else if (response.method === 'remove') {
|
|
|
|
const channels = response.resolved; //await guild.resolveChannels(response.rest);
|
|
if (!channels.length) return { error: true, msg: message.format('ERR_CHRESOLVE') }
|
|
const _channels = channels.map((c) => c.id);
|
|
setting.ignoredChannels = setting.ignoredChannels.filter((c) => !_channels.includes(c));
|
|
|
|
action = 'GENERAL_REMOVED';
|
|
index = 'S_MESSAGELOG_CHANNELS';
|
|
changes = channels.map((c) => c.name);
|
|
|
|
} else if (response.method === 'list') {
|
|
return {
|
|
msg: message.format('S_MESSAGELOG_LIST')
|
|
};
|
|
}
|
|
|
|
} else {
|
|
const channels = await guild.resolveChannels(setting.ignoredChannels);
|
|
return {
|
|
msg: message.format('S_MESSAGELOG_ROLES_LIST', { roles: channels.map((r) => r.name).join(', ') })
|
|
};
|
|
}
|
|
|
|
|
|
} else if (['attachments', 'images', 'attachment', 'image'].includes(method)) {
|
|
|
|
if (guild.premium < 2) return {
|
|
msg: message.format('PREMIUM_REQUIRED', { required: 2, tier: guild.premium }),
|
|
error: true
|
|
};
|
|
if (!args.length) return {
|
|
msg: message.format('MISSING_ARGS'),
|
|
error: true
|
|
};
|
|
|
|
const [bool] = args;
|
|
const result = this.client.resolver.resolveBoolean(bool);
|
|
|
|
if (result) {
|
|
|
|
setting.attachments = true;
|
|
index = 'S_MESSAGELOG_ATTACHMENTS';
|
|
changes = message.format('ON_OFF_TOGGLE', { toggle: true }, true);
|
|
|
|
} else {
|
|
|
|
setting.attachments = false;
|
|
index = 'S_MESSAGELOG_ATTACHMENTS';
|
|
changes = message.format('ON_OFF_TOGGLE', { toggle: false }, true);
|
|
|
|
}
|
|
|
|
} else if (this.client.resolver.resolveBoolean(method) === false) {
|
|
|
|
index = 'S_MESSAGELOG_TOGGLE';
|
|
changes = message.format('ON_OFF_TOGGLE', { toggle: false }, true);
|
|
|
|
if (setting.webhook) { //Clean up - remove webhook since logs were disabled
|
|
const channel = await guild.resolveChannel(setting.channel);
|
|
if (channel) { //Channel might have been deleted
|
|
const hooks = await channel.fetchWebhooks();
|
|
const hook = hooks.filter((hook) => hook.id === setting.webhook.id).first();
|
|
|
|
if (hook && !channel.permissionsFor(guild.me).has('MANAGE_WEBHOOKS')) return { error: true, msg: message.format('S_MESSAGELOG_TOGGLE_PERM') } //index = 'S_MESSAGELOG_TOGGLE_PERM'; //missing perms
|
|
else if (hook) {
|
|
//await hook.delete('Removing message logging hook, as message logs were disabled.').catch(this.client.logger.error);
|
|
//guild.webhooks.delete(setting.webhook);
|
|
await guild.updateWebhook(this.index);
|
|
}
|
|
}
|
|
}
|
|
|
|
setting.channel = null;
|
|
|
|
} else { //Set the channel & configure webhook
|
|
|
|
const channel = await guild.resolveChannel(method);
|
|
if (!channel) return {
|
|
msg: message.format('ERR_CHANNEL_RESOLVE', { resolveable: method }),
|
|
error: true
|
|
};
|
|
if(channel.type !== 'text') return {
|
|
error: true,
|
|
msg: message.format('ERR_CHANNEL_TYPE', { type: channel.type })
|
|
};
|
|
|
|
const perms = channel.permissionsFor(guild.me);
|
|
const missingPerms = perms.missing(['SEND_MESSAGES', 'VIEW_CHANNEL', 'MANAGE_WEBHOOKS']);
|
|
|
|
if(missingPerms.length) return {
|
|
error: true,
|
|
msg: message.format('ERR_CHANNEL_PERMS', { channel: channel.name, perms: missingPerms.join(', ') })
|
|
};
|
|
|
|
//Handle old webhook if one exists
|
|
const oldChannel = await guild.resolveChannel(setting.channel);
|
|
if (oldChannel && oldChannel.id !== channel.id) {
|
|
const hooks = await oldChannel.fetchWebhooks();
|
|
const hook = hooks.filter(hook => hook.id === setting.webhook.id).first();
|
|
|
|
if (hook) {
|
|
guild.updateWebhook(this.index);
|
|
//hook.delete('Removing old webhook').catch(this.client.logger.error);
|
|
}
|
|
}
|
|
|
|
//Create new webhook
|
|
const hook = await channel.createWebhook('Galactic Bot message logs', { avatar: './util/GBotTest.png', reason: 'Message logs webhook.' });
|
|
await guild.updateWebhook(this.index, hook);
|
|
|
|
index = 'S_MESSAGELOG_CHANNEL';
|
|
changes = channel.name;
|
|
setting.channel = channel.id;
|
|
|
|
}
|
|
|
|
await message.guild._updateSettings({ [this.index]: setting });
|
|
return {
|
|
msg: message.format(index, { changed: changes instanceof Array ? changes?.join(', ') : changes || undefined, action: message.format(action) })
|
|
};
|
|
|
|
}
|
|
|
|
async fields(guild) {
|
|
const setting = guild._settings[this.index];
|
|
const roles = setting?.ignoredRoles ? await Promise.all(setting.ignoredRoles.map(async (role) => await guild.resolveRole(role))) : undefined;
|
|
const channels = setting?.ignoredChannels ? await Promise.all(setting.ignoredChannels.map(async (c) => await guild.resolveChannel(c))) : undefined;
|
|
return [
|
|
{
|
|
name: '》 Status',
|
|
value: guild.format('SETTING_STATUS', { bool: Boolean(setting?.channel) }, true),
|
|
inline: true
|
|
},
|
|
{
|
|
name: '》 Channel',
|
|
value: await guild.resolveChannel(setting?.channel) || '`N/A`',
|
|
inline: true
|
|
},
|
|
{
|
|
name: '》 Attachment Logs',
|
|
value: guild.format('SETTING_STATUS', { bool: Boolean(setting?.attachments) }, true),
|
|
inline: true
|
|
},
|
|
{
|
|
name: '》 Ignored Roles',
|
|
value: roles?.map((r) => r.name).join(', ') || '`N/A`'
|
|
},
|
|
{
|
|
name: '》 Ignored Channels',
|
|
value: channels?.map((c) => c.name).join(', ') || '`N/A`'
|
|
}
|
|
];
|
|
}
|
|
|
|
async _handleReset(message) {
|
|
const result = await super._handleReset(message);
|
|
await message.guild.updateWebhook(this.index);
|
|
return result;
|
|
}
|
|
|
|
}
|
|
|
|
module.exports = MessageLogsSetting; |