def removeHexFromProcessingDB(hexnite,real): if real: backend = FileBackend("./realdb") else: backend = FileBackend("./testdb") hex = backend.filter(hexes, {'hexnite': hexnite}) backend.delete(hex) 'Hexnite',hexnite,'removed from database'
def removeHexFromProcessingDB(hexnite, real): if real: backend = FileBackend("./realdb") else: backend = FileBackend("./testdb") hex = backend.filter(hexes, {'hexnite': hexnite}) backend.delete(hex) 'Hexnite', hexnite, 'removed from database'
class TwitchNotifier(commands.Cog): def __init__(self, bot): self.bot: 'PixlBot' = bot self.config = bot.config['TwitchNotifier'] self.backend = FileBackend('db') self.backend.autocommit = True self.bot.logger.info("Twitch notifier plugin ready") self.uuids = [] self.online_uuids = [] self.sslcontext = ssl.SSLContext() self.sslcontext.load_cert_chain(self.config['cert_path'], self.config['key_path']) self._twitch_init_() def _twitch_init_(self): self.bot.logger.info("Registering with Twitch...") self.twitch = Twitch(self.config['id'], self.config['secret']) self.twitch.authenticate_app([]) self.bot.logger.info( f"Registering webhook endpoint {self.config['myurl']} ...") self.hook = TwitchWebHook(self.config['myurl'], self.config['id'], self.config['port'], ssl_context=self.sslcontext) self.hook.authenticate(self.twitch) self.bot.logger.info("Clearing all hook subscriptions...") self.hook.unsubscribe_all(self.twitch) # Clear all subs on startup self.hook.start() self._register_all() def _login_to_id(self, name: str) -> Optional[str]: """Returns the twitch ID for a given login name, or None if the name couldn't be resolved.""" try: res: dict = self.twitch.get_users(logins=[name]) except TwitchBackendException as e: self.bot.logger.error(f"Backend error fetching user! {e}") return None if len(res) == 0: return None else: return res['data'][0]['id'] def _register_all(self): """Attempts to register stream_changed callbacks for all configured users.""" self.bot.logger.info("Registering callbacks for all watched users..") users = self.backend.filter(TwitchWatchedUser, {'twitch_name': { "$exists": True }}) if not users: self.bot.logger.info("No users to watch. No callbacks registered.") else: for u in users: self.bot.logger.info(f"Registering: {u['twitch_name']}") success, uuid = self.hook.subscribe_stream_changed( u['twitch_id'], self._cb_stream_changed) if success and uuid: self.uuids.append(uuid) self.bot.logger.info( f"{success}: registered subscription UUID: {uuid}") else: self.bot.logger.error( f"{success}: failed registering subscription: {uuid}") def _cb_stream_changed(self, uuid, data): """Callback for Twitch webhooks, fires on stream change event""" self.bot.logger.debug(f"Callback data for {uuid}: {data}") if data["type"] == "offline": if uuid in self.online_uuids: self.online_uuids.remove( uuid ) # Stupid twitch sending the same damn webhook multiple times... return else: self.bot.logger.debug( f"Ignoring duplicate offline callback for {uuid}") return elif data["type"] == "live": if uuid in self.online_uuids: self.bot.logger.debug( f"Ignoring duplicate live callback for {uuid}") return else: self.online_uuids.append(uuid) else: self.bot.logger.error( f"Got a callback type we can't handle: {data['type']}") return if uuid not in self.uuids: self.bot.logger.error( f"Got a callback for a UUID we're not tracking: {uuid}, my UUIDs: {self.uuids}" ) return try: item = self.backend.get(TwitchWatchedUser, {"twitch_id": data["user_id"]}) except TwitchWatchedUser.DoesNotExist: self.bot.logger.error( f"Got a callback for a USER we're not tracking: {data['user_id']} -> {data['user_name']}" ) return channel: discord.TextChannel = self.bot.get_channel( item['notify_channel']) width = 640 height = 360 url = data['thumbnail_url'].format(width=width, height=height) tu = self.twitch.get_users(data['user_id'])['data'][0] self.bot.logger.debug(tu) embed = discord.Embed( title=f"Now streaming {data['game_name']}", description=data['title'], color=discord.Color.green(), ) embed.set_image(url=url) embed.set_thumbnail(url=tu["profile_image_url"]) embed.set_author(name=item["twitch_name"], url=f"https://twitch.tv/{data['user_name']}") embed.add_field(name="Watch live at", value=f"https://twitch.tv/{data['user_name']}") self.bot.loop.create_task( channel. send( # This isn't an async function, so enqueue it manually embed=embed)) self.bot.logger.info( f"Successfully sent online notification for {data['user_id']}") @cog_ext.cog_subcommand( base="Twitchwatch", name="add_notification", description="Add a go live notification for Twitch", options=[twitch_name, notify_channel, notify_text], guild_ids=util.guilds) async def add_notification(self, ctx: SlashContext, twitch_name: str, notify_channel: discord.TextChannel, notify_text: str): twitch_id = self._login_to_id(twitch_name) try: self.backend.get(TwitchWatchedUser, {'twitch_name': twitch_name}) except TwitchWatchedUser.DoesNotExist: pass except TwitchWatchedUser.MultipleDocumentsReturned: self.bot.logger.error( "Multiple users returned - database inconsistent???") return if not twitch_id: await ctx.send(embed=mkembed( 'error', f"Unable to get the Twitch ID for the name {twitch_name}")) return await ctx.defer() # This bit can take a minute. success, uuid = self.hook.subscribe_stream_changed( twitch_id, self._cb_stream_changed) if success and uuid: self.uuids.append(uuid) self.bot.logger.info( f"{success}: registered subscription UUID: {uuid}") else: self.bot.logger.error( f"{success}: failed registering subscription: {uuid}") await ctx.send("Bluh, couldn't register the webhook with twitch :(" ) return item = TwitchWatchedUser({ 'twitch_name': twitch_name, 'twitch_id': twitch_id, 'discord_name': ctx.author.id, 'notify_channel': notify_channel.id, 'notify_text': notify_text, 'uuid': str(uuid) }) self.bot.logger.debug(f"DB object dump: {item.__dict__}") self.backend.save(item) await ctx.send(embed=mkembed("done", f"Notification added for {twitch_name}", channel=notify_channel.name)) @cog_ext.cog_subcommand( base="Twitchwatch", name="del_notification", description="Remove a go live notification for Twitch", options=[twitch_name], guild_ids=util.guilds) async def del_notification(self, ctx: SlashContext, twitch_name: str): try: item = self.backend.get(TwitchWatchedUser, {'twitch_name': twitch_name}) except TwitchWatchedUser.DoesNotExist: await ctx.send(embed=mkembed( "error", f"No notification exists for {twitch_name}")) return self.hook.unsubscribe(item['uuid']) self.bot.logger.info(f"Removing watch {item['uuid']}: {twitch_name}") self.backend.delete(item) if item['uuid'] in self.uuids: self.uuids.remove(item['uuid']) await ctx.send( embed=mkembed("done", f"Notification for {twitch_name} removed."))
class Profiles(object): def __init__(self, bot): self.bot = bot self.cfg = PluginConfig(self) self.db = FileBackend(self.cfg.get('main_db')) mtt = MessageRetargeter(bot) self.msg = mtt.msg web = Flask(__name__, template_folder=tmpl_dir) mako = MakoTemplates() mako.init_app(web) # Add routes here web.add_url_rule('/edit_web/<args>', 'edit_web', self.edit_web, methods=['GET', 'POST']) _thread.start_new_thread(web.run, (), {'host': '0.0.0.0'}) @command def learn(self, mask, target, args): """ Stores information allowing for later retrieval. Names are downcased for sanity. Usage: %%learn <name> <information>... """ name = args['<name>'].lower() info = ' '.join(args['<information>']) try: profile = self.db.get(Profile, {'name': name}) except Profile.DoesNotExist: profile = Profile( { 'name': name, 'owner': mask.nick.lower(), 'lines': [info], 'random': False, 'public': False } ) profile.save(self.db) self.db.commit() self.msg(mask, target, 'Your data "%s" has been stored.' % name) return except Profile.MultipleDocumentsReturned: self.msg(mask, target, "Found more than one %s. This is bad! Please notify the bot owner." % name) return if is_allowed_to(Action.edit, mask.nick, profile): lines_to_append = profile.lines lines_to_append.append(info) profile.save(self.db) self.db.commit() self.msg(mask, target, 'Your data "%s" has been updated.' % name) return else: self.msg(mask, target, 'You are not authorized to edit "%s". Ask %s instead.' % (name, profile.owner)) return @command def query(self, mask, target, args): """ Retrieve the information associated with <name>. If the item is marked random, then one random item will be returned. Usage: %%query <name> ?? <name> """ name = args['<name>'].lower() try: profile = self.db.get(Profile, {'name': name}) except Profile.DoesNotExist: self.msg(mask, target, 'I cannot find "%s" in the records.' % name) return if profile.random: self.msg(mask, target, get_flags(profile) + random.choice(profile.lines)) else: for line in profile.lines: self.msg(mask, target, get_flags(profile) + line) if len(profile.lines) >= int(self.cfg.get('throttle_max')): sleep(int(self.cfg.get('throttle_time'))) @command def forget(self, mask, target, args): """ Delete <name> from the records. Only the person who created the item can remove it. Usage: %%forget <name> """ name = args['<name>'].lower() try: profile = self.db.get(Profile, {'name': name}) except Profile.DoesNotExist: self.msg(mask, target, 'I cannot find "%s" in the records.' % name) return if is_allowed_to(Action.delete, mask.nick, profile): self.db.delete(profile) self.db.commit() self.msg(mask, target, "%s has been deleted." % name) else: self.msg(mask, target, 'You are not authorized to delete "%s". Ask %s instead.' % (name, profile.owner)) @command(permission='admin', show_in_help_list=False) def rmf(self, mask, target, args): """ Delete <name> from the records without checking permissions. Usage: %%rmf <name> """ name = args['<name>'].lower() try: profile = self.db.get(Profile, {'name': name}) except Profile.DoesNotExist: self.msg(mask, target, 'I cannot find "%s" in the records.' % name) return self.db.delete(profile) self.db.commit() self.msg(mask, target, "%s has been deleted." % name) @command(permission='admin', show_in_help_list=False) def chown(self, mask, target, args): """ Change the owner of <name> to <newowner>. Usage: %%chown <name> <newowner> """ name = args['<name>'].lower() newowner = args['<newowner>'].lower() try: profile = self.db.get(Profile, {'name': name}) except Profile.DoesNotExist: self.msg(mask, target, 'I cannot find "%s" in the records.' % name) return profile.owner = newowner self.db.save(profile) self.db.commit() self.msg(mask, target, "%s is now owned by %s." % (name, newowner)) @command def toggle_public(self, mask, target, args): """ Changes whether <name> is publicly editable or not Usage: %%toggle_public <name> """ profile = args['<name>'].lower() try: profile = self.db.get(Profile, {'name': profile}) except Profile.DoesNotExist: self.msg(mask, target, 'I cannot find "%s" in the records.' % profile) return if is_allowed_to(Action.edit, mask.nick, profile): if profile.public: profile.public = False self.msg(mask, target, '"%s" is no longer publicly editable.' % profile) else: profile.public = True self.msg(mask, target, '"%s" is now publicly editable.' % profile) self.db.save(profile) self.db.commit() return else: self.msg(mask, target, 'You are not authorized to edit "%s". Ask %s instead.' % (profile, profile.owner)) return @command def toggle_random(self, mask, target, args): """ Toggle the randomness of an item, so that it shows a single random line instead of all lines when queried. Usage: %%toggle_random <name> """ name = args['<name>'].lower() try: profile = self.db.get(Profile, {'name': name}) except Profile.DoesNotExist: self.msg(mask, target, 'I cannot find "%s" in the records.' % name) return if is_allowed_to(Action.edit, mask.nick, profile): profile.random = not profile.random self.msg(mask, target, 'Random mode for %s is set to: %s' % (profile.name, profile.random)) profile.save(self.db) self.db.commit() else: self.msg(mask, target, 'You are not authorized to edit "%s". Ask %s instead.' % (name, profile.owner)) irc3.base.logging.log(irc3.base.logging.WARN, "%s tried to edit %s, but can't since it's owned by %s" % (mask.nick, profile.name, profile.owner) ) @event("(@(?P<tags>\S+) )?:(?P<mask>\S+) PRIVMSG (?P<target>\S+) :\?\? (?P<data>.*)") def easy_query(self, mask, target, data): self.bot.get_plugin(Commands).on_command(cmd='query', mask=mask, target=target, data=data) #### # All web stuff below this point # @command def edit(self, mask, target, args): """ Sends you a webpage link to edit <name>. Great for longer profiles. Make sure to keep the URL you are given secure, as with it, anyone can edit your profiles. Usage: %%edit <name> """ # TODO: Clear any existing sessions the user has data = { 'id': str(uuid.uuid4()), 'name': mask.nick, 'profile': args['<name>'] } name = args['<name>'].lower() try: profile = self.db.get(Profile, {'name': name}) except Profile.DoesNotExist: self.msg(mask, target, 'I cannot find "%s" in the records.' % name) return if is_allowed_to(Action.fulledit, mask.nick, profile): newses = Session(data) self.db.save(newses) self.db.commit() self.bot.privmsg(mask.nick, "An editor has been set up for you at http://skaianet.tkware.us:5000/edit_web/%s" % str( data['id'])) self.bot.privmsg(mask.nick, "Be very careful not to expose this address - with it, anyone can edit your stuff") else: self.msg(mask, target, 'You are not authorized to webedit "%s". Ask %s instead.' % (name, profile.owner)) def edit_web(self, args): # Web endpoint: /edit_web/<args> if request.method == 'GET': # Does the session exist? try: edit_session = self.db.get(Session, {'id': args}) except Session.DoesNotExist: return render_template('youfail.html', bot=self.bot, failreason='Invalid Session', userfail=True) # Does the profile exist? name = edit_session.profile try: profile = self.db.get(Profile, {'name': name.lower()}) except Profile.DoesNotExist: return render_template('youfail.html', bot=self.bot, failreason='I cannot find "%s" in the records.' % name ) # Kick off to the edit page! return render_template('edit.html', bot=self.bot, profile=profile, username=edit_session.name, sessionid=edit_session.id ) elif request.method == 'POST': # We have to look up the session ID one more time. Something could have happened to the profile # since we created the session. try: edit_session = self.db.get(Session, {'id': request.form['ID']}) except Session.DoesNotExist: return render_template('youfail.html', bot=self.bot, failreason='Invalid Session', userfail=True) name = request.form['profile'] try: profile = self.db.get(Profile, {'name': request.form['profile']}) except Profile.DoesNotExist: return render_template('youfail.html', bot=self.bot, failreason='I cannot find "%s" in the records.' % name, userfail=True ) # Now with the profile in hand, blank the lines field and rebuild it from the form. # Here we grab all numeric items from the submission, sort it, and one by one refill the DB object. lines = [item for item in request.form if item.isdigit()] lines.sort() profile.lines = [] for item in lines: profile.lines.append(request.form[item]) self.db.save(profile) self.db.delete(edit_session) self.db.commit() return render_template('done.html', bot=self.bot, profile=profile.name )
class Responder(commands.Cog): def __init__(self, bot): self.bot = bot self.backend = FileBackend('db') self.backend.autocommit = True bot.logger.info("Responder plugin ready") def _find_one(self, name: str) -> Union[ResponseCommand, None]: """Searches for a response in the DB, returning it if found, or None if it doesn't exist or there are multiples. This exists to tie up the Blitzdb boilerplate in one place.""" try: comm = self.backend.get(ResponseCommand, {'command': name}) except ResponseCommand.DoesNotExist: return None except ResponseCommand.MultipleDocumentsReturned: self.bot.logger.error(f"_find_one discarding multiple results returned for '{name}'") return None else: return comm def _reply_allowed(self, comm: ResponseCommand, message: discord.Message) -> bool: """Determine whether a message can be replied to based on its attributes In general, if a user or channel restriction is set on a command, it can only be used when called in the listed channel or by the listed user. """ self.bot.logger.debug(f"Restriction dump: {comm.get('restrictions')}") if not comm.get("restrictions"): # No restrictions on this command, we can respond without doing anything else. return True else: if comm["restrictions"].get("channels"): channels = comm["restrictions"]["channels"] if message.channel.id in channels: return True else: return False elif comm["restrictions"].get("users"): users = comm["restrictions"]["users"] if message.author.id in users: return True else: return False else: return True @cog_ext.cog_subcommand(base="Autoresponder", name="addresponse", description="Adds an automatic response to certain text", options=[respond_to, response], guild_ids=util.guilds) async def addresponse(self, ctx: SlashContext, respond_to: str, response: str): """Adds an automatic response to (name) as (response) The first word (name) is the text that will be replied to. Everything else is what it will be replied to with. If you want to reply to an entire phrase, enclose name in quotes.""" if self._find_one(respond_to): await ctx.send(embed=mkembed('error', f"'{respond_to}' already exists.")) return else: comm = ResponseCommand( {'command': respond_to, 'reply': response, 'creator_str': str(ctx.author), 'creator_id': ctx.author.id} ) self.backend.save(comm) self.bot.logger.info(f"'{response}' was added by {ctx.author.display_name}") await ctx.send(embed=mkembed('done', "Autoresponse saved.", reply_to=respond_to, reply_with=response)) @cog_ext.cog_subcommand(base="Autoresponder", name="delresponse", description="Removes an automatic reponse from certain text", options=[respond_to], guild_ids=util.guilds) async def delresponse(self, ctx: SlashContext, respond_to: str): """Removes an autoresponse. Only the initial creator of a response can remove it.""" comm = self._find_one(respond_to) if not comm: await ctx.send(embed=mkembed('error', f"{respond_to} is not defined.")) return elif not ctx.author.id == comm['creator_id']: await ctx.send( embed=mkembed('error', f"You are not the creator of {respond_to}. Ask {comm['creator_str']}")) else: self.backend.delete(comm) self.bot.logger.info(f"'{respond_to}' was deleted by {ctx.author.display_name}") await ctx.send(embed=mkembed('info', f"{respond_to} has been removed.")) # @commands.command() # @cog_ext.cog_subcommand(base="Autoresponder", name="limit_user", # description="Limit a response to triggering on a certain user. Leave users blank to remove.", # options=[respond_to, restrict_user], # guild_ids=util.guilds) async def limitchannel(self, ctx: SlashContext, respond_to: str, **kwargs): comm = self._find_one(respond_to) if not comm: await ctx.send(embed=mkembed('error', f"'{respond_to}' does not exist.")) return if not ctx.author.id == comm['creator_id']: await ctx.send( embed=mkembed('error', f"You are not the creator of '{respond_to}'. Ask {comm['creator_str']}")) return if len(kwargs) == 0: comm["restrictions"] = {} self.backend.save(comm) await ctx.send(embed=mkembed('done', f"All restrictions removed from {respond_to}")) return if kwargs['restrict_user']: if not comm.get("restrictions"): comm["restrictions"] = {} elif not comm["restrictions"].get("users"): comm["restrictions"]["users"] = [] comm["restrictions"]["users"] = list(set( comm["restrictions"]["users"] + [u.id for u in restrict_user] )) self.backend.save(comm) display_users = [self.bot.get_user(u).display_name for u in comm["restrictions"]["users"]] await ctx.send( embed=mkembed('done', 'User restriction updated:', command=comm['command'], users=display_users) ) if kwargs['restrict_channel']: if not comm.get("restrictions"): comm["restrictions"] = {} if not comm["restrictions"].get("channels"): comm["restrictions"]["channels"] = [] comm["restrictions"]["channels"] = list(set( comm["restrictions"]["channels"] + [c.id for c in ctx.message.channel_mentions] )) display_channels = [self.bot.get_channel(c).name for c in comm["restrictions"]["channels"]] self.backend.save(comm) await ctx.send( embed=mkembed('done', 'Channel restriction updated:', Command=comm['command'], Channels=display_channels ) ) @commands.command() async def responserestrictions(self, ctx: context, name: str): """Show the restriction list for a given command""" comm = self._find_one(name) if not comm: await ctx.send(embed=mkembed('error', f"{name} does not exist.")) return await ctx.send( embed=mkembed('info', f"Information for `{name}`", Reply=comm['reply'], Restrictions=comm.get('restrictions', 'None'), Creator=comm['creator_str'] ) ) @commands.Cog.listener() async def on_message(self, message: discord.message): comm = self._find_one(message.content) if comm and self._reply_allowed(comm, message): await message.channel.send(comm['reply'])
class Memos(object): def __init__(self, bot): self.bot = bot self.cfg = PluginConfig(self) self.db = FileBackend(self.cfg.get('main_db')) mtt = MessageRetargeter(bot) self.msg = mtt.msg @command def note(self, target, mask, args): """ Leaves a note for <name>, containing <text>. The next time I see <name> speak, I will deliver any notes they have waiting. Notes taken in private are delivered in private, and vice versa. Usage: %%note <name> <text>... """ if mask.is_channel: pubmsg = True else: pubmsg = False if args['<name>'] == self.bot.nick: self.msg(mask, target, "You can't leave notes for me, silly :)") return newmemo = Memo( { 'sender': target.nick.lower(), 'recipient': args['<name>'].lower(), 'public': pubmsg, 'timestamp': ctime(), 'text': ' '.join(args['<text>']) } ) newmemo.save(self.db) self.db.commit() confirmation_msg = "Your note for %s has been queued for delivery." % args['<name>'] self.msg(mask, target, confirmation_msg) @irc3.event(irc3.rfc.PRIVMSG) # Triggered on every message anywhere. def check_notes(self, target, mask, data, event): del data, event try: msgs = self.db.filter(Memo, {'recipient': mask.nick.lower()}) msgword = "message" if len(msgs) < 2 else "messages" # Fix: I have 1 messages for you! except Memo.DoesNotExist: return if len(msgs) == 0: return # Avoid telling people they have messages in public, if any of them are set public=False if contains_private_messages(msgs): self.msg(mask, mask.nick, "I have %s %s for you, %s!" % (len(msgs), msgword, mask.nick)) else: self.msg(mask, target, "I have %s %s for you, %s!" % (len(msgs), msgword, mask.nick)) # Actually deliver the memos for msg in msgs: # This looks ridiculous but we don't care about the timezone really, only the relative time # from the local system clock. now = datetime.datetime.strptime(ctime(), "%a %b %d %H:%M:%S %Y") reltime = humanize.naturaltime(now - datetime.datetime.strptime(msg.timestamp, "%a %b %d %H:%M:%S %Y")) message_text = "%s // %s // %s" % (msg.sender, reltime, msg.text) if msg.public: self.msg(mask, target, message_text) self.db.delete(msg) else: self.bot.privmsg(mask.nick, message_text) self.db.delete(msg) self.db.commit()
class Responder(commands.Cog): def __init__(self, bot): self.bot = bot self.backend = FileBackend('./responder-db') self.backend.autocommit = True bot.logger.info("Responder plugin ready") def _find_one(self, name: str) -> Union[ResponseCommand, None]: """Searches for a response in the DB, returning it if found, or None if it doesn't exist or there are multiples. This exists to tie up the Blitzdb boilerplate in one place.""" try: comm = self.backend.get(ResponseCommand, {'command': name}) except ResponseCommand.DoesNotExist: return None except ResponseCommand.MultipleDocumentsReturned: self.bot.logger.error( f"_find_one discarding multiple results returned for '{name}'") return None else: return comm def _reply_allowed(self, comm: ResponseCommand, message: discord.Message) -> bool: """Determine whether a message can be replied to based on its attributes In general, if a user or channel restriction is set on a command, it can only be used when called in the listed channel or by the listed user. """ self.bot.logger.debug(f"Restriction dump: {comm.get('restrictions')}") if not comm.get("restrictions"): # No restrictions on this command, we can respond without doing anything else. return True else: if comm["restrictions"].get("channels"): channels = comm["restrictions"]["channels"] if message.channel.id in channels: return True else: return False elif comm["restrictions"].get("users"): users = comm["restrictions"]["users"] if message.author.id in users: return True else: return False else: return True @commands.command() async def addresponse(self, ctx: context, name: str, *responsen): """Adds an automatic response to (name) as (response) The first word (name) is the text that will be replied to. Everything else is what it will be replied to with. If you want to reply to an entire phrase, enclose name in quotes.""" arg2 = " ".join(responsen) if self._find_one(name): await ctx.send(embed=mkembed('error', f"'{name}' already exists.")) return else: comm = ResponseCommand({ 'command': name, 'reply': arg2, 'creator_str': str(ctx.author), 'creator_id': ctx.author.id }) self.backend.save(comm) self.bot.logger.info( f"'{name}' was added by {ctx.author.display_name}") await ctx.send(embed=mkembed('done', f"Saved: {name} => {arg2}")) @commands.command() async def delresponse(self, ctx: context, name: str): """Removes an autoresponse. Only the initial creator of a response can remove it.""" comm = self._find_one(name) if not comm: ctx.send(embed=mkembed('error', f"{name} is not defined.")) return elif not ctx.author.id == comm['creator_id']: await ctx.send(embed=mkembed( 'error', f"You are not the creator of {name}. Ask {comm['creator_str']}" )) else: self.backend.delete(comm) self.bot.logger.info( f"'{name}' was deleted by {ctx.author.display_name}") await ctx.send(embed=mkembed('error', f"{name} has been removed.")) @commands.command() async def responselimit(self, ctx: context, name: str, *tags: str): """Adds a restriction mode on a response so it only triggers in certain circumstances. Tags is a space-separated list of users and channels that this responder will apply to. These must be discord tags or pings, i.e. discord must show them as links, not just text. If the word NONE is used, all restrictions are removed. """ comm = self._find_one(name) if not comm: await ctx.send(embed=mkembed('error', f"{name} does not exist.")) return if not ctx.author.id == comm['creator_id']: await ctx.send(embed=mkembed( 'error', f"You are not the creator of {name}. Ask {comm['creator_str']}" )) return if tags[0] == "NONE": comm["restrictions"] = {} self.backend.save(comm) await ctx.send( embed=mkembed('done', f"All restrictions removed from {name}")) return if ctx.message.mentions: if not comm.get("restrictions"): comm["restrictions"] = {} elif not comm["restrictions"].get("users"): comm["restrictions"]["users"] = [] comm["restrictions"]["users"] = list( set(comm["restrictions"]["users"] + [u.id for u in ctx.message.mentions])) self.backend.save(comm) display_users = [ self.bot.get_user(u).display_name for u in comm["restrictions"]["users"] ] await ctx.send(embed=mkembed('done', 'User restriction updated:', command=comm['command'], users=display_users)) if ctx.message.channel_mentions: if not comm.get("restrictions"): comm["restrictions"] = {} if not comm["restrictions"].get("channels"): comm["restrictions"]["channels"] = [] comm["restrictions"]["channels"] = list( set(comm["restrictions"]["channels"] + [c.id for c in ctx.message.channel_mentions])) display_channels = [ self.bot.get_channel(c).name for c in comm["restrictions"]["channels"] ] self.backend.save(comm) await ctx.send(embed=mkembed('done', 'Channel restriction updated:', Command=comm['command'], Channels=display_channels)) @commands.command() async def responserestrictions(self, ctx: context, name: str): """Show the restriction list for a given command""" comm = self._find_one(name) if not comm: await ctx.send(embed=mkembed('error', f"{name} does not exist.")) return await ctx.send( embed=mkembed('info', f"Information for `{name}`", Reply=comm['reply'], Restrictions=comm.get('restrictions', 'None'), Creator=comm['creator_str'])) @commands.Cog.listener() async def on_message(self, message: discord.message): comm = self._find_one(message.content) if comm and self._reply_allowed(comm, message): await message.channel.send(comm['reply'])