+import { AllowedMentions, BushCommand, BushGuildMember, BushMessage, BushSlashMessage } from '@lib';

+ const responseCode = await member.bushBan({

+ const responseMessage = () => {

+ switch (responseCode) {

+ case 'missing permissions':

+ return `${this.client.util.emojis.error} Could not ban **${member.user.tag}** because I do not have permissions`;

+ case 'error banning':

+ return `${this.client.util.emojis.error} An error occurred while trying to ban **${member.user.tag}**.`;

+ case 'error creating ban entry':

+ return `${this.client.util.emojis.error} While banning **${member.user.tag}**, there was an error creating a ban entry, please report this to my developers.`;

+ case 'error creating modlog entry':

+ return `${this.client.util.emojis.error} While banning **${member.user.tag}**, there was an error creating a modlog entry, please report this to my developers.`;

+ case 'failed to dm':

+ return `${this.client.util.emojis.warn} Banned **${member.user.tag}** however I could not send them a dm.`;

+ case 'success':

+ return `${this.client.util.emojis.success} Successfully banned **${member.user.tag}**.`;

+ }

+ };

+ return await message.util.reply({ content: responseMessage(), allowedMentions: AllowedMentions.none() });

+import { AllowedMentions, BushCommand, BushGuildMember, BushMessage, BushSlashMessage, BushUser } from '@lib';

+ const responseCode = await member.bushKick({

+ const responseMessage = () => {

+ switch (responseCode) {

+ case 'missing permissions':

+ return `${this.client.util.emojis.error} Could not kick **${member.user.tag}** because I am missing the \`Kick Members\` permission.`;

+ case 'error kicking':

+ return `${this.client.util.emojis.error} An error occurred while trying to kick **${member.user.tag}**.`;

+ case 'error creating modlog entry':

+ return `${this.client.util.emojis.error} While muting **${member.user.tag}**, there was an error creating a modlog entry, please report this to my developers.`;

+ case 'failed to dm':

+ return `${this.client.util.emojis.warn} Kicked **${member.user.tag}** however I could not send them a dm.`;

+ case 'success':

+ return `${this.client.util.emojis.success} Successfully kicked **${member.user.tag}**.`;

+ }

+ };

+ return await message.util.reply({ content: responseMessage(), allowedMentions: AllowedMentions.none() });

+ if (log.duration) modLog.push(`**Duration**: ${this.client.util.humanizeDuration(log.duration)}`);

+import { AllowedMentions, BushCommand, BushGuildMember, BushMessage, BushSlashMessage, BushUser } from '@lib';

+ const responseCode = await member.mute({

+ const responseMessage = () => {

+ const prefix = message.guild.getSetting('prefix');

+ switch (responseCode) {

+ case 'missing permissions':

+ return `${error} Could not mute ${victimBoldTag} because I am missing the \`Manage Roles\` permission.`;

+ case 'no mute role':

+ return `${error} Could not mute ${victimBoldTag}, you must set a mute role with \`${prefix}muterole\`.`;

+ case 'invalid mute role':

+ return `${error} Could not mute ${victimBoldTag} because the current mute role no longer exists. Please set a new mute role with \`${prefix}muterole\`.`;

+ case 'mute role not manageable':

+ return `${error} Could not mute ${victimBoldTag} because I cannot assign the current mute role, either change the role's position or set a new mute role with \`${prefix}muterole\`.`;

+ case 'error giving mute role':

+ return `${error} Could not mute ${victimBoldTag}, there was an error assigning them the mute role.`;

+ case 'error creating modlog entry':

+ return `${error} There was an error creating a modlog entry, please report this to my developers.`;

+ case 'error creating mute entry':

+ return `${error} There was an error creating a punishment entry, please report this to my developers.`;

+ case 'failed to dm':

+ return `${this.client.util.emojis.warn} Muted **${member.user.tag}** however I could not send them a dm.`;

+ case 'success':

+ return `${this.client.util.emojis.success} Successfully muted **${member.user.tag}**.`;

+ }

+ };

+ return await message.util.reply({ content: responseMessage(), allowedMentions: AllowedMentions.none() });

+ usage: 'role <add|remove> <user> <role> [duration]',

+ examples: ['role add spammer nogiveaways 7days']

+ args: [

+ {

+ id: 'action',

+ type: [['add'], ['remove']],

+ prompt: {

+ start: 'Would you like to `add` or `remove` a role?',

+ retry: '{error} Choose whether you would you like to `add` or `remove` a role.'

+ }

+ },

+ {

+ id: 'user',

+ type: 'member',

+ prompt: {

+ start: `What user do you want to add/remove the role to/from?`,

+ retry: `{error} Choose a valid user to add/remove the role to/from.`

+ }

+ },

+ {

+ id: 'role',

+ type: 'role',

+ prompt: {

+ start: `What role do you want to add/remove to/from the user.?`,

+ retry: `{error} Choose a valid role to add/remove.`

+ }

+ },

+ {

+ id: 'duration',

+ type: 'duration',

+ prompt: {

+ start: 'How long would you like to role to last?',

+ retry: '{error} Choose a valid duration.',

+ optional: true

+ }

+ }

+ ],

+ description: 'What user do you want to add/remove the role to/from?',

+ description: 'The role you would like to add/remove from the to/from.',

+ },

+ {

+ name: 'duration',

+ description: 'How long would you like to role to last?',

+ type: 'STRING',

+ required: false

+ { action, user, role, duration }: { action: 'add' | 'remove'; user: BushGuildMember; role: BushRole; duration: number }

+ if (!message.member.permissions.has('MANAGE_ROLES')) {

+

+ const shouldLog = this.punishmentRoleNames.includes(role.name);

+

+ const responseCode =

+ action === 'add'

+ ? await user.addRole({ moderator: message.member, addToModlog: shouldLog, role, duration })

+ : await user.removeRole({ moderator: message.member, addToModlog: shouldLog, role, duration });

+

+ const responseMessage = () => {

+ switch (responseCode) {

+ case 'user hierarchy':

+ return `${this.client.util.emojis.error} <@&${role.id}> is higher or equal to your highest role.`;

+ case 'role managed':

+ return `${this.client.util.emojis.error} <@&${role.id}> is managed by an integration and cannot be managed.`;

+ case 'client hierarchy':

+ return `${this.client.util.emojis.error} <@&${role.id}> is higher or equal to my highest role.`;

+ case 'error creating modlog entry':

+ return `${this.client.util.emojis.error} There was an error creating a modlog entry, please report this to my developers.`;

+ case 'error creating role entry' || 'error removing role entry':

+ return `${this.client.util.emojis.error} There was an error ${

+ action === 'add' ? 'creating' : 'removing'

+ } a punishment entry, please report this to my developers.`;

+ case 'error adding role' || 'error removing role':

+ return `${this.client.util.emojis.error} An error occurred while trying to ${action} <@&${role.id}> ${

+ action === 'add' ? 'to' : 'from'

+ } **${user.user.tag}**.`;

+ case 'success':

+ return `${this.client.util.emojis.success} Successfully ${action === 'add' ? 'added' : 'removed'} <@&${role.id}> ${

+ action === 'add' ? 'to' : 'from'

+ } **${user.user.tag}**${duration ? ` for ${this.client.util.humanizeDuration(duration)}` : ''}.`;

+ };

+

+ await message.util.reply({ content: responseMessage(), allowedMentions: AllowedMentions.none() });

+

+ punishmentRoleNames = [

+ 'No Files',

+ 'No Links',

+ 'No Reactions',

+ 'No Suggestions',

+ 'No Bots',

+ 'No VC',

+ 'No Giveaways',

+ 'No Support'

+ ];

+import { AllowedMentions, BushCommand, BushMessage, BushSlashMessage } from '@lib';

+ const responseCode = await message.guild.unban({

+ const responseMessage = () => {

+ switch (responseCode) {

+ case 'missing permissions':

+ return `${this.client.util.emojis.error} Could not unban **${user.tag}** because I do not have permissions`;

+ case 'error unbanning':

+ return `${this.client.util.emojis.error} An error occurred while trying to unban **${user.tag}**.`;

+ case 'error removing ban entry':

+ return `${this.client.util.emojis.error} While unbanning **${user.tag}**, there was an error removing their ban entry, please report this to my developers.`;

+ case 'error creating modlog entry':

+ return `${this.client.util.emojis.error} While unbanning **${user.tag}**, there was an error creating a modlog entry, please report this to my developers.`;

+ case 'user not banned':

+ return `${this.client.util.emojis.warn} **${user.tag}** but I tried to unban them anyways.`;

+ case 'success':

+ return `${this.client.util.emojis.success} Successfully unbanned **${user.tag}**.`;

+ }

+ };

+ return await message.util.reply({ content: responseMessage(), allowedMentions: AllowedMentions.none() });

+import { AllowedMentions, BushCommand, BushGuildMember, BushMessage, BushSlashMessage, BushUser } from '@lib';

+ const responseCode = await member.unmute({

+ const responseMessage = () => {

+ const prefix = message.guild.getSetting('prefix');

+ switch (responseCode) {

+ case 'missing permissions':

+ return `${error} Could not unmute ${victimBoldTag} because I am missing the \`Manage Roles\` permission.`;

+ case 'no mute role':

+ return `${error} Could not unmute ${victimBoldTag}, you must set a mute role with \`${prefix}muterole\`.`;

+ case 'invalid mute role':

+ return `${error} Could not unmute ${victimBoldTag} because the current mute role no longer exists. Please set a new mute role with \`${prefix}muterole\`.`;

+ case 'mute role not manageable':

+ return `${error} Could not unmute ${victimBoldTag} because I cannot assign the current mute role, either change the role's position or set a new mute role with \`${prefix}muterole\`.`;

+ case 'error removing mute role':

+ return `${error} Could not unmute ${victimBoldTag}, there was an error removing their mute role.`;

+ case 'error creating modlog entry':

+ return `${error} While muting ${victimBoldTag}, there was an error creating a modlog entry, please report this to my developers.`;

+ case 'error removing mute entry':

+ return `${error} While muting ${victimBoldTag}, there was an error removing their mute entry, please report this to my developers.`;

+ case 'failed to dm':

+ return `${this.client.util.emojis.warn} unmuted **${member.user.tag}** however I could not send them a dm.`;

+ case 'success':

+ return `${this.client.util.emojis.success} Successfully unmuted **${member.user.tag}**.`;

+ }

+ };

+ return await message.util.reply({ content: responseMessage(), allowedMentions: AllowedMentions.none() });

+import {

+ Ban,

+ BushCache,

+ BushClient,

+ BushConstants,

+ BushGuildMember,

+ BushGuildMemberResolvable,

+ BushGuildResolvable,

+ BushMessage,

+ BushSlashMessage,

+ Global,

+ Guild,

+ ModLog,

+ ModLogType,

+ Mute,

+ PunishmentRole

+} from '@lib';

+import Op from 'sequelize/types/lib/operators';

+

+interface punishmentModels {

+ mute: Mute;

+ ban: Ban;

+ role: PunishmentRole;

+}

+

+ public async findExpiredEntries<K extends keyof punishmentModels>(type: K): Promise<punishmentModels[K][]> {

+ const dbModel = this.findPunishmentModel(type);

+ //@ts-ignore: stfu idc

+ return await dbModel.findAll({

+ where: {

+ [Op.and]: [

+ {

+ expires: {

+ [Op.lt]: new Date() // Find all rows with an expiry date before now

+ }

+ }

+ ]

+ }

+ });

+ }

+

+ private findPunishmentModel<K extends keyof punishmentModels>(type: K): typeof Mute | typeof Ban | typeof PunishmentRole {

+import { GuildMember, Role } from 'discord.js';

+import { BushRole } from './BushRole';

+interface AddRoleOptions {

+ moderator?: BushUserResolvable;

+ duration?: number;

+ role: BushRole | Role;

+ addToModlog: boolean;

+}

+

+interface RemoveRoleOptions {

+ moderator?: BushUserResolvable;

+ duration?: number;

+ role: BushRole | Role;

+ addToModlog: boolean;

+type AddRoleResponse =

+ | PunishmentResponse

+ | 'user hierarchy'

+ | 'role managed'

+ | 'client hierarchy'

+ | 'error creating role entry'

+ | 'error adding role';

+type RemoveRoleResponse =

+ | PunishmentResponse

+ | 'user hierarchy'

+ | 'role managed'

+ | 'client hierarchy'

+ | 'error removing role entry'

+ | 'error removing role';

+ moderator: options.moderator || this.client.user.id,

+ public async addRole(options: AddRoleOptions): Promise<AddRoleResponse> {

+ const ifShouldAddRole = this.checkIfShouldAddRole(options.role);

+ if (ifShouldAddRole !== true) return ifShouldAddRole;

+

+ const moderator = this.client.users.cache.get(this.client.users.resolveId(options.moderator || this.client.user));

+

+ if (options.addToModlog) {

+ const { log: modlog } = await this.client.util

+ .createModLogEntry({

+ type: options.duration ? ModLogType.TEMP_PUNISHMENT_ROLE : ModLogType.PERM_PUNISHMENT_ROLE,

+ guild: this.guild,

+ moderator: moderator.id,

+ user: this,

+ reason: 'N/A'

+ })

+ .catch(() => null);

+ if (!modlog) return 'error creating modlog entry';

+

+ const punishmentEntrySuccess = await this.client.util

+ .createPunishmentEntry({

+ type: 'role',

+ user: this,

+ guild: this.guild,

+ duration: options.duration,

+ modlog: modlog.id

+ })

+ .catch(() => null);

+ if (!punishmentEntrySuccess) return 'error creating role entry';

+ }

+

+ const removeRoleSuccess = await this.roles.remove(options.role, `${moderator.tag}`);

+ if (!removeRoleSuccess) return 'error adding role';

+

+ return 'success';

+ }

+

+ public async removeRole(options: RemoveRoleOptions): Promise<RemoveRoleResponse> {

+ const ifShouldAddRole = this.checkIfShouldAddRole(options.role);

+ if (ifShouldAddRole !== true) return ifShouldAddRole;

+

+ const moderator = this.client.users.cache.get(this.client.users.resolveId(options.moderator || this.client.user));

+

+ if (options.addToModlog) {

+ const { log: modlog } = await this.client.util

+ .createModLogEntry({

+ type: ModLogType.PERM_PUNISHMENT_ROLE,

+ guild: this.guild,

+ moderator: moderator.id,

+ user: this,

+ reason: 'N/A'

+ })

+ .catch(() => null);

+ if (!modlog) return 'error creating modlog entry';

+

+ const punishmentEntrySuccess = await this.client.util

+ .removePunishmentEntry({

+ type: 'role',

+ user: this,

+ guild: this.guild

+ })

+ .catch(() => null);

+ if (!punishmentEntrySuccess) return 'error removing role entry';

+ }

+

+ const removeRoleSuccess = await this.roles.remove(options.role, `${moderator.tag}`);

+ if (!removeRoleSuccess) return 'error removing role';

+

+ return 'success';

+ private checkIfShouldAddRole(role: BushRole | Role) {

+ if (this.roles.highest.position <= role.position) {

+ return `user hierarchy`;

+ } else if (role.managed) {

+ return `role managed`;

+ } else if (this.guild.me.roles.highest.position <= role.position) {

+ return `client hierarchy`;

+ }

+ return true;

+ const { log: modlog } = await this.client.util

+ const { log: modlog } = await this.client.util

+ const { log: modlog } = await this.client.util

+ const { log: modlog } = await this.client.util

+ public get isOwner(): boolean {

+ public get isSuperUser(): boolean {

+ user: Snowflake;

+ guild: Snowflake;

+ user: Snowflake;

+ guild: Snowflake;

+import { DataTypes, Sequelize } from 'sequelize';

+

+export interface GlobalModelCreationAttributes {

+ environment: 'production' | 'development';

+ superUsers?: Snowflake[];

+ disabledCommands?: string[];

+ blacklistedUsers?: Snowflake[];

+ blacklistedGuilds?: Snowflake[];

+ blacklistedChannels?: Snowflake[];

+}

+ /**

+ * The bot's environment.

+ */

+ /**

+ * Trusted users.

+ */

+ /**

+ * Globally disabled commands.

+ */

+ /**

+ * Globally blacklisted users.

+ */

+ /**

+ * Guilds blacklisted from using the bot.

+ */

+ /**

+ * Channels where the bot is prevented from running.

+ */

+import { DataTypes, Sequelize } from 'sequelize';

+// export type GuildModelCreationAttributes = Optional<

+// GuildModel,

+// 'prefix' | 'autoPublishChannels' | 'blacklistedChannels' | 'welcomeChannel' | 'muteRole' | 'punishmentEnding'

+// >;

+export interface GuildModelCreationAttributes {

+ id: string;

+ prefix?: string;

+ autoPublishChannels?: Snowflake[];

+ blacklistedChannels?: Snowflake[];

+ welcomeChannel?: Snowflake;

+ muteRole?: Snowflake;

+ punishmentEnding?: string;

+}

+ id!: string;

+ prefix!: string;

+import { Snowflake } from 'discord.js';

+ id: Snowflake;

+ id: Snowflake;

+ /**

+ * The user's id.

+ */

+ public id: Snowflake;

+ /**

+ * The user's xp.

+ */

+ /**

+ * The primary key of the modlog entry.

+ */

+ /**

+ * The type of punishment.

+ */

+ /**

+ * The user being punished.

+ */

+ /**

+ * The user carrying out the punishment.

+ */

+ /**

+ * The reason the user is getting punished

+ */

+ /**

+ * The amount of time the user is getting punished for.

+ */

+ /**

+ * The guild the user is getting punished in.

+ */

+ user: Snowflake;

+ guild: Snowflake;

+ user: Snowflake;

+ guild: Snowflake;

+ user: Snowflake;

+ role: Snowflake;

+ guild: Snowflake;

+ user: Snowflake;

+ role?: Snowflake;

+ guild: Snowflake;

+ * The role added to the user.

+ */

+ role: Snowflake;

+ /**

+ role: {

+ type: DataTypes.STRING,

+ allowNull: false

+ },

+import { BushGuildMember, BushTask } from '@lib';

+

+export default class RemovePunishmentRole extends BushTask {

+ public constructor() {

+ super('removePunishmentRole', {

+ delay: 30_000, // 1/2 min

+ runOnStart: true

+ });

+ }

+ async exec(): Promise<void> {

+ const expiredEntries = await this.client.util.findExpiredEntries('role');

+ this.client.logger.verbose(

+ `RemovePunishmentRoleTask`,

+ `Queried punishment roles, found <<${expiredEntries.length}>> expired punishment roles.`

+ );

+

+ for (const entry of expiredEntries) {

+ const guild = this.client.guilds.cache.get(entry.guild);

+ if (!guild) {

+ await entry.destroy();

+ continue;

+ }

+

+ const member = guild.members.cache.get(entry.user) as BushGuildMember;

+ const result = await member.removePunishRole({ reason: 'Punishment expired.', role: entry.role });

+ if (['success', 'failed to dm'].includes(result)) await entry.destroy();

+ else throw result;

+

+ this.client.logger.verbose(`RemovePunishmentRoleTask`, `Removed a punishment role from ${entry.user}.`);

+ }

+ }

+}

+import { BushGuild, BushTask } from '@lib';

+ const rows = await this.client.util.findExpiredEntries('mute');

+

+ const guild = this.client.guilds.cache.get(row.guild) as BushGuild;

+

+ const result = await guild.unban({ user: row.user, reason: 'Punishment expired.' });

+ if (['success', 'user not banned'].includes(result)) await row.destroy();

+ else throw result;

+import { BushGuildMember, BushTask, Mute } from '@lib';

+

+ const member = guild.members.cache.get(row.user) as BushGuildMember;

+ const result = await member.unmute({ reason: 'Punishment expired.' });

+ if (['success', 'failed to dm'].includes(result)) await row.destroy();

+ else throw result;

+