async def rw_player(self, ctx, player=None): """Player profile. player can be a player tag or a Discord member. """ server = ctx.message.server author = ctx.message.author member = None tag = None if player is None: tag = self.settings.get(server.id, {}).get(author.id) else: try: cvt = MemberConverter(ctx, player) member = cvt.convert() except BadArgument: # cannot convert to member. Assume argument is a tag tag = clean_tag(player) else: tag = self.settings.get(server.id, {}).get(member.id) if tag is None: await self.bot.say("Can’t find tag associated with user.") return try: p = await self.api.fetch_player(tag) except RushWarsAPIError as e: await self.bot.say("RushWarsAPIError") else: await self.bot.say(embed=RWEmbed.player(p))
async def _eq_elevated_queue(self, context: Context, student: str, instructor: str): """ Manages the placing of a student into an instructor's elevated queue :param context: Object containing information about the caller :param student: The student that is being sent into another instructor's queue :param instructor: The instructor that the student is being sent to :return: None """ member_conv = MemberConverter() try: student_id, instructor_id = await gather( member_conv.convert(context, student), member_conv.convert(context, instructor)) self.instructor_queue[instructor_id].append(student_id) logger.debug( f"{context.author} has placed {student_id} into {instructor_id}'s queue" ) recipient = await userToMember(instructor_id, context.bot) await recipient.send( f"{instructor_id} placed {student_id} in your elevated queue") if student in self.bad_dq_counter: del self.bad_dq_counter[student] except BadArgument: logger.error(f"{context.author} gave the incorrect arguments" f" for the eq command: {student} and {instructor}") await context.author.send( "One of the users you entered is not a valid user")
async def start(self, ctx, *players: commands.MemberConverter): channel = self.get_channel(ctx) if channel in self.games: await ctx.send( f"A game is already happening in here. The players are {[player.display_name for player in self.games[channel].players]}" ) players = [player for player in players] if not ctx.author in players: players.append(ctx.author) self.games[channel] = YahtzeeGame(players) await ctx.send( f"Game started with {[player.name for player in players]}")
async def ppsize(self, ctx, user_mention=None): async with ctx.channel.typing(): if (user_mention is None): member = ctx.author elif (is_mention.match(user_mention)): converter = MemberConverter() member = await converter.convert(ctx, user_mention) else: member = None text = "Command usage: `fbot ppsize` or `fbot ppsize <@mention>`" if (member is not None): ppsize = None if member.bot: text = "Bots don't have pps, you do know that?" else: try: ppsize = db.getppsize(member.id) if ppsize < 0: ppsize = random.randint(0, 16) db.updateppsize(member.id, ppsize) except: db.register(member.id) ppsize = random.randint(0, 16) db.updateppsize(member.id, ppsize) if (ppsize is not None): pp = "8" + "=" * ppsize + "D" text = f"{member.mention}'s ppsize: `{pp}`" await ctx.send(text, allowed_mentions=AllowedMentions.all())
async def strike(self, ctx, striketarget, numberofstrikes=1): converter = MemberConverter() striketargetstr = await converter.convert(ctx, striketarget) striketargetid = '<@!' + str(striketargetstr.id) + '>' striker = '<@!' + str(ctx.author.id) + '>' await StrikeCog.strikelog(self, striketargetid, striker) await StrikeCog.strikemod(self, striketargetid, numberofstrikes * 1)
async def updateIndivTimeRoles(ctx, arg): channel = ctx.channel server = ctx.guild rolesTrophies_ID, rolesTrophies_tds = getServerTimeRoles(server) timenow = datetime.now() mc = MemberConverter() member = await mc.convert(ctx, arg) print('Trying to update this user: '******'New Trophy', value=(updatedTrophies_ID[0]), # there should only be one anyway.. inline=False) else: emb = (discord.Embed( title="Membership Trophy Role Update", description=member.mention + " already has the correct trophy!" " Any erroneous trophies should have been removed..", color=0x49ad3f)) await channel.send(embed=emb)
async def get_user(bot, ctx, mention_or_id): if mention_or_id.isdigit(): member = bot.get_user(int(mention_or_id)) else: converter = MemberConverter() member = await converter.convert(ctx, mention_or_id) return member
async def joindate(ctx, *member): member = " ".join(member) converter = MemberConverter() member = await converter.convert(ctx, member) print(f"Member name: {member.name}. Nickname: {member.nick}") response = f"{str(member)} {member.nick} Joined: {member.joined_at}.\n" await ctx.send(response)
async def myjoindate(ctx): member = ctx.message.author.display_name converter = MemberConverter() member = await converter.convert(ctx, member) print(f"Member name: {member.name}. Nickname: {member.nick}") response = f"{str(member)} {member.nick} Joined: {member.joined_at}.\n" await ctx.send(response)
async def listGroupsCommand(self, context, groupName=None): messageToSend = '' mc = MemberConverter() if (groupName is None) or (groupName is RESERVED_WORDS) or ( groupName not in groupData ): # Conditions to list all groups (no name given, reserved words, or isn't in groupData) messageToSend += 'There are currently ' + str( len(groupData)) + ' groups on PWPG!\n' for n in groupData: messageToSend += n + ': ' if groupData[n]['description'] != 'No Description': messageToSend += groupData[n][ 'description'] # Add the description if the group has one messageToSend += '\n\tMembers: ' + str( len(groupData[n]['member'])) + '\n' elif groupName in groupData: messageToSend += groupName + ' has ' + str( len(groupData[groupName]['member']) ) + ' members.\n' # <groupName> has <number> members \n if groupData[groupName]['description'] != 'No Description': messageToSend += groupData[groupName][ 'description'] + '\n' # Add the description if the group has one messageToSend += '---' + '\n' for m in groupData[groupName]['member']: # Add each member # messageToSend += str(m) + '\n' member = await mc.convert(context, m) messageToSend += member.name + '\n' else: print('how did this even happen?') messageToSend += 'THIS SHOULD NOT BE SEEN!?' await context.send('```' + messageToSend + '```')
async def unmute(self, ctx, user='******'): """unmute someone/everyone in the voice channel you are connected to""" if user == 'all': if ctx.author.voice: for member in ctx.author.voice.channel.members: await member.edit(mute=False) embed = discord.Embed(title=':white_check_mark: Users have been unmuted :speaking_head:', description=f"users in `{ctx.author.voice.channel}` voice channel have been unmuted") await ctx.send(embed=embed) else: await ctx.send('**:x: you need to be in a voice channel to use this command**') else: try: converter = MemberConverter() member = await converter.convert(ctx, user) if member.voice: await member.edit(mute=False) await ctx.send("**:white_check_mark: user has been unmuted**") else: await ctx.send("**member is not in a voice channel. can't unmute**") except: await ctx.send(f"""**specify the user you want to unmute or type `all` to unmute everyone in the voice channel you are connected to by default all users will be unmuted**""")
async def pingGroupCommand(self, context, groupName, *, optionalMessage=None): if groupName in groupData: m = MemberConverter() # Assemble message to send. messageToSend = '`' + context.author.display_name + '` has pinged `' + groupName + '`.' if optionalMessage is not None: messageToSend += '\n' + optionalMessage # For each member in the group, # check user status and preference for offline ping # send the message if online or wants offline pings for u in groupData[groupName]['member']: user = await m.convert(context, u) if groupData[groupName]['member'][u].get('offlinePing') or ( user.status is Status.online or user.status is Status.idle): await user.send(messageToSend) else: print('no offline ping and they aren\'t online') return True else: print('ping error -> no group') return False
async def removeStudentFromQueue(self, context: Context, student: str = None): """ Removes a student from any and all queues they are on. @context: context object containing information about the caller @student: String uniquely identifying a student """ sender = context.author if student is None: logger.debug( f"{sender} used the remove command without specifying a student" ) await sender.send( f"You must specify a student to remove. For example `/remove {sender}`" ) else: member_conv = MemberConverter() try: student = await member_conv.convert(context, student) except BadArgument as err: logger.debug( f"{sender} called remove but student {student} could not be found." ) await sender.send(f"Student `{student}` not found.") return if student in self.OHQueue: self.OHQueue.remove(student) self._instructor_queue_find_and_remove(student) logger.debug(f"{sender} has removed {student} from all queues") await sender.send(f"You have removed {student} from all queues")
async def kick( self, ctx: Context, member: MemberConverter, *, reason: ModerationReason = "No reason specified.", ) -> None: """Kick a member from your server.""" if not isinstance(member, discord.Member): await ctx.send(embed=discord.Embed(description=dedent(f""" You cannot kick this member! {member.mention} [**`{member.id}`**] isn't a member of this server. You can only kick members in this server. """))) return embed = moderation_embed(ctx, action="kick", user=member, reason=reason, color=discord.Color.gold()) embed.timestamp = datetime.utcnow() embed.set_thumbnail(url=member.avatar_url_as(format="png", size=256)) await ctx.send(embed=embed) await member.kick(reason=reason)
async def sin_counter(self, ctx): desc_count: list = [(k, v) for k, v in sorted( self._sin_counter.items(), key=lambda x: x[1], reverse=True)] msg = '' converter = MemberConverter() for id, count in desc_count: msg += f'{await converter.convert(ctx=ctx, argument=id)} - {count}\n' await ctx.reply(msg)
async def revoke_invite(ctx, *args): await lock.acquire() try: if len(args) != 1: await safe_send_embed(ctx.message.channel, other_embed("Error", "This command requires 1 argument: A game ID.")) return mem1 = ctx.message.author # may not be discord.Member, potentially discord.User game_id = args[0] if game_id not in bot.games: await safe_send_embed(ctx.message.channel, other_embed("Error", "A game with the specified ID does not exist.")) return game = chess.pgn.read_game(io.StringIO(bot.games[game_id])) if str(mem1.id) != game.headers["White"]: await safe_send_embed(ctx.message.channel, other_embed("Error", "You were not invited to play that game.")) return if game.headers["Started"] != "False": await safe_send_embed(ctx.message.channel, other_embed("Error", "You have already accepted the invitation to play this game.")) return conv = MemberConverter() # need to instantiate new object, otherwise convert can't pass in self try: mem2 = await conv.convert(ctx, game.headers["Black"]) except Exception: mem2 = None last_timestamp = int(time.time()) emb = other_embed("Game Invitation Revoked", None, [127, 0, 255]) emb.add_field( name = "Game ID", value = game_id, inline = True ) emb.add_field( name = "White", value = str(mem1), inline = True ) emb.add_field( name = "Black", value = str(mem2), inline = True ) emb.add_field( name = "Invitation Timestamp", value = time.strftime("%A, %B %d, %Y at %H:%M:%S "+setup.timezone, time.localtime(int(game.headers["First_Timestamp"]))), inline = True ) emb.add_field( name = "Recent Timestamp", value = time.strftime("%A, %B %d, %Y at %H:%M:%S "+setup.timezone, time.localtime(last_timestamp)), inline = True ) await safe_send_embed(mem2, emb) await safe_send_embed(ctx.message.channel, emb) del bot.games[game_id] except Exception as e: await safe_send_embed(ctx.message.channel, error_embed(e)) finally: lock.release()
async def 참가자등록(ctx, *, join_member: str): global member_list converter = MemberConverter() # string을 discord.member으로 바꿔주는 converter member_list = [str(i) for i in join_member.split(" ")] # ' '를 기준으로 멤버를 나눠 리스트에 저장 for i in range(0, 8): # 각 리스트에 있는 string들을 converter으로 discord.member로 바꿔줌 tmp = member_list[i] member_list[i] = await converter.convert(ctx, tmp[0:]) print("참가자등록 완료")
async def ban(self, ctx, member: MemberConverter, delete_msg_days: int = 0, *args): if await self.is_banned(ctx.guild, member) is True: await ctx.send('User {} has already been banned.'.format( str(member.user))) return reason = "No reason" if len(args) > 0: reason = " ".join(args[:]) self.add_punishment(ctx, member, PunishmentType.BAN, True, reason) member.ban(delete_message_days=delete_msg_days, reason=reason) msg = 'Permanently banned member {} for {}.'.format( str(member.user), reason) self.console.log(msg) await ctx.send(msg)
async def resolveAsk(self, ctx, *args): if ctx.message.guild: try: if ctx.message.author.guild_permissions.administrator: if len(args) != 0: converter = MemberConverter() usrName = await converter.convert(ctx, args[0]) usrId = usrName.id channel = await usrName.create_dm() if len(args) == 1: await ctx.send("Resolved " + str(usrName) + "'s question") await channel.send("All questions were resolved!") postResolveAskAll(usrId) elif len(args) == 2: if self.is_integer(args[1]) is True: query = getAsk(usrId)[int(args[1]) - 1] await ctx.send("Resolved " + str(usrName) + "'s question index: " + str(args[1])) await channel.send("```\nQuestion " + str(args[1]) + ": \"" + query + "\" was resolved!\n```") postResolveAsk(str(int(args[1]) - 1), usrId) else: await ctx.send( "Invalid resolve command! Use !resolveAsk <user> <index> \"<message>\"" ) elif len(args) == 3: query = getAsk(usrId)[int(args[1]) - 1] resolveMsg = str(args[2]) await ctx.send("Resolved " + str(usrName) + "'s question index: " + str(args[1]) + " with message: " + resolveMsg) await channel.send( "```\nQuestion " + str(args[1]) + ": \"" + query + "\" was resolved with message:\n" + resolveMsg + "\n```") postResolveAsk(str(int(args[1]) - 1), usrId) else: await ctx.send( "Invalid resolve command! Use !resolveAsk <user> <index> \"<message>\"" ) else: await ctx.send( "Invalid resolve command! Use !resolveAsk <user> <index> \"<message>\"" ) else: await ctx.send("You do not have permissions to do this.") except: await ctx.send("Invalid user!") else: await ctx.send("This command can only be used in a server.")
class repl: reaction = '\N{CLOCKWISE RIGHTWARDS AND LEFTWARDS OPEN CIRCLE ARROWS}' target_finder = MemberConverter() def __init__(self): self.__name__ = 'repl' self.start_message = None self.channel = None self.target = None self.cleanup = False async def start(self, ctx, target=None): self.start_message = ctx.message self.channel = ctx.channel self.target = target and await self.target_finder.convert(ctx, target) self.cleanup = bool( self.target and self.channel.permissions_for(ctx.me).manage_messages) return 'REPL running for {} ({})'.format(self.target or 'no target', self.cleanup) async def stop(self, ctx): channel, self.channel = self.channel, None # Stop the repl session without losing reference to the channel async for msg in channel.history(after=self.start_message): if msg.author == ctx.me and msg.reactions: await msg.remove_reaction( self.reaction, ctx.me ) # Fails silently; reactions check is just for efficiency await self.start_message.delete() self.start_message = self.target = None await ctx.message.delete() async def __call__(self, ctx): return (self.target, self.channel) if self.running else None async def on_message(self, bot, message): if message.channel == self.channel and message.id != self.start_message.id: await message.add_reaction(self.reaction) async def redo(self, bot, reaction, member): if member.id != bot.user.id or reaction.emoji != self.reaction or reaction.message.channel != self.channel: return message = reaction.message if self.cleanup: async for msg in message.channel.history(after=message): if msg.author == self.target: await msg.delete() await message.delete() await self.channel.send(message.content) @property def running(self): return bool(self.channel)
async def setppsize(self, ctx, user_mention, ppsize: int): if (ppsize > 1950): await ctx.reply("Too big: ppsize exceeds max message length") elif (user_mention is None): await ctx.reply("baka") else: converter = MemberConverter() member = await converter.convert(ctx, user_mention) user_id = member.id db.updateppsize(user_id, ppsize)
async def find_response(self, ctx, member_id, time_sent, messages_dict, index): converter = MemberConverter() for channel in messages_dict: for message in messages_dict[channel]['messages'][(1 + index):]: #print("heyo, this is second" ,messages_dict[channel]['messages'].index(message), "this is",index) member = await converter.convert(ctx, message["author"][:-5]) if int(member.id) == int(member_id): if time_sent < message["created_at"]: difference = message["created_at"] - time_sent self.members_dict[int(member_id)].append(difference) return
async def parse(self, ctx, msg, settings): member_converter = MemberConverter() admin_ids = settings.admin_ids try: member = await member_converter.convert(ctx, msg.content) except CommandError: raise ValueError if member.id in settings.admin_ids: admin_ids.remove(member.id) else: admin_ids.append(member.id) return admin_ids
async def add_task(ctx, list_id, task, author=fridayID, pr=3, status="todo"): converter = MemberConverter() member = await converter.convert(ctx, author) if not add_task_check(pr, status): await ctx.channel.send( "Remember that the **priority** must be between **1** and **4** and the **status** must be choosen between **these**: \n\t" "`- todo`\n\t`- await`\n\t`- cancel`\n\t`- done`\n\t`- onwork`\n\t`- fixing`") elif check_users_guild(member) or author is fridayID: id_group = str(ctx.guild.id) task_list = read_task_list(id_group, list_id) new_task = Task(len(task_list) + 1, task, author, pr, status) task_list.append(new_task) write_task_list(id_group, list_id, task_list) await ctx.channel.send("Task **" + task + "** created successfully! " + reaction_emojis["thumb"])
async def ban(ctx, txt=None, *, reason=None): """Ban someone.""" if txt == None: return await ctx.send("``USAGE: ban <user> [reason]``") if reason == None: reason = f"No reason provided" for a in txt: if (a.isnumeric()) == True: try: user = await dozbot.fetch_user(txt) except: pass else: try: converter = MemberConverter() user = await converter.convert(ctx, txt) except: return await ctx.send(f"I can't find that user!") if user.id == ctx.author.id: return await ctx.send( f'Are you trying to use that on yourself {ctx.author.mention}?' ) try: # DM the banned user the reason of ban embed = discord.Embed( title='BAN NOTICE', description=f'You were banned from **{ctx.guild.name}**', colour=discord.Colour.red()) embed.add_field(name='REASON:', value=reason, inline=False) embed.set_footer( text=f'Banned by {ctx.message.author.name}', icon_url=ctx.message.author.avatar_url_as(static_format='png')) embed.set_image(url=BAN_GIF) await user.send(embed=embed) except: print( chalk.yellow( f"[NOTICE] CMD|BAN: Couldn't DM reason to {user}.")) dozbot_logs_webhook.send( f"```[NOTICE] CMD|BAN: Couldn't DM reason to {user}.```") try: # Tries to ban user await ctx.guild.ban(user, reason=reason) await ctx.send(f">>> {user} has been banned!\nReason: {reason}") except: return await ctx.send("I don't have permission to ban this user!")
async def unmute(self, ctx, *, member): print(f"{ctx.guild.name} - #{ctx.channel.name} - {ctx.author.name} - {ctx.message.content}") if not ctx.author.guild_permissions.manage_permissions: await ctx.send("You do not have the permissions to use this command.") return converter = MemberConverter() try: member = await converter.convert(ctx, member) except Exception: print(Exception) await ctx.send("Member not found.") return role = discord.utils.get(member.guild.roles, name = "Muted") await member.remove_roles(role) await ctx.send(member.display_name + ' was unmuted.')
def __init__(self, bot): #instance variables self.bot = bot self.equipment_requests_queue = deque() self.active_requests_queue = deque() self.converter = MemberConverter() self.user_converter = UserConverter() self.registered_users = dict() # open registered users spreadsheet USERS_WORKSHEET = 2 self.users_sheet = client.open('Inventory').get_worksheet( USERS_WORKSHEET) self.all_reg_users = self.users_sheet.get_all_values() row = 2 for entry in self.all_reg_users[1:]: user_id = self.users_sheet.cell( row, 1, value_render_option='FORMULA').value self.registered_users[user_id] = entry[1:] row += 1 self.my_user_id = "267374448720609281" self.initial_response = None self.initial_response_trimmed = None self.initial_response_length = 0 self.pid_response = None self.pid_length = 0 self.inventory_selection = None self.user_selection = None self.is_number = None self.is_cancelled = None self.equipment_selection = None self.equipment_selection_length = 0 self.equipment_selection_trimed = None self.item_id = None self.item_quantity = 0 self.can_take_this_many = None self.avl_item_quantity = 0 self.selected_item = None self.equipment_sheet = client.open('Inventory').get_worksheet(0)
async def summary(self, ctx, *, msg): user = "" user_toon = msg.strip() if not ctx.message.mentions: results = User.toon_search(user_toon) if results.first() is not None: for x in results: converter = MemberConverter() user = await converter.convert(ctx, x.discord_id) break else: user = ctx.message.mentions[0] user_summary = TextTools.list_summary(str(user.id), user.joined_at, str(ctx.message.guild.id)) for x in user_summary: await ctx.message.channel.send(x) await Users.get_profile_image(self, ctx=ctx, msg=user.mention)
async def censor(ctx, txt=None): """Auto delete someone's messages.""" if txt == None: txtnon = await ctx.send("``USAGE: censor <user>``") await asyncio.sleep(2) try: return await txtnon.delete() except: return for a in txt: if (a.isnumeric()) == True: try: user = await dozbot.fetch_user(txt) except: pass else: try: converter = MemberConverter() user = await converter.convert(ctx, txt) except: return await ctx.send( f"{ctx.author.mention}, I can't find that user!") if not user: return await ctx.send("Couldn't find that user!") if user.id == ctx.author.id: return await ctx.send( f"Are you trying to censor yourself {ctx.author.mention}?") query = {"_id": user.id} if (censor_db.count_documents(query) == 0): post = { "_id": user.id, "user": user.name + '#' + user.discriminator } censor_db.insert_one(post) await ctx.send(f"{user.mention}\nhttps://i.imgflip.com/3g5hqc.png") dozbot_logs_webhook.send( f'```[NOTICE]|CENSOR: Censored {user} ({user.id})```') else: censor_db.delete_one(query) await ctx.send(f"Uncensored {user}") dozbot_logs_webhook.send( f'```[NOTICE]|CENSOR: Unensored {user} ({user.id})```')
async def unmute(ctx, user): try: klap = discord.utils.get(ctx.message.guild.roles, name=role_for_mute) converter = MemberConverter() member = await converter.convert(ctx, user) emb = discord.Embed(title=f'Unmuted {member.name}. Take it slowly', color=0xFF3861) await member.remove_roles(klap) await ctx.send(embed=emb) except: err = discord.Embed(colour=0xdaf806, title="") err.add_field( name="Unable to execute!", value="You must mention user nickname after this command") err.set_footer( text=f'Make sure server got role named "{role_for_mute}"') await ctx.send(embed=err)