3
0
Fork 0
mirror of https://github.com/ZeppelinBot/Zeppelin.git synced 2025-05-18 15:45:03 +00:00

added new parameters

This commit is contained in:
roflmaoqwerty 2020-06-06 08:11:28 +10:00
parent 46515f0fb3
commit 5d56142b27

View file

@ -46,7 +46,7 @@ const ConfigSchema = t.type({
timed_mute_message: tNullable(t.string), timed_mute_message: tNullable(t.string),
update_mute_message: tNullable(t.string), update_mute_message: tNullable(t.string),
remove_roles_on_mute: t.union([t.boolean, t.array(t.string)]), remove_roles_on_mute: t.union([t.boolean, t.array(t.string)]),
role_restore_blacklist: t.union([t.boolean, t.array(t.string)]), restore_roles_on_mute: t.union([t.boolean, t.array(t.string)]),
can_view_list: t.boolean, can_view_list: t.boolean,
can_cleanup: t.boolean, can_cleanup: t.boolean,
@ -106,7 +106,7 @@ export class MutesPlugin extends ZeppelinPlugin<TConfigSchema> {
timed_mute_message: "You have been muted on the {guildName} server for {time}. Reason given: {reason}", timed_mute_message: "You have been muted on the {guildName} server for {time}. Reason given: {reason}",
update_mute_message: "Your mute on the {guildName} server has been updated to {time}.", update_mute_message: "Your mute on the {guildName} server has been updated to {time}.",
remove_roles_on_mute: false, remove_roles_on_mute: false,
role_restore_blacklist: false, restore_roles_on_mute: false,
can_view_list: false, can_view_list: false,
can_cleanup: false, can_cleanup: false,
@ -188,119 +188,120 @@ export class MutesPlugin extends ZeppelinPlugin<TConfigSchema> {
await member.edit({ channelID: moveToVoiceChannelId }); await member.edit({ channelID: moveToVoiceChannelId });
} catch (e) {} // tslint:disable-line } catch (e) {} // tslint:disable-line
} }
} if (config.remove_roles_on_mute) {
if (config.remove_roles_on_mute === true) {
// If the user is already muted, update the duration of their existing mute return;
const existingMute = await this.mutes.findExistingMuteForUserId(user.id);
let notifyResult: UserNotificationResult = { method: null, success: true };
if (existingMute) {
await this.mutes.updateExpiryTime(user.id, muteTime);
} else {
await this.mutes.addMute(user.id, muteTime);
}
const template = existingMute
? config.update_mute_message
: muteTime
? config.timed_mute_message
: config.mute_message;
const muteMessage =
template &&
(await renderTemplate(template, {
guildName: this.guild.name,
reason: reason || "None",
time: timeUntilUnmute,
}));
if (muteMessage && user instanceof User) {
let contactMethods = [];
if (muteOptions?.contactMethods) {
contactMethods = muteOptions.contactMethods;
} else {
const useDm = existingMute ? config.dm_on_update : config.dm_on_mute;
if (useDm) {
contactMethods.push({ type: "dm" });
}
const useChannel = existingMute ? config.message_on_update : config.message_on_mute;
const channel = config.message_channel && this.guild.channels.get(config.message_channel);
if (useChannel && channel instanceof TextChannel) {
contactMethods.push({ type: "channel", channel });
} }
} }
notifyResult = await notifyUser(user, muteMessage, contactMethods); // If the user is already muted, update the duration of their existing mute
} const existingMute = await this.mutes.findExistingMuteForUserId(user.id);
let notifyResult: UserNotificationResult = { method: null, success: true };
// Create/update a case if (existingMute) {
const casesPlugin = this.getPlugin<CasesPlugin>("cases"); await this.mutes.updateExpiryTime(user.id, muteTime);
let theCase; } else {
await this.mutes.addMute(user.id, muteTime);
}
if (existingMute && existingMute.case_id) { const template = existingMute
// Update old case ? config.update_mute_message
// Since mutes can often have multiple notes (extraNotes), we won't post each case note individually, : muteTime
// but instead we'll post the entire case afterwards ? config.timed_mute_message
theCase = await this.cases.find(existingMute.case_id); : config.mute_message;
const noteDetails = [`Mute updated to ${muteTime ? timeUntilUnmute : "indefinite"}`];
const reasons = [reason, ...(muteOptions.caseArgs?.extraNotes || [])]; const muteMessage =
for (const noteReason of reasons) { template &&
await casesPlugin.createCaseNote({ (await renderTemplate(template, {
caseId: existingMute.case_id, guildName: this.guild.name,
reason: reason || "None",
time: timeUntilUnmute,
}));
if (muteMessage && user instanceof User) {
let contactMethods = [];
if (muteOptions?.contactMethods) {
contactMethods = muteOptions.contactMethods;
} else {
const useDm = existingMute ? config.dm_on_update : config.dm_on_mute;
if (useDm) {
contactMethods.push({ type: "dm" });
}
const useChannel = existingMute ? config.message_on_update : config.message_on_mute;
const channel = config.message_channel && this.guild.channels.get(config.message_channel);
if (useChannel && channel instanceof TextChannel) {
contactMethods.push({ type: "channel", channel });
}
}
notifyResult = await notifyUser(user, muteMessage, contactMethods);
}
// Create/update a case
const casesPlugin = this.getPlugin<CasesPlugin>("cases");
let theCase;
if (existingMute && existingMute.case_id) {
// Update old case
// Since mutes can often have multiple notes (extraNotes), we won't post each case note individually,
// but instead we'll post the entire case afterwards
theCase = await this.cases.find(existingMute.case_id);
const noteDetails = [`Mute updated to ${muteTime ? timeUntilUnmute : "indefinite"}`];
const reasons = [reason, ...(muteOptions.caseArgs?.extraNotes || [])];
for (const noteReason of reasons) {
await casesPlugin.createCaseNote({
caseId: existingMute.case_id,
modId: muteOptions.caseArgs?.modId,
body: noteReason,
noteDetails,
postInCaseLogOverride: false,
});
}
if (muteOptions.caseArgs?.postInCaseLogOverride !== false) {
casesPlugin.postCaseToCaseLogChannel(existingMute.case_id);
}
} else {
// Create new case
const noteDetails = [`Muted ${muteTime ? `for ${timeUntilUnmute}` : "indefinitely"}`];
if (notifyResult.text) {
noteDetails.push(ucfirst(notifyResult.text));
}
theCase = await casesPlugin.createCase({
...(muteOptions.caseArgs || {}),
userId,
modId: muteOptions.caseArgs?.modId, modId: muteOptions.caseArgs?.modId,
body: noteReason, type: CaseTypes.Mute,
reason,
noteDetails, noteDetails,
postInCaseLogOverride: false, });
await this.mutes.setCaseId(user.id, theCase.id);
}
// Log the action
const mod = await this.resolveUser(muteOptions.caseArgs?.modId);
if (muteTime) {
this.serverLogs.log(LogType.MEMBER_TIMED_MUTE, {
mod: stripObjectToScalars(mod),
user: stripObjectToScalars(user),
time: timeUntilUnmute,
});
} else {
this.serverLogs.log(LogType.MEMBER_MUTE, {
mod: stripObjectToScalars(mod),
user: stripObjectToScalars(user),
}); });
} }
if (muteOptions.caseArgs?.postInCaseLogOverride !== false) { return {
casesPlugin.postCaseToCaseLogChannel(existingMute.case_id); case: theCase,
} notifyResult,
} else { updatedExistingMute: !!existingMute,
// Create new case };
const noteDetails = [`Muted ${muteTime ? `for ${timeUntilUnmute}` : "indefinitely"}`];
if (notifyResult.text) {
noteDetails.push(ucfirst(notifyResult.text));
}
theCase = await casesPlugin.createCase({
...(muteOptions.caseArgs || {}),
userId,
modId: muteOptions.caseArgs?.modId,
type: CaseTypes.Mute,
reason,
noteDetails,
});
await this.mutes.setCaseId(user.id, theCase.id);
} }
// Log the action
const mod = await this.resolveUser(muteOptions.caseArgs?.modId);
if (muteTime) {
this.serverLogs.log(LogType.MEMBER_TIMED_MUTE, {
mod: stripObjectToScalars(mod),
user: stripObjectToScalars(user),
time: timeUntilUnmute,
reason,
});
} else {
this.serverLogs.log(LogType.MEMBER_MUTE, {
mod: stripObjectToScalars(mod),
user: stripObjectToScalars(user),
reason,
});
}
lock.unlock();
return {
case: theCase,
notifyResult,
updatedExistingMute: !!existingMute,
};
} }
public async unmuteUser( public async unmuteUser(