forked from Galactic/galactic-bot
303 lines
11 KiB
JavaScript
303 lines
11 KiB
JavaScript
const { Setting } = require('../../../../interfaces/');
|
|
const emojis = require('../../../../../util/emojis.json');
|
|
const maxCharacters = 98;
|
|
|
|
const { stripIndents } = require('common-tags');
|
|
|
|
class MuteSetting extends Setting {
|
|
|
|
constructor(client) {
|
|
|
|
super(client, {
|
|
name: 'mute',
|
|
module: 'moderation',
|
|
aliases: [
|
|
'muted',
|
|
'muteType',
|
|
'mutedType',
|
|
'muteRole',
|
|
'mutedRole',
|
|
'createMute',
|
|
'createMuteRole',
|
|
'createMuted',
|
|
'createMutedRole',
|
|
'permaMute',
|
|
'permanentMute',
|
|
'defaultMuteDuration'
|
|
],
|
|
arguments: [
|
|
{
|
|
name: 'create',
|
|
type: 'BOOLEAN',
|
|
types: ['VERBAL'],
|
|
default: true
|
|
},
|
|
{
|
|
name: 'type',
|
|
type: 'BOOLEAN',
|
|
types: ['VERBAL'],
|
|
default: true
|
|
},
|
|
{
|
|
name: 'permanent',
|
|
aliases: ['perm', 'perma'],
|
|
type: 'BOOLEAN',
|
|
types: ['VERBAL'],
|
|
default: true
|
|
},
|
|
{
|
|
name: 'defaultDuration',
|
|
aliases: ['duration'],
|
|
type: 'BOOLEAN',
|
|
types: ['VERBAL'],
|
|
default: true
|
|
},
|
|
{
|
|
name: 'text',
|
|
type: 'BOOLEAN',
|
|
types: ['FLAG'],
|
|
default: true
|
|
},
|
|
{
|
|
name: 'voice',
|
|
type: 'BOOLEAN',
|
|
types: ['FLAG'],
|
|
default: true
|
|
}
|
|
],
|
|
usage: '[type|role|create|permanent|duration] [value]',
|
|
examples: [
|
|
'createmute Muted',
|
|
'mutetype 1',
|
|
'permamute true',
|
|
'mute default 1 day'
|
|
],
|
|
resolve: 'GUILD',
|
|
default: {
|
|
mute: {
|
|
role: null,
|
|
type: 0,
|
|
defaultDuration: 3600,
|
|
permanent: false
|
|
}
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
async handle(message, args) {
|
|
|
|
let { params, parsedArguments } = await this._parseArguments(args, message.guild); //eslint-disable-line prefer-const
|
|
|
|
if(['mutetype', 'mutedtype'].includes(message._settingCaller) || parsedArguments.type) {
|
|
|
|
if(!params[0]) return { error: true, msg: message.format('S_MUTE_TYPENAN') };
|
|
const num = params[0];
|
|
const number = parseInt(num);
|
|
if(Number.isNaN(number)) return {
|
|
msg: message.format('S_MUTE_TYPENAN'),
|
|
error: true
|
|
|
|
};
|
|
|
|
if(![0, 1, 2].includes(number)) return {
|
|
msg: message.format('S_MUTE_TYPEINVALID'),
|
|
error: true
|
|
};
|
|
|
|
await message.guild._updateSettings({
|
|
[this.index]: {
|
|
...message.guild._settings[this.index],
|
|
type: number
|
|
}
|
|
});
|
|
|
|
return {
|
|
msg: `${message.format('S_MUTE_TYPESUCCESS', { type: number })} ${message.format('S_MUTE_TYPESWITCH', { type: number }, true)}`,
|
|
error: false
|
|
};
|
|
|
|
} else if (['permamute', 'permanentmute'].includes(message._settingCaller) || parsedArguments.permanent) {
|
|
|
|
if(!params[0]) return { error: true, msg: message.format('S_MUTE_PERMANENTINVALID') };
|
|
const boolean = this.client.resolver.resolveBoolean(params[0]);
|
|
if(boolean === null) {
|
|
return {
|
|
msg: message.format('S_MUTE_PERMANENTINVALID'),
|
|
error: true
|
|
};
|
|
}
|
|
|
|
await message.guild._updateSettings({
|
|
[this.index]: {
|
|
...message.guild._settings[this.index],
|
|
permanent: boolean
|
|
}
|
|
});
|
|
|
|
return {
|
|
msg: message.format('S_MUTE_PERMANENTSUCCESS', { boolean }),
|
|
error: false
|
|
};
|
|
|
|
} else if (['defaultMuteDuration'].includes(message._settingCaller) || parsedArguments.defaultDuration) {
|
|
|
|
if(!params.length) return { error: true, msg: message.format('S_MUTE_PERMANENTINVALID') };
|
|
const time = this.client.resolver.resolveTime(params.join(' '));
|
|
if(!time) {
|
|
return {
|
|
msg: message.format('S_MUTE_DEFAULTINVALID'),
|
|
error: true
|
|
};
|
|
}
|
|
|
|
await message.guild._updateSettings({
|
|
[this.index]: {
|
|
...message.guild._settings[this.index],
|
|
defaultDuration: time
|
|
}
|
|
});
|
|
|
|
return {
|
|
msg: message.format('S_MUTE_DEFAULTSUCCESS', { time }),
|
|
error: false
|
|
};
|
|
|
|
}
|
|
|
|
let role = null,
|
|
updatedPermissions = false,
|
|
created = false;
|
|
|
|
const issues = [];
|
|
|
|
if(parsedArguments.create || ['createmute', 'createmuted', 'createmutedrole', 'createmuterole'].includes(message._settingCaller)) {
|
|
const missing = message.channel.permissionsFor(message.guild.me).missing('MANAGE_ROLES');
|
|
if(missing.length > 0) return {
|
|
msg: message.format('S_MUTE_ROLEMISSINGPERMISSION'),
|
|
error: true
|
|
};
|
|
|
|
const foundRole = await message.guild.resolveRole(params.join(' '), true);
|
|
if(foundRole) {
|
|
const prompt = await message.prompt(message.format('S_MUTE_ROLEPROMPT', { name: foundRole.name, id: foundRole.id }), { emoji: 'loading' });
|
|
const response = prompt.content.toLowerCase();
|
|
const bool = this.client.resolver.resolveBoolean(response);
|
|
if(bool === null) return { msg: message.format('S_MUTE_ROLEPROMPTERROR'), error: true };
|
|
if(!bool) {
|
|
role = await this._createRole(message, params);
|
|
if(role.error) return role;
|
|
created = true;
|
|
} else {
|
|
role = foundRole;
|
|
}
|
|
} else {
|
|
role = await this._createRole(message, params);
|
|
if(role.error) return role;
|
|
created = true;
|
|
}
|
|
const channels = message.guild.channels.cache;
|
|
for(const channel of channels.values()) {
|
|
const configuration = channel.type === 'text'
|
|
? { permissions: { SEND_MESSAGES: false, ADD_REACTIONS: false }, bitwise: 0x800 }
|
|
: { permissions: { CONNECT: false }, bitwise: 0x100000 };
|
|
try {
|
|
// console.log(channel.type)
|
|
if(channel.type === 'text' && !parsedArguments.voice || channel.type === 'voice' && !parsedArguments.text || !parsedArguments.text && !parsedArguments.voice) {
|
|
if(channel.type === 'category') continue;
|
|
await channel.createOverwrite(role, configuration.permissions, super.reason(message.author));
|
|
for(const permission of channel.permissionOverwrites.values()) {
|
|
if(permission.type !== 'role') continue;
|
|
const r = await this.client.resolver.resolveRole(permission.id, true, message.guild);
|
|
if((permission.allow & configuration.bitwise) === configuration.bitwise) { //eslint-disable-line no-bitwise
|
|
const info = {
|
|
role: r.name,
|
|
permission: channel.type === 'text' ? 'SEND_MESSAGES' : 'CONNECT',
|
|
channel: channel.name,
|
|
type: channel.type,
|
|
emoji: channel.type === 'text' ? emojis['text-channel'] : emojis['voice-channel']
|
|
};
|
|
issues.push(info);
|
|
}
|
|
}
|
|
}
|
|
} catch(err) {} //eslint-disable-line no-empty
|
|
}
|
|
updatedPermissions = true;
|
|
} else {
|
|
if(params.length > 1 && params[0].toLowerCase() === 'role') params = params.splice(1);
|
|
const search = params.join(' ');
|
|
role = await this.client.resolver.resolveRole(search, true, message.guild);
|
|
}
|
|
|
|
if(!role) return {
|
|
msg: message.format('S_MUTE_ROLEMISSING'),
|
|
error: true
|
|
};
|
|
|
|
await message.guild._updateSettings({
|
|
[this.index]: {
|
|
...message.guild._settings[this.index],
|
|
role: role.id
|
|
}
|
|
});
|
|
|
|
return {
|
|
msg: stripIndents`${message.format('S_MUTE_ROLESUCCESS', { role: role.name, type: created ? 'created' : 'set' })} ${updatedPermissions ? message.format('S_MUTE_GENERATEDPERMISSIONS') : message.format('S_MUTE_UNGENERATEDPERMISSIONS')}
|
|
${issues.length > 0 ? message.format('S_MUTE_ISSUES', { issues: issues.map((i) => `**\`${i.role}\`:** Has the \`${i.permission}\` permission in **${i.emoji}${i.channel}**.`).join('\n') }) : ''}`,
|
|
error: false
|
|
};
|
|
|
|
}
|
|
|
|
async _createRole(message, args) {
|
|
let role = null;
|
|
let name = args.join(' ') || 'Muted';
|
|
if(name.length > maxCharacters) name = name.slice(0, maxCharacters);
|
|
try {
|
|
role = await message.guild.roles.create({
|
|
data: {
|
|
name
|
|
},
|
|
reason: super.reason(message.author)
|
|
});
|
|
} catch(error) {
|
|
return {
|
|
msg: message.format('S_MUTE_ROLECREATEERROR'),
|
|
error: true
|
|
};
|
|
}
|
|
return role;
|
|
}
|
|
|
|
fields(guild) {
|
|
const setting = guild._settings[this.index];
|
|
return [
|
|
{
|
|
name: '》 Muted Role',
|
|
value: setting?.role ? `<@&${guild._settings[this.index].role}>` : '`N/A`',
|
|
inline: true
|
|
},
|
|
{
|
|
name: '》 Mute Type',
|
|
value: `\`${setting?.type || 0}\``,
|
|
inline: true
|
|
},
|
|
{ name: '\u200b', value: '\u200b', inline: true }, //zero width spaces, not necessary, but could make things look nicer.
|
|
{
|
|
name: '》 Permanent Mutes',
|
|
value: guild.format('SETTING_STATUS', { bool: Boolean(setting?.permanent) }, true),
|
|
inline: true
|
|
},
|
|
{
|
|
name: '》 Default Duration',
|
|
value: `\`${setting.defaultDuration ? `${setting.defaultDuration} seconds` : 'N/A'}\``,
|
|
inline: true
|
|
},
|
|
{ name: '\u200b', value: '\u200b', inline: true } //zero width spaces, not necessary, but could make things look nicer.
|
|
];
|
|
}
|
|
|
|
}
|
|
|
|
module.exports = MuteSetting; |