350 lines
13 KiB
JavaScript
350 lines
13 KiB
JavaScript
const {
|
|
InfractionTargetTypes,
|
|
InfractionDictionary,
|
|
InfractionColors
|
|
} = require('../../../util/Constants.js');
|
|
|
|
const { Util } = require('../../../util/');
|
|
|
|
const Constants = {
|
|
MaxCharacters: 1024, // Max embed description is 2048 characters, however some of those description characters are going to usernames, types, filler text, etc.
|
|
RemovedInfractions: ['BAN', 'SOFTBAN', 'KICK']
|
|
};
|
|
|
|
class Infraction {
|
|
|
|
constructor(client, data = {}) {
|
|
|
|
this.client = client;
|
|
this.type = data.type || null;
|
|
this.id = null;
|
|
this.case = null;
|
|
|
|
this.message = data.message; //NOT REQUIRED
|
|
this.arguments = data.arguments || {};
|
|
|
|
this.guildId = data.guild ? data.guild.id : null;
|
|
this.guild = data.guild || null;
|
|
|
|
this.channelId = data.channel ? data.channel.id : null;
|
|
this.channel = data.channel || null;
|
|
|
|
this.messageId = data.message ? data.message.id : null;
|
|
this.message = data.message || null;
|
|
|
|
this.targetId = data.target ? data.target.id : null;
|
|
this.target = data.target || [];
|
|
|
|
this.executorId = data.executor ? data.executor.id : null;
|
|
this.executor = data.executor || null;
|
|
|
|
this.targetType = data.targetType && InfractionTargetTypes.includes(data.targetType) ? data.targetType : 'USER';
|
|
|
|
this.resolved = false;
|
|
|
|
this.duration = isNaN(data.duration) ? null : data.duration; //How long the action will last. Must be in milliseconds.
|
|
this.callback = isNaN(data.duration) ? null : Date.now() + data.duration * 1000; //At what epoch(?) time it will callback.
|
|
|
|
this.reason = data.reason.length ? data.reason : 'N/A';
|
|
|
|
this.points = data.points || 0;
|
|
this.totalPoints = 0;
|
|
this.expiration = data.expiration || 0;
|
|
|
|
this.data = data.data || {}; //Miscellaneous data that may need to be saved for future use.
|
|
this.flags = data.arguments ? Object.keys(data.arguments) : [];
|
|
this.hyperlink = data.hyperlink || null; // To overwrite hyperlink (if it's from a callback)
|
|
|
|
this.modlogMessageId = null;
|
|
this.dmlogMessageId = null;
|
|
this.modlogId = null;
|
|
|
|
this.changes = [];
|
|
|
|
this.timestamp = Date.now();
|
|
|
|
this._callbacked = Boolean(data._callbacked);
|
|
this._fetched = Boolean(data);
|
|
|
|
|
|
}
|
|
|
|
async handle() {
|
|
|
|
const { moderationLog, dmInfraction } = await this.guild.settings();
|
|
|
|
//Increment CaseId, should only be called if making a new infraction.
|
|
this.guild._settings.caseId++;
|
|
this.case = this.guild._settings.caseId;
|
|
await this.guild._updateSettings({
|
|
caseId: this.case
|
|
});
|
|
|
|
/* Logging */
|
|
|
|
if(moderationLog.channel) {
|
|
if(moderationLog.infractions.includes(this.type)) {
|
|
this._moderationLog = await this.client.resolver.resolveChannel(moderationLog.channel, true, this.guild);
|
|
if(!this._moderationLog) return undefined;
|
|
this.modlogId = this._moderationLog.id;
|
|
try {
|
|
this._logMessage = await this._moderationLog.send('', { embed: this._embed() });
|
|
this.modlogMessageId = this._logMessage.id;
|
|
} catch(e) {
|
|
console.error(e);
|
|
} //eslint-disable-line no-empty
|
|
} else {
|
|
this.client.logger.debug(`Did not log infraction ${this.type} because it is not in the infractions.`);
|
|
}
|
|
}
|
|
|
|
if(dmInfraction.enabled) {
|
|
if(this.targetType === 'USER') {
|
|
let message = dmInfraction.messages[this.type] || dmInfraction.messages.default;
|
|
if(!message) message = '';
|
|
message = message
|
|
.replace(/\{(guild|server)\}/ugim, this.guild.name)
|
|
.replace(/\{user\}/ugim, this.target.tag)
|
|
.replace(/\{infraction\}/ugim, this.dictionary.past)
|
|
.replace(/\{from\|on\}/ugim, Constants.RemovedInfractions.includes(this.type) ? 'from' : 'on'); //add more if you want i should probably add a better system for this...
|
|
try {
|
|
const logMessage = await this.target.send(message, {
|
|
embed: this._embed(true)
|
|
});
|
|
this.dmlogMessageId = logMessage.id;
|
|
} catch(e) {} //eslint-disable-line no-empty
|
|
}
|
|
}
|
|
|
|
if(this.duration) {
|
|
await this.client.moderationManager._handleExpirations([this.json]);
|
|
}
|
|
|
|
/* LMAOOOO PLEASE DONT JUDGE ME */
|
|
if(this.data.roles && this.data.roles.length > 0) {
|
|
this.data.roleIds = this.data.roles.map((r) => r.id);
|
|
this.data.roleNames = this.data.roles.map((r) => r.name);
|
|
delete this.data.roles;
|
|
}
|
|
|
|
return this.save();
|
|
|
|
}
|
|
|
|
async save() {
|
|
return this.client.storageManager.mongodb.infractions.insertOne(this.json)
|
|
.catch((error) => {
|
|
this.client.logger.error(`There was an issue saving infraction data to the database.\n${error.stack || error}`);
|
|
});
|
|
}
|
|
|
|
hyperlink(bool = false) {
|
|
if(bool) return `https://discord.com/channels/${this.guildId}/${this.modlogId}/${this.modlogMessageId}`;
|
|
return `https://discord.com/channels/${this.guildId}/${this.channelId}/${this.messageId}`;
|
|
}
|
|
|
|
_embed(dm) {
|
|
let description = "";
|
|
|
|
description += `${this.guild.format('INFRACTION_DESCRIPTION', {
|
|
type: this.dictionary.past.toUpperCase(),
|
|
moderator: `${Util.escapeMarkdown(this.executor.tag)}`,
|
|
reason: Util.escapeMarkdown(this.reason.length > Constants.MaxCharacters ? `${this.reason.substring(0, Constants.MaxCharacters-3)}...` : this.reason, { italic: false, underline: false, strikethrough: false })
|
|
})}`;
|
|
|
|
if(this.duration) {
|
|
description += `\n${this.guild.format('INFRACTION_DESCRIPTIONDURATION', { duration: Util.duration(this.duration) })}`;
|
|
}
|
|
|
|
if(this.points && this.points > 0) { //TODO: Add expiration to INFRACTION_DESCRIPTIONPOINTS
|
|
description += `\n${this.guild.format('INFRACTION_DESCRIPTIONPOINTS', { points: this.points, total: this.pointsTotal, expires: Util.duration(this.pointsExpiration) })}`;
|
|
}
|
|
|
|
if(this.description && this.description instanceof Function) {
|
|
description += this.description(dm);
|
|
}
|
|
|
|
if(!this.silent &&
|
|
(this.message || this.hyperlink)
|
|
&& (dm && !Constants.RemovedInfractions.includes(this.type))) {
|
|
description += `\n${this.guild.format('INFRACTION_DESCRIPTIONJUMPTO', { name: this.hyperlink ? 'Case' : 'Message', link: this.hyperlink ? this.hyperlink : `https://discord.com/channels/${this.guildId}/${this.channelId}/${this.messageId}` })}`;
|
|
}
|
|
|
|
|
|
const blah = {
|
|
author: {
|
|
name: `${this.target.display} (${this.targetId})`,
|
|
icon_url: this.target.displayAvatarURL() //eslint-disable-line camelcase
|
|
},
|
|
timestamp: this.timestamp,
|
|
color: this.color,
|
|
footer: {
|
|
text: `》 Case ${this.case}`
|
|
},
|
|
description
|
|
};
|
|
|
|
return blah;
|
|
|
|
}
|
|
|
|
get json() {
|
|
return {
|
|
id: `${this.guildId}:${this.case}`,
|
|
guild: this.guildId,
|
|
channel: this.channelId,
|
|
channelName: this.channel.display,
|
|
message: this.messageId,
|
|
executor: this.executorId,
|
|
executorTag: this.executor.display,
|
|
target: this.targetId,
|
|
targetTag: this.target.display,
|
|
targetType: this.targetType,
|
|
type: this.type,
|
|
case: this.case,
|
|
timestamp: this.timestamp,
|
|
duration: this.duration,
|
|
callback: this.callback,
|
|
reason: this.reason,
|
|
data: this.data,
|
|
flags: this.flags,
|
|
modLogMessage: this.modLogMessageId,
|
|
dmLogMessage: this.dmlogMessageId,
|
|
modLogChannel: this.modlogId,
|
|
resolved: this.resolved,
|
|
changes: this.changes,
|
|
_callbacked: this._callbacked || false
|
|
};
|
|
}
|
|
|
|
get targetIcon() {
|
|
return this.targetType === 'USER'
|
|
? this.target.displayAvatarURL()
|
|
: this.guild.iconURL();
|
|
}
|
|
|
|
get actions() {
|
|
const actions = [];
|
|
for(const argument of Object.values(this.arguments)) {
|
|
if(['silent', 'prune', 'force'].includes(argument)) actions.push(argument);
|
|
}
|
|
return actions;
|
|
}
|
|
|
|
get _reason() {
|
|
let str = `[${this.type}][targetId:${this.target.id}] Executed by ${this.executor.tag} (${this.executor.id}) because: ${this.reason}`;
|
|
if(str.length > 512) str = `${this.reason.substring(0, 509)}...`;
|
|
return str;
|
|
}
|
|
|
|
get dictionary() {
|
|
return InfractionDictionary[this.type];
|
|
}
|
|
|
|
get color() {
|
|
return InfractionColors[this.type];
|
|
}
|
|
|
|
//Super Functions
|
|
_succeed() {
|
|
return {
|
|
error: false,
|
|
infraction: this
|
|
};
|
|
}
|
|
|
|
_fail(message, fatal = false) {
|
|
return {
|
|
error: true,
|
|
infraction: this,
|
|
reason: message,
|
|
fatal
|
|
};
|
|
}
|
|
|
|
verify() {
|
|
return this._verify();
|
|
}
|
|
|
|
async _verify() {
|
|
if (this.executor.id === this.guild.ownerID) return this._succeed();
|
|
if (this.guild && this.guild._settings.protection.enabled && this.targetType === 'USER') {
|
|
//Idk what the thought process here has been, but the user object does not have roles, and the executor is a user object
|
|
const executor = await this.guild.members.fetch(this.executor.id).catch();
|
|
const target = await this.guild.members.fetch(this.target.id).catch();
|
|
if (!target) return this._succeed();
|
|
const executorHighest = executor.roles.highest; //this.executor.roles.highest;
|
|
const targetHighest = target.roles.highest; //this.member.roles.highest;
|
|
if(executorHighest.comparePositionTo(targetHighest) > 0) {
|
|
return this._fail('INFRACTION_PROTECTIONERROR');
|
|
}
|
|
}
|
|
return this._succeed();
|
|
}
|
|
|
|
// async fetch() { //Data from Mongodb (id-based data)
|
|
// const data = await this.client.storageManager.mongodb.infractions.findOne({ id: this.id });
|
|
// if(!data) {
|
|
// this.client.logger.error(`Case ${this.id} is missing infraction data in database.`);
|
|
// return null;
|
|
// }
|
|
|
|
// if(data.guild) {
|
|
// let guild = null;
|
|
// try {
|
|
// guild = await this.client.guilds.fetch(data.guild);
|
|
// } catch(error) {
|
|
// this.client.logger.error(`Unable to fetch guild: ${data.guild}\n${error.stack || error}`);
|
|
// guild = null;
|
|
// }
|
|
// if(!guild) return null;
|
|
// if(data.targets) {
|
|
// this.targetIds = data.targets;
|
|
// for(const target of data.targets) {
|
|
// const fetchedTarget = await this._fetchTarget(target);
|
|
// if(fetchedTarget) this.targets.push(fetchedTarget);
|
|
// }
|
|
// }
|
|
// if(data.executor) {
|
|
// this.executorId = data.executor;
|
|
// const fetchedExecutor = await this._fetchTarget(data.executor, 'USER');
|
|
// if(fetchedExecutor) this.executor = fetchedExecutor;
|
|
// }
|
|
// }
|
|
|
|
// this.type = data.type;
|
|
// this.timestamp = data.timestamp;
|
|
// this.duration = data.duration;
|
|
// this.reason = data.reason;
|
|
// this.channelId = data.channel;
|
|
// this.resolved = data.resolved;
|
|
// this._callbacked = data._callbacked;
|
|
|
|
// this.dictionary = InfractionDictionary[this.type];
|
|
// this.color = InfractionColors[this.type];
|
|
|
|
// this.modlogMessageId = data.modlogMessageId;
|
|
// this.dmlogMessageId = data.dmlogMessageId;
|
|
|
|
// this._fetched = Boolean(data._fetched);
|
|
// return this;
|
|
|
|
// }
|
|
|
|
// async _fetchTarget(target, type = null) {
|
|
// type = type || this.targetType;
|
|
// let fetched = null;
|
|
// if(type === 'CHANNEL') {
|
|
// fetched = await this.client.resolver.resolveChannel(target, true, this.guild);
|
|
// } else if (type) {
|
|
// fetched = await this.client.resolver.resolveMember(target, true, this.guild);
|
|
// if(!fetched) {
|
|
// fetched = await this.client.resolver.resolveUser(target, true);
|
|
// }
|
|
// }
|
|
// return fetched || null;
|
|
// }
|
|
|
|
}
|
|
|
|
module.exports = Infraction; |