async def addmany_reactionroles(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 try: rr_message, nargs = await parse_channel_message(message, args, client) except lib_parsers.errors.message_parse_failure: return 1 args = args[nargs:] with db_hlapi(message.guild.id) as db: reactionroles = json.loads( db.grab_config("reaction-role-data") or "{}") for i in range(len(args) // 2): try: emoji = await valid_emoji(message, args[i * 2], client) role = await get_exact_role(message, args[i * 2 + 1]) await rindex_check(message, role) except (InvalidEmoji, NoRoleError, RindexFailure): return 1 if str(rr_message.id) in reactionroles: reactionroles[str(rr_message.id)][emoji] = role.id else: reactionroles[str(rr_message.id)] = {} reactionroles[str(rr_message.id)][emoji] = role.id with db_hlapi(message.guild.id) as db: db.add_config("reaction-role-data", json.dumps(reactionroles)) if kwargs["verbose"]: await message.channel.send("Added Multiple reactionroles")
async def rr_purge(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 try: message_id = int(args[0].replace("-", "/").split("/")[-1]) except IndexError: await message.channel.send("ERROR: No message id supplied") return 1 except ValueError: await message.channel.send("ERROR: Message id is not a valid int") return 1 with db_hlapi(message.guild.id) as db: reactionroles: Any = db.grab_config("reaction-role-data") if not reactionroles: await message.channel.send("ERROR: This guild has no reactionroles") return 1 reactionroles = json.loads(reactionroles) if str(message_id) in reactionroles: del reactionroles[str(message_id)] else: await message.channel.send("ERROR: This message has no reactionroles") return 1 with db_hlapi(message.guild.id) as db: db.add_config("reaction-role-data", json.dumps(reactionroles)) if kwargs["verbose"]: await message.channel.send( f"Purged reactionroles from message with id {message_id}")
async def update_csv_blacklist(message: discord.Message, args: List[str], name: str, verbose: bool = True, allowed: Optional[str] = None) -> None: if not message.guild: raise blacklist_input_error("No Guild Attached") if len(args) >= 2 and args[1] in ["rm", "remove"]: with db_hlapi(message.guild.id) as db: db.delete_config(name) await message.channel.send(f"Removed {name} config from database") return if not args or len(args) != 1: await message.channel.send(f"Malformed {name}") raise blacklist_input_error(f"Malformed {name}") if (allowed is not None) and not all(i in allowed for i in args[0]): await message.channel.send( f"The {name} does not support characters used, only supports {allowed}" ) raise blacklist_input_error("Unsupported chars") with db_hlapi(message.guild.id) as db: db.add_config(name, args[0]) if verbose: await message.channel.send(f"Updated {name} successfully")
async def parse_role(message: discord.Message, args: list[str], db_entry: str, verbose: bool = True) -> int: """ Parse a role from a command and put it into the db under the db_entry name :returns: int -- The success state of adding the role to the db, 0 being no error """ if not message.guild: await message.channel.send("ERROR: Could not resolve guild") return 1 if args: role_str: str = args[0].strip("<@&>") else: with db_hlapi(message.guild.id) as db: try: r_int = int(db.grab_config(db_entry) or 0) except ValueError: await message.channel.send( f"ERROR: {db_entry} is corrupt, please reset this role config" ) return 1 await message.channel.send( f"{db_entry} is {message.guild.get_role(r_int)}") return 0 if role_str in ["remove", "rm", "delete"]: with db_hlapi(message.guild.id) as db: db.delete_config(db_entry) await message.channel.send(f"Deleted {db_entry} role config") return 0 try: role = message.guild.get_role(int(role_str)) except ValueError: await message.channel.send(constants.sonnet.error_role.invalid) return 1 if not role: await message.channel.send(constants.sonnet.error_role.invalid) return 1 with db_hlapi(message.guild.id) as db: db.add_config(db_entry, str(role.id)) if verbose: await message.channel.send(f"Updated {db_entry} to {role}") return 0
async def set_usertrust_use(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if args: gate = bool(parse_boolean(args[0])) with db_hlapi(message.guild.id) as db: db.add_config("usertrust-enabled", str(int(gate))) if kwargs["verbose"]: await message.channel.send( f"Set usertrust enabled to {bool(gate)}") else: with db_hlapi(message.guild.id) as db: gate = bool(int(db.grab_config("usertrust-enabled") or "0")) await message.channel.send(f"Usertrust enabled is {bool(gate)}")
async def timestampedit(self, args: List[str], client: discord.Client) -> int: # notifier-log-timestamp cnf_name: Final[str] = "notifier-log-timestamp" if args: # I hate this code holy shit its so unreadable if args[0] == "add" and len(args) >= 2: # Add timestamp try: # Parse time jointime = MustParseDuration(args[1]) except lib_goparsers.errors.ParseFailureError: await self.m.channel.send("ERROR: Invalid time format") return 1 if jointime < 0 or jointime > 60 * 60 * 24 * 30: # Only allow JT up to a month, ive learned to never trust input the hard way await self.m.channel.send( "ERROR: Time range entered is larger than one month (~30 days)" ) return 1 with db_hlapi(self.guild.id) as db: # Add to db db.add_config(cnf_name, str(jointime)) await self.m.channel.send( f"Updated new user notify time to <{format_duration(jointime)} since creation" ) return 0 elif args[0] == "remove": # Remove timestamp with db_hlapi(self.guild.id) as db: db.delete_config(cnf_name) await self.m.channel.send("Deleted new user notify time") return 0 else: # Error await self.m.channel.send("Invalid args passed") return 1 else: # Show current timestamp with db_hlapi(self.guild.id) as db: jointime_str = db.grab_config(cnf_name) fmt = format_duration( int(jointime_str)) if jointime_str else "None" await self.m.channel.send(f"new user notify is set to {fmt}") return 0
async def set_embed_typec(message: discord.Message, args: List[str], typec: str, verbose: bool, ramfs: lexdpyk.ram_filesystem) -> int: if not message.guild: return 1 if args: if args[0] == "reset": with db_hlapi(message.guild.id) as db: db.delete_config(f"embed-color-{typec}") if verbose: await message.channel.send( f"Reset {typec}-color to its default value") return 0 try: colint: int = int(args[0], 16) except ValueError: await message.channel.send("ERROR: Not a valid color") return 1 else: with db_hlapi(message.guild.id) as db: colhex = db.grab_config(f"embed-color-{typec}") if colhex: await message.channel.send( f"{typec}-color is set to {zpadhex(int(colhex, 16))}") else: await message.channel.send( f"{typec}-color is not set (default: {zpadhex(load_embed_color(message.guild, typec, ramfs))})" ) return 0 if colint >= (2**24): await message.channel.send("ERROR: Color out of 24bit range") return 1 with db_hlapi(message.guild.id) as db: db.add_config(f"embed-color-{typec}", hex(colint)) if verbose: await message.channel.send( f"Updated {typec}-color to {zpadhex(colint)}") return 0
async def remove_reactionroles(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 try: rr_message, nargs = await parse_channel_message(message, args, client) except lib_parsers.errors.message_parse_failure: return 1 args = args[nargs:] if not args: await message.channel.send("ERROR: Not enough args supplied") return 1 try: emoji = await valid_emoji(message, args[0], client) except InvalidEmoji: return 1 with db_hlapi(message.guild.id) as db: reactionroles: Any = db.grab_config("reaction-role-data") if not reactionroles: await message.channel.send("ERROR: This guild has no reactionroles") return 1 reactionroles = json.loads(reactionroles) if str(rr_message.id) in reactionroles: if emoji in reactionroles[str(rr_message.id)]: del reactionroles[str(rr_message.id)][emoji] else: await message.channel.send( f"ERROR: This message does not have {emoji} reactionrole on it" ) return 1 else: await message.channel.send( "ERROR: This message has no reactionroles on it") return 1 with db_hlapi(message.guild.id) as db: db.add_config("reaction-role-data", json.dumps(reactionroles)) if kwargs["verbose"]: await message.channel.send( f"Removed reactionrole {emoji} from message id {rr_message.id}")
async def antispam_time_set(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 if args: try: mutetime = MustParseDuration(args[0]) except lib_goparsers.errors.ParseFailureError: await message.channel.send("ERROR: Invalid time format") return 1 else: mutetime = int(kwargs["conf_cache"]["antispam-time"]) await message.channel.send(f"Antispam mute time is {mutetime} seconds") return 0 if mutetime < 0: await message.channel.send("ERROR: Mutetime cannot be negative") return 1 elif mutetime >= 60 * 60 * 256: await message.channel.send( "ERROR: Mutetime cannot be greater than 256 hours") return 1 with db_hlapi(message.guild.id) as db: db.add_config("antispam-time", str(mutetime)) if kwargs["verbose"]: await message.channel.send( f"Set antispam mute time to {format_duration(mutetime)}")
async def faq_get(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 if not args: await message.channel.send("No args passed") return 1 with db_hlapi(message.guild.id) as db: db.inject_enum(faq_name, faq_enum) maybedata = db.grab_enum(faq_name, args[0]) if maybedata is None: await message.channel.send("ERROR: FAQ requested does not exist") return 1 _, _, content, perm = maybedata # pylint: disable=E0633 if await parse_permissions(message, kwargs["conf_cache"], str(perm), verbose=False): await message.channel.send(content) return 0 else: await message.channel.send( "You dont have permission to request this FAQ") return 1
async def __help_override__( message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Optional[Tuple[str, List[Tuple[str, str]]]]: if not message.guild: return None PREFIX = kwargs["conf_cache"]["prefix"] clist: List[Tuple[str, str]] = [(f"{PREFIX}{v['pretty_name']}", str(v["description"])) for _, v in commands.items()] clist.sort(key=lambda s: s[0]) with db_hlapi(message.guild.id) as db: db.inject_enum(faq_name, faq_enum) for i in sorted(db.list_enum(faq_name)): # We can cast here because list_enum confirmed its existance # pylint: disable=E0633 _, meta, _, _ = cast(Tuple[str, str, str, str], db.grab_enum(faq_name, i)) clist.append((f"{PREFIX}faq {i}", str(meta if meta else i)), ) faq_description = db.grab_config( "faq_description") or category_info["description"] # TODO(ultrabear) Custom description per guild return faq_description, clist
async def faq_set_description(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 if not args: await message.channel.send("ERROR: Missing FAQ name") return 1 if len(args) < 2: await message.channel.send("ERROR: Missing FAQ desc") return 1 name = args[0] desc = stripargs(message.content, 2) if len(desc) > 256: await message.channel.send("ERROR: FAQ description too large") return 1 with db_hlapi(message.guild.id) as db: db.inject_enum(faq_name, faq_enum) maybefaq = db.grab_enum(faq_name, name) if maybefaq is None: await message.channel.send("ERROR: FAQ entry does not exist") return 1 _, _, body, perm = maybefaq # pylint: disable=E0633 db.set_enum(faq_name, [name, desc, body, perm]) if kwargs["verbose"]: await message.channel.send(f"Updated description for FAQ entry {name}")
async def set_starboard_count(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 if args: try: count = int(args[0]) if count > 100: await message.channel.send( "ERROR: Cannot set a starboard count higher than 100") return 1 with db_hlapi(message.guild.id) as database: database.add_config("starboard-count", str(int(count))) if kwargs["verbose"]: await message.channel.send( f"Updated starboard count to {count}") except ValueError: await message.channel.send("ERROR: Invalid input, enter a number") return 1 else: mconf = load_message_config(message.guild.id, kwargs["ramfs"], datatypes=starboard_cache) count = int(mconf["starboard-count"]) await message.channel.send(f"Starboard count is {count}")
async def get_users_trust(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: try: user, _ = await parse_user_member(message, args, client, default_self=True) except lib_parsers.errors.user_parse_error: return 1 t_count: int with db_hlapi(message.guild.id) as db: db.inject_enum("usertrust", [("userID", str), ("count", int)]) trust = db.grab_enum("usertrust", str(user.id)) if trust and isinstance(trust[1], int): t_count = trust[1] else: t_count = 0 trusted = get_trust_pool(message.guild, kwargs["kernel_ramfs"]) fmt = f"```\nUser: {user}\nMcount: {t_count}\nHas Trusted Role: {user.id in trusted}\n```" await message.channel.send(fmt)
async def faq_set(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 if not args: await message.channel.send("ERROR: Missing FAQ name") return 1 if len(args) < 2: await message.channel.send("ERROR: Missing FAQ body") return 1 name = args[0] body = stripargs(message.content, 2) if len(body) > constants.message.content: await message.channel.send("ERROR: FAQ body too large") return 1 elif len(name) >= 32: await message.channel.send("ERROR: FAQ name too large") return 1 with db_hlapi(message.guild.id) as db: db.inject_enum(faq_name, faq_enum) db.set_enum(faq_name, [name, "", body, "everyone"]) if kwargs["verbose"]: await message.channel.send(f"Created new FAQ entry under name {name}")
async def set_blacklist_infraction_level(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 if args: action = args[0].lower() else: await message.channel.send( f"blacklist action is `{kwargs['conf_cache']['blacklist-action']}`" ) return if not action in ["warn", "kick", "mute", "ban"]: await message.channel.send( "ERROR: Blacklist action is not valid\nValid Actions: `warn` `mute` `kick` `ban`" ) return 1 with db_hlapi(message.guild.id) as database: database.add_config("blacklist-action", action) if kwargs["verbose"]: await message.channel.send(f"Updated blacklist action to `{action}`")
async def on_usertrust_message(message: discord.Message, **kargs: Any) -> None: if parse_skip_message(kargs["client"], message): return trusted = get_trust_pool(message.guild, kargs["kernel_ramfs"]) # Give up if user is already trusted if message.author.id in trusted: return utrust_cache = load_message_config(message.guild.id, kargs["ramfs"], datatypes=trust_types) if not bool(int(utrust_cache["usertrust-enabled"])): return with db_hlapi(message.guild.id) as db: db.inject_enum("usertrust", [("userID", str), ("count", int)]) # Inc counter if ucol := db.grab_enum("usertrust", str(message.author.id)): count = int(ucol[1]) + 1 else:
async def defaultpfpedit(self, args: List[str], client: discord.Client) -> int: # notifier-log-defaultpfp cnf_name: Final[str] = "notifier-log-defaultpfp" if args: with db_hlapi(self.guild.id) as db: db.add_config(cnf_name, str(true := int(parse_boolean(args[0])))) await self.m.channel.send( f"Updated defaultpfp checking to {bool(true)}") else: with db_hlapi(self.guild.id) as db: await self.m.channel.send( f"Defaultpfp checking is set to {bool(int(db.grab_config(cnf_name) or 0))}" ) return 0
async def on_ready(**kargs: Any) -> None: inc_statistics_better(0, "on-ready", kargs["kernel_ramfs"]) Client: discord.Client = kargs["client"] print(f'{Client.user} has connected to Discord!') # Warn if user is not bot if not Client.user.bot: print( "WARNING: The connected account is not a bot, as it is against ToS we do not condone user botting" ) # bot start time check to not reparse timers on network disconnect if kargs["bot_start"] > (time.time() - 10): with db_hlapi(None) as db: mutes: List[Tuple[str, str, str, int]] = db.fetch_all_mutes() lost_mutes = sorted(mutes, key=lambda a: a[3]) ts = datetime_now().timestamp() lost_mute_timers = [i for i in lost_mutes if 0 != i[3]] if lost_mute_timers: print(f"Lost mutes: {len(lost_mute_timers)}") for i in lost_mute_timers: if i[3] < ts: await attempt_unmute(Client, i) lost_mute_timers = [i for i in lost_mute_timers if i[3] >= ts] if lost_mute_timers: print( f"Mute timers to recover: {len(lost_mute_timers)}\nThis process will end in {round(lost_mutes[-1][3]-time.time())} seconds" ) for i in lost_mute_timers: await asyncio.sleep(i[3] - datetime_now().timestamp()) with db_hlapi(int(i[0])) as db: if db.is_muted(infractionid=i[1]): await attempt_unmute(Client, i) print("Mutes recovered")
async def clear_faq_description(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 with db_hlapi(message.guild.id) as db: db.delete_config("faq_description") if kwargs["verbose"]: await message.channel.send("Deleted FAQ help description")
async def attempt_unmute(Client: discord.Client, mute_entry: Tuple[str, str, str, int]) -> None: with db_hlapi(int(mute_entry[0])) as db: db.unmute_user(infractionid=mute_entry[1]) mute_role_id = db.grab_config("mute-role") if (guild := Client.get_guild(int(mute_entry[0]))) and mute_role_id: if (user := guild.get_member(int( mute_entry[2]))) and (mute_role := guild.get_role( int(mute_role_id))):
async def add_reactionroles(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 try: rr_message, nargs = await parse_channel_message(message, args, client) except lib_parsers.errors.message_parse_failure: return 1 args = args[nargs:] if len(args) < 2: await message.channel.send("ERROR: Not enough args supplied") return 1 try: emoji = await valid_emoji(message, args[0], client) role = await get_exact_role(message, args[1]) await rindex_check(message, role) except (InvalidEmoji, NoRoleError, RindexFailure): return 1 with db_hlapi(message.guild.id) as db: reactionroles = json.loads( db.grab_config("reaction-role-data") or "{}") if str(rr_message.id) in reactionroles: reactionroles[str(rr_message.id)][emoji] = role.id else: reactionroles[str(rr_message.id)] = {} reactionroles[str(rr_message.id)][emoji] = role.id with db_hlapi(message.guild.id) as db: db.add_config("reaction-role-data", json.dumps(reactionroles)) if kwargs["verbose"]: await message.channel.send( f"Added reactionrole to message id {rr_message.id}: {emoji}:{role.mention}", allowed_mentions=discord.AllowedMentions.none())
def parse_blacklist( indata: _parse_blacklist_inputs) -> tuple[bool, bool, list[str]]: """ Deprecated, this should be in dlib_messages.py Parse the blacklist over a message object :returns: Tuple[bool, bool, List[str]] -- broke blacklist, broke notifer list, list of strings of infraction messages """ message, blacklist, ramfs = indata if not message.guild: return False, False, [] # Preset values broke_blacklist = False notifier = False infraction_type = [] # Compilecheck regex try: ramfs.ls(f"{message.guild.id}/regex") except FileNotFoundError: with db_hlapi(message.guild.id) as db: reglist = {} for regex_type in ["regex-blacklist", "regex-notifier"]: if dat := db.grab_config(regex_type): reglist[regex_type] = [ " ".join(i.split(" ")[1:])[1:-2] for i in json.loads(dat)["blacklist"] ] else: reglist[regex_type] = [] for regex_type in ["regex-blacklist", "regex-notifier"]: ramfs.mkdir(f"{message.guild.id}/regex/{regex_type}") for i in reglist[regex_type]: regexname = hex( int.from_bytes( hashlib.sha256(i.encode("utf8")).digest(), "big"))[-32:] ramfs.create_f( f"{message.guild.id}/regex/{regex_type}/{regexname}", f_type=re.compile, f_args=[i]) if blacklist["url-blacklist"]: ramfs.create_f(f"{message.guild.id}/regex/url", f_type=re.compile, f_args=[_compileurl(blacklist["url-blacklist"])]) else: ramfs.create_f(f"{message.guild.id}/regex/url", f_type=returnsNone)
async def grab_mute_role(message: discord.Message, ramfs: lexdpyk.ram_filesystem) -> discord.Role: if not message.guild: raise NoMuteRole("No guild table to find mute role") with db_hlapi(message.guild.id) as db: mute_role = db.grab_config("mute-role") if mute_role and (mute_role_obj := message.guild.get_role( int(mute_role))): return mute_role_obj else:
async def set_prefix(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 if args: prefix = args[0] with db_hlapi(message.guild.id) as database: database.add_config("prefix", prefix) else: prefix = kwargs["conf_cache"]["prefix"] if kwargs["verbose"]: await message.channel.send(f"Prefix set to `{prefix}`")
async def on_message_delete(message: discord.Message, **kargs: Any) -> None: client: discord.Client = kargs["client"] kernel_ramfs: lexdpyk.ram_filesystem = kargs["kernel_ramfs"] ramfs: lexdpyk.ram_filesystem = kargs["ramfs"] # Ignore bots if parse_skip_message(client, message): return elif not message.guild: return files: Optional[List[discord.File]] = grab_files(message.guild.id, message.id, kernel_ramfs, delete=True) inc_statistics_better(message.guild.id, "on-message-delete", kernel_ramfs) # Add to log with db_hlapi(message.guild.id) as db: message_log = db.grab_config("message-log") try: if not (message_log and (log_channel := client.get_channel(int(message_log)))): return except ValueError: try: await message.channel.send("ERROR: message-log config is corrupt in database, please reset") except discord.errors.Forbidden: pass return if not isinstance(log_channel, discord.TextChannel): return message_embed = discord.Embed( title=f"Message deleted in #{message.channel}", description=message.content[:constants.embed.description], color=load_embed_color(message.guild, embed_colors.deletion, ramfs) ) # Parse for message lengths >2048 (discord now does 4000 hhhhhh) if len(message.content) > constants.embed.description: limend = constants.embed.description + constants.embed.field.value message_embed.add_field(name="(Continued)", value=message.content[constants.embed.description:limend]) if len(message.content) > limend: flimend = limend + constants.embed.field.value message_embed.add_field(name="(Continued further)", value=message.content[limend:flimend]) message_embed.set_author(name=f"{message.author} ({message.author.id})", icon_url=user_avatar_url(message.author)) if (r := message.reference) and (rr := r.resolved) and isinstance(rr, discord.Message): message_embed.add_field(name="Replying to:", value=f"{rr.author.mention} [(Link)]({rr.jump_url})")
async def char_antispam_set(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 if not args: antispam = kwargs["conf_cache"]["char-antispam"] await message.channel.send( f"CharAntispam timings are M:{antispam[0]},S:{antispam[1]},C:{antispam[2]}" ) return if len(args) == 1: try: messages, seconds, chars = [float(i) for i in args[0].split(",")] except ValueError: await message.channel.send("ERROR: Incorrect args supplied") return 1 elif len(args) > 1: try: messages = float(args[0]) seconds = float(args[1]) chars = float(args[2]) except ValueError: await message.channel.send("ERROR: Incorrect args supplied") return 1 # Prevent bullshit outside_range = "ERROR: Cannot go outside range" if not (2 <= messages <= 64): await message.channel.send(f"{outside_range} 2-64 messages") return 1 elif not (0 <= seconds <= 10): await message.channel.send(f"{outside_range} 0-10 seconds") return 1 elif not (128 <= chars <= 2**16): await message.channel.send(f"{outside_range} 128-{2**16} chars") return 1 with db_hlapi(message.guild.id) as database: database.add_config("char-antispam", f"{int(messages)},{seconds},{int(chars)}") if kwargs["verbose"]: await message.channel.send( f"Updated char antispam timings to M:{int(messages)},S:{seconds},C:{int(chars)}" )
async def sleep_and_unmute(guild: discord.Guild, member: discord.Member, infractionID: str, mute_role: discord.Role, mutetime: int, ramfs: lexdpyk.ram_filesystem) -> None: await asyncio.sleep(mutetime) # unmute in db with db_hlapi(guild.id) as db: if db.is_muted(infractionid=infractionID): db.unmute_user(infractionid=infractionID) try: await member.remove_roles(mute_role) except discord.errors.HTTPException: pass
async def usertrust_count(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: try: count = int(args[0]) except (ValueError, IndexError): await message.channel.send("ERROR: No int supplied or int is invalid") return 1 if 2**32 < count or count < 10: await message.channel.send( f"ERROR: Count cannot exceed range 10-{2**32}") with db_hlapi(message.guild.id) as db: db.add_config("usertrust-message-count", str(count)) await message.channel.send(f"Updated usertrust message count to {count}")
async def set_view_infractions(message: discord.Message, args: List[str], client: discord.Client, **kwargs: Any) -> Any: if not message.guild: return 1 gate: bool if args: gate = pb if isinstance( (pb := parse_boolean(args[0])), bool) else False with db_hlapi(message.guild.id) as db: db.add_config("member-view-infractions", str(int(gate))) if kwargs["verbose"]: await message.channel.send( f"Set member view own infractions to {gate}")