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)