async def adduserrole(self, ctx, *, role=None):
"""Adds a new role to the user role system (admin only)."""
author = ctx.message.author
server = ctx.message.guild
channel = ctx.message.channel
usage = 'Usage: `{}adduserrole [role]`'.format(ctx.prefix)
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(server, "SuppressMentions"):
suppress = True
else:
suppress = False
isAdmin = self._is_admin(ctx.message.author, ctx.message.channel,
ctx.message.guild)
# Only allow admins to change server stats
if not isAdmin:
await channel.send(
'You do not have sufficient privileges to access this command.'
)
return
if role == None:
await ctx.send(usage)
return
if type(role) is str:
if role == "everyone":
role = "@everyone"
# It' a string - the hope continues
roleCheck = DisplayName.roleForName(role, server)
if not roleCheck:
msg = "I couldn't find **{}**...".format(role)
if suppress:
msg = Nullify.clean(msg)
await ctx.send(msg)
return
role = roleCheck
# Now we see if we already have that role in our list
try:
promoArray = self.settings.getServerStat(server, "UserRoles")
except Exception:
promoArray = []
if promoArray == None:
promoArray = []
for aRole in promoArray:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
# We found it - throw an error message and return
msg = '**{}** is already in the list.'.format(role.name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
# If we made it this far - then we can add it
promoArray.append({'ID': role.id, 'Name': role.name})
self.settings.setServerStat(server, "UserRoles", promoArray)
msg = '**{}** added to list.'.format(role.name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
async def check_temp_roles(self, member, temp_role):
# Get the current task
task = asyncio.Task.current_task()
#self._log("Temp Role Object:", value=temp_role, member=member)
# Get the cooldown and server id
c = int(temp_role["Cooldown"])
r_id = int(temp_role["ID"])
# Wait until we're ready to remove
timeleft = c-int(time.time())
#self._log("Time left check 1 - do we have time left?", value=timeleft, member=member)
if timeleft > 0:
await asyncio.sleep(timeleft)
# Resolve the role
role = DisplayName.roleForID(r_id, member.guild)
#self._log("Role check - is role?", value=role, member=member)
if not role:
# Doesn't exist - remove it
temp_roles = self.settings.getUserStat(member, member.guild, "TempRoles")
temp_roles.remove(temp_role)
self._remove_task(task)
return
# We have a role - let's see if we still need to keep it
c = temp_role["Cooldown"]
#self._log("Cooldown check - do we have a cooldown?", value=c, member=member)
if c == None:
# We now have this role forever
# One last check to make sure it all makes sense
found = False
temp_roles = self.settings.getUserStat(member, member.guild, "TempRoles")
if not role in member.roles:
temp_roles.remove(temp_role)
self.settings.setUserStat(member, member.guild, "TempRoles", temp_roles)
self._remove_task(task)
return
# We still have a cooldown
timeleft = c-int(time.time())
#self._log("Time left:", value=timeleft, member=member)
if timeleft > 0:
# Recalibrate
self.loop_list.append(self.bot.loop.create_task(self.check_temp_roles(member, temp_role)))
self._remove_task(task)
return
# Here - we're either past our cooldown, or who knows what else
#self._log("Past the cooldown - no time left - do we have the role?", value=(role in member.roles), member=member)
if role in member.roles:
#self._log("Removing the role now - on time (supposedly)", member=member, value=role)
# We have the role still - remove it
self.settings.role.rem_roles(member, [role])
# Remove the entry from our user settings
temp_roles = self.settings.getUserStat(member, member.guild, "TempRoles")
if not temp_roles:
temp_roles = []
if temp_role in temp_roles:
#self._log("Temp Role was in user settings - removing", member=member)
temp_roles.remove(temp_role)
self.settings.setUserStat(member, member.guild, "TempRoles", temp_roles)
# Check if we pm
if self.settings.getServerStat(member.guild, "TempRolePM") and "AddedBy" in temp_role:
try:
await member.send("**{}** was removed from your roles in *{}*.".format(role.name, member.guild.name))
except:
pass
self._remove_task(task)
async def untemp(self, ctx, member = None, role = None):
"""Removes the passed temp role from the passed user (bot-admin only)."""
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.guild, "SuppressMentions"):
suppress = True
else:
suppress = False
isAdmin = ctx.message.author.permissions_in(ctx.message.channel).administrator
if not isAdmin:
checkAdmin = self.settings.getServerStat(ctx.message.guild, "AdminArray")
for arole in ctx.message.author.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(arole.id):
isAdmin = True
# Only allow admins to change server stats
if not isAdmin:
await ctx.channel.send('You do not have sufficient privileges to access this command.')
return
if member == None or role == None:
msg = 'Usage: `{}untemp "[member]" "[role]"`'.format(ctx.prefix)
await ctx.channel.send(msg)
return
# Get member and role
member_from_name = DisplayName.memberForName(member, ctx.guild)
role_from_name = DisplayName.roleForName(role, ctx.guild)
if not member_from_name and not role_from_name:
msg = "I couldn't find either the role or member..."
await ctx.send(msg)
return
if not member_from_name:
msg = 'I couldn\'t find *{}*...'.format(member)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await ctx.send(msg)
return
if not role_from_name:
msg = 'I couldn\'t find *{}*...'.format(role)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await ctx.send(msg)
return
# Make sure our role is in the list
promoArray = self.settings.getServerStat(ctx.guild, "TempRoleList")
if not role_from_name.id in [int(x["ID"]) for x in promoArray]:
# No dice
await ctx.send("That role is not in the temp role list!")
return
# Check if the user has that role - and remove it
if not role_from_name in member_from_name.roles:
# Don't have it
await ctx.send("That user doesn't have that role!")
return
message = await ctx.send("Applying...")
# We should be able to remove it now
self.settings.role.rem_roles(member_from_name, [role_from_name])
user_roles = self.settings.getUserStat(member_from_name, ctx.guild, "TempRoles")
for r in user_roles:
if int(r["ID"]) == role_from_name.id:
user_roles.remove(r)
self.settings.setUserStat(member_from_name, ctx.guild, "TempRoles", user_roles)
break
msg = "*{}* was removed from **{}**.".format(
DisplayName.name(member_from_name),
role_from_name.name
)
# Announce it
if suppress:
msg = Nullify.clean(msg)
await message.edit(content=msg)
# Check if we pm
if self.settings.getServerStat(ctx.guild, "TempRolePM"):
try:
await member_from_name.send("**{}** was removed from your roles in *{}*.".format(role_from_name.name, ctx.guild.name))
except:
pass
async def gethw(self, ctx, *, user=None, search=None):
"""Searches the user's hardware for a specific search term."""
if not user:
usage = "Usage: `{}gethw [user] [search term]`".format(ctx.prefix)
await ctx.send(usage)
return
# Let's check for username and search term
parts = user.split()
memFromName = None
buildParts = None
for j in range(len(parts)):
# Reverse search direction
i = len(parts) - 1 - j
memFromName = None
buildParts = None
# Name = 0 up to i joined by space
nameStr = ' '.join(parts[0:i])
buildStr = ' '.join(parts[i:])
memFromName = DisplayName.memberForName(nameStr, ctx.guild)
if memFromName:
# Got a member - let's check the remainder length, and search!
if len(buildStr) < 3:
usage = "Search term must be at least 3 characters."
return await ctx.send(usage)
buildList = self.settings.getGlobalUserStat(
memFromName, "Hardware")
if buildList == None:
buildList = []
buildList = sorted(buildList, key=lambda x: x['Name'].lower())
foundStr = ''
foundCt = 0
for build in buildList:
bParts = build['Hardware']
for line in bParts.splitlines():
if buildStr.lower() in line.lower():
foundCt += 1
foundStr += '{}. **{}**\n {}\n'.format(
foundCt, build['Name'],
line.replace("`", "").replace("\\", ""))
if len(foundStr):
# We're in business
foundStr = "__**\"{}\" Results:**__\n\n".format(
buildStr, DisplayName.name(memFromName)) + foundStr
break
else:
# foundStr = 'Nothing found for "{}" in *{}\'s* builds.'.format(buildStr, DisplayName.name(memFromName))
# Nothing found...
memFromName = None
buildStr = None
if memFromName and len(foundStr):
# We're in business
return await Message.Message(
message=Utils.suppressed(ctx, foundStr)).send(ctx)
# If we're here - then we didn't find a member - set it to the author, and run another quick search
buildStr = user
if len(buildStr) < 3:
usage = "Search term must be at least 3 characters."
return await ctx.send(usage)
buildList = self.settings.getGlobalUserStat(ctx.author, "Hardware")
if buildList == None:
buildList = []
buildList = sorted(buildList, key=lambda x: x['Name'].lower())
foundStr = ''
foundCt = 0
for build in buildList:
bParts = build['Hardware']
for line in bParts.splitlines():
if buildStr.lower() in line.lower():
foundCt += 1
foundStr += '{}. **{}**\n {}\n'.format(
foundCt, build['Name'],
line.replace("`", "").replace("\\", ""))
if len(foundStr):
# We're in business
foundStr = "__**\"{}\" Results:**__\n\n".format(
buildStr) + foundStr
else:
foundStr = 'Nothing found for "{}".'.format(buildStr)
# Nothing found...
await Message.Message(message=Utils.suppressed(ctx, foundStr)
).send(ctx)
async def newhw(self, ctx):
"""Initiate a new-hardware conversation with the bot. The hardware added will also be set as the Main Build."""
buildList = self.settings.getGlobalUserStat(ctx.author, "Hardware")
if buildList == None:
buildList = []
hwChannel = None
if ctx.guild:
# Not a pm
hwChannel = self.settings.getServerStat(ctx.guild,
"HardwareChannel")
if not (not hwChannel or hwChannel == ""):
# We need the channel id
if not str(hwChannel) == str(ctx.channel.id):
msg = 'This isn\'t the channel for that...'
for chan in ctx.guild.channels:
if str(chan.id) == str(hwChannel):
msg = 'This isn\'t the channel for that. Take the hardware talk to the **{}** channel.'.format(
chan.name)
return await ctx.send(msg)
else:
hwChannel = self.bot.get_channel(hwChannel)
if not hwChannel:
# Nothing set - pm
hwChannel = ctx.author
# Make sure we're not already in a parts transaction
if str(ctx.author.id) in self.hwactive:
return await ctx.send(
"You're already in a hardware session! You can leave with `{}cancelhw`"
.format(ctx.prefix))
# Set our HWActive flag
hw_id = self.gen_id()
self.hwactive[str(ctx.author.id)] = hw_id
msg = 'Alright, *{}*, let\'s add a new build.\n\n'.format(
DisplayName.name(ctx.author))
if len(buildList) == 1:
msg += 'You currently have *1 build* on file.\n\n'
else:
msg += 'You currently have *{} builds* on file.\n\nLet\'s get started!'.format(
len(buildList))
try:
await hwChannel.send(msg)
except:
# Can't send to the destination
self._stop_hw(ctx.author)
if hwChannel == ctx.author:
# Must not accept pms
await ctx.send(
"It looks like you don't accept pms. Please enable them and try again."
)
return
if hwChannel == ctx.author and ctx.channel != ctx.author.dm_channel:
await ctx.message.add_reaction("📬")
msg = '*{}*, tell me what you\'d like to call this build (type stop to cancel):'.format(
DisplayName.name(ctx.author))
# Get the build name
newBuild = {'Main': True}
while True:
buildName = await self.prompt(hw_id, ctx, msg, hwChannel,
DisplayName.name(ctx.author))
if not buildName:
self._stop_hw(ctx.author)
return
buildExists = False
for build in buildList:
if build['Name'].lower() == buildName.content.lower():
mesg = 'It looks like you already have a build by that name, *{}*. Try again.'.format(
DisplayName.name(ctx.author))
await hwChannel.send(mesg)
buildExists = True
break
if not buildExists:
newBuild['Name'] = buildName.content
break
bname = Utils.suppressed(ctx, buildName.content)
msg = 'Alright, *{}*, what parts does "{}" have? (Please include *all* parts for this build - you can add new lines with *shift + enter*)\n'.format(
DisplayName.name(ctx.author), bname)
msg += 'You can also pass pcpartpicker links to have them formatted automagically - I can also format them using different styles.\n'
msg += 'For example: '
msg += '```https://pcpartpicker.com/list/123456 mdblock``` would format with the markdown block style.\n'
msg += 'Markdown styles available are *normal, md, mdblock, bold, bolditalic*'
while True:
parts = await self.prompt(hw_id, ctx, msg, hwChannel,
DisplayName.name(ctx.author))
if not parts:
self._stop_hw(ctx.author)
return
if 'pcpartpicker.com' in parts.content.lower():
# Possibly a pc partpicker link?
msg = 'It looks like you sent a pc part picker link - did you want me to try and format that? (y/n/stop)'
test = await self.confirm(hw_id, ctx, parts, hwChannel, msg)
if test == None:
self._stop_hw(ctx.author)
return
elif test == True:
partList = parts.content.split()
if len(partList) == 1:
partList.append(None)
output = None
try:
output = await PCPP.getMarkdown(
partList[0], partList[1], False)
except:
pass
#output = PCPP.getMarkdown(parts.content)
if not output:
msg = 'Something went wrong! Make sure you use a valid pcpartpicker link.'
await hwChannel.send(msg)
self._stop_hw(ctx.author)
return
if len(output) > 2000:
msg = "That's an *impressive* list of parts - but the max length allowed for messages in Discord is 2000 characters, and you're at *{}*.".format(
len(output))
msg += '\nMaybe see if you can prune up that list a bit and try again?'
await hwChannel.send(msg)
self._stop_hw(ctx.author)
return
# Make sure
conf = await self.confirm(hw_id, ctx, output, hwChannel,
None, ctx.author)
if conf == None:
# Timed out
self._stop_hw(ctx.author)
return
elif conf == False:
# Didn't get our answer
msg = 'Alright, *{}*, what parts does "{}" have? (Please include *all* parts for this build - you can add new lines with *shift + enter*)'.format(
DisplayName.name(ctx.author), bname)
continue
m = '{} set to:\n{}'.format(bname, output)
await hwChannel.send(m)
newBuild['Hardware'] = output
break
newBuild['Hardware'] = parts.content
break
# Check if we already have a main build and clear it
for build in buildList:
if build['Main']:
build['Main'] = False
buildList.append(newBuild)
self.settings.setGlobalUserStat(ctx.author, "Hardware", buildList)
msg = '*{}*, {} was created successfully! It has been set as your main build. To select a different main, you can use `{}mainhw`'.format(
DisplayName.name(ctx.author), bname, ctx.prefix)
self._stop_hw(ctx.author)
await hwChannel.send(msg)
async def confirm(self,
hw_id,
ctx,
message,
dest=None,
m=None,
author=None):
# Get author name
authorName = None
if author:
if type(author) is str:
authorName = author
else:
try:
authorName = DisplayName.name(author)
except Exception:
pass
else:
if message:
try:
author = message.author
except Exception:
pass
try:
authorName = DisplayName.name(message.author)
except Exception:
pass
if not dest:
dest = message.channel
if not m:
if authorName:
msg = '*{}*, I got:'.format(Utils.suppressed(ctx, authorName))
else:
msg = "I got:"
if type(message) is str:
msg2 = Utils.suppressed(ctx, message)
else:
msg2 = '{}'.format(Utils.suppressed(ctx, message.content))
msg3 = 'Is that correct? (y/n/stop)'
await dest.send(msg)
await dest.send(msg2)
await dest.send(msg3)
else:
msg = m
await dest.send(Utils.suppressed(ctx, msg))
while True:
def littleCheck(m):
return ctx.author.id == m.author.id and self.confirmCheck(
m, dest) and len(m.content)
try:
talk = await self.bot.wait_for('message',
check=littleCheck,
timeout=300)
except Exception:
talk = None
# See if we're still in the right context
if not hw_id == self.hwactive.get(str(ctx.author.id), None):
return None
# Hardware ended
if not self.stillHardwaring(ctx.author):
return None
if not talk:
if authorName:
msg = "*{}*, I'm out of time...".format(authorName)
else:
msg = "I'm out of time..."
await dest.send(msg)
return None
else:
# We got something
if talk.content.lower().startswith('y'):
return True
elif talk.content.lower().startswith('stop'):
if authorName:
msg = "No problem, *{}!* See you later!".format(
authorName)
else:
msg = "No problem! See you later!"
await dest.send(msg)
return None
else:
return False
async def edithw(self, ctx, *, build=None):
"""Edits a build from your build list."""
hwChannel = None
if ctx.guild:
# Not a pm
hwChannel = self.settings.getServerStat(ctx.guild,
"HardwareChannel")
if not (not hwChannel or hwChannel == ""):
# We need the channel id
if not str(hwChannel) == str(ctx.channel.id):
msg = 'This isn\'t the channel for that...'
for chan in ctx.guild.channels:
if str(chan.id) == str(hwChannel):
msg = 'This isn\'t the channel for that. Take the hardware talk to the **{}** channel.'.format(
chan.name)
break
return await ctx.send(Utils.suppressed(ctx, msg))
else:
hwChannel = self.bot.get_channel(hwChannel)
if not hwChannel:
# Nothing set - pm
hwChannel = ctx.author
# Make sure we're not already in a parts transaction
if str(ctx.author.id) in self.hwactive:
return await ctx.send(
"You're already in a hardware session! You can leave with `{}cancelhw`"
.format(ctx.prefix))
buildList = self.settings.getGlobalUserStat(ctx.author, "Hardware")
if buildList == None:
buildList = []
if not len(buildList):
# No parts!
msg = 'You have no builds on file! You can add some with the `{}newhw` command.'.format(
ctx.prefix)
return await ctx.send(msg)
buildList = sorted(buildList, key=lambda x: x['Name'].lower())
mainBuild = None
# Get build by name first - then by number
if build is not None:
for b in buildList:
if b['Name'].lower() == build.lower():
# Found it
mainBuild = b
break
if not mainBuild:
try:
build = int(build) - 1
if build >= 0 and build < len(buildList):
mainBuild = buildList[build]
except:
pass
else:
# No build passed - get the main if it exists
for b in buildList:
if b['Main']:
mainBuild = b
break
if not mainBuild:
msg = "I couldn't find that build or number."
return await ctx.send(msg)
# Set our HWActive flag
hw_id = self.gen_id()
self.hwactive[str(ctx.author.id)] = hw_id
# Here, we have a build
bname = Utils.suppressed(ctx, mainBuild['Name'])
bparts = Utils.suppressed(ctx, mainBuild['Hardware'])
msg = '"{}"\'s current parts:'.format(bname)
try:
await hwChannel.send(msg)
except:
# Can't send to the destination
self._stop_hw(ctx.author)
if hwChannel == ctx.author:
# Must not accept pms
await ctx.send(
"It looks like you don't accept pms. Please enable them and try again."
)
return
if hwChannel == ctx.author and ctx.channel != ctx.author.dm_channel:
await ctx.message.add_reaction("📬")
await hwChannel.send(bparts)
msg = 'Alright, *{}*, what parts does "{}" have now? (Please include *all* parts for this build - you can add new lines with *shift + enter*)\n'.format(
DisplayName.name(ctx.author), bname)
msg += 'You can also pass pcpartpicker links to have them formatted automagically - I can also format them using different styles.\n'
msg += 'For example: '
msg += '```https://pcpartpicker.com/list/123456 mdblock``` would format with the markdown block style.\n'
msg += 'Markdown styles available are *normal, md, mdblock, bold, bolditalic*'
while True:
parts = await self.prompt(hw_id, ctx, msg, hwChannel,
DisplayName.name(ctx.author))
if not parts:
self._stop_hw(ctx.author)
return
if 'pcpartpicker.com' in parts.content.lower():
# Possibly a pc partpicker link?
msg = 'It looks like you sent a pc part picker link - did you want me to try and format that? (y/n/stop)'
test = await self.confirm(hw_id, ctx, parts, hwChannel, msg)
if test == None:
self._stop_hw(ctx.author)
return
elif test == True:
partList = parts.content.split()
if len(partList) == 1:
partList.append(None)
output = None
try:
output = await PCPP.getMarkdown(
partList[0], partList[1], False)
except:
pass
if not output:
msg = 'Something went wrong! Make sure you use a valid pcpartpicker link.'
await hwChannel.send(msg)
self._stop_hw(ctx.author)
return
if len(output) > 2000:
msg = "That's an *impressive* list of parts - but the max length allowed for messages in Discord is 2000 characters, and you're at *{}*.".format(
len(output))
msg += '\nMaybe see if you can prune up that list a bit and try again?'
await hwChannel.send(msg)
self._stop_hw(ctx.author)
return
# Make sure
conf = await self.confirm(hw_id, ctx, output, hwChannel,
None, ctx.author)
if conf == None:
# Timed out
self._stop_hw(ctx.author)
return
elif conf == False:
# Didn't get our answer
msg = 'Alright, *{}*, what parts does "{}" have now? (Please include *all* parts for this build - you can add new lines with *shift + enter*)'.format(
DisplayName.name(ctx.author), bname)
continue
m = '{} set to:\n{}'.format(bname, output)
await hwChannel.send(m)
mainBuild['Hardware'] = output
self.settings.setGlobalUserStat(ctx.author, "Hardware",
buildList)
break
mainBuild['Hardware'] = parts.content
self.settings.setGlobalUserStat(ctx.author, "Hardware", buildList)
break
msg = '*{}*, {} was edited successfully!'.format(
DisplayName.name(ctx.author), bname)
self._stop_hw(ctx.author)
await hwChannel.send(msg)
async def mute(self, ctx, *, member=None, cooldown=None):
"""Prevents a member from sending messages in chat (bot-admin only)."""
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.guild, "SuppressMentions"):
suppress = True
else:
suppress = False
isAdmin = ctx.message.author.permissions_in(
ctx.message.channel).administrator
if not isAdmin:
checkAdmin = self.settings.getServerStat(ctx.message.guild,
"AdminArray")
for role in ctx.message.author.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
isAdmin = True
# Only allow admins to change server stats
if not isAdmin:
await ctx.channel.send(
'You do not have sufficient privileges to access this command.'
)
return
if member == None:
msg = 'Usage: `{}mute [member] [cooldown]`'.format(ctx.prefix)
await ctx.channel.send(msg)
return
if cooldown == None:
# Either a cooldown wasn't set - or it's the last section
if type(member) is str:
# It' a string - the hope continues
# Let's search for a name at the beginning - and a time at the end
parts = member.split()
for j in range(len(parts)):
# Reverse search direction
i = len(parts) - 1 - j
memFromName = None
endTime = None
# Name = 0 up to i joined by space
nameStr = ' '.join(parts[0:i + 1])
# Time = end of name -> end of parts joined by space
timeStr = ' '.join(parts[i + 1:])
memFromName = DisplayName.memberForName(
nameStr, ctx.message.guild)
if memFromName:
# We got a member - let's check for time
# Get current time - and end time
try:
# Get current time - and end time
currentTime = int(time.time())
cal = parsedatetime.Calendar()
time_struct, parse_status = cal.parse(timeStr)
start = datetime(*time_struct[:6])
end = time.mktime(start.timetuple())
# Get the time from now to end time
endTime = end - currentTime
except:
pass
if not endTime == None:
# We got a member and a time - break
break
if memFromName == None:
# We couldn't find one or the other
msg = 'Usage: `{}mute [member] [cooldown]`'.format(
ctx.prefix)
await ctx.channel.send(msg)
return
if endTime == 0:
coolDown = None
else:
cooldown = endTime
member = memFromName
# Check if we're muting ourself
if member is ctx.message.author:
msg = 'It would be easier for me if you just *stayed quiet all by yourself...*'
await ctx.channel.send(msg)
return
# Check if we're muting the bot
if member.id == self.bot.user.id:
msg = 'How about we don\'t, and *pretend* we did...'
await ctx.channel.send(msg)
return
# Check if member is admin or bot admin
isAdmin = member.permissions_in(ctx.channel).administrator
if not isAdmin:
checkAdmin = self.settings.getServerStat(ctx.guild, "AdminArray")
for role in member.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
isAdmin = True
# Only allow admins to change server stats
if isAdmin:
await ctx.channel.send(
'You can\'t mute other admins or bot-admins.')
return
# Set cooldown - or clear it
if type(cooldown) is int or type(cooldown) is float:
if cooldown < 0:
msg = 'Cooldown cannot be a negative number!'
await ctx.channel.send(msg)
return
currentTime = int(time.time())
cooldownFinal = currentTime + cooldown
else:
cooldownFinal = None
mess = await ctx.send("Muting...")
# Do the actual muting
await self.muter.mute(member, ctx.message.guild, cooldownFinal)
if cooldown:
mins = "minutes"
checkRead = ReadableTime.getReadableTimeBetween(
currentTime, cooldownFinal)
msg = '*{}* has been **Muted** for *{}*.'.format(
DisplayName.name(member), checkRead)
pm = 'You have been **Muted** by *{}* for *{}*.\n\nYou will not be able to send messages on *{}* until either that time has passed, or you have been **Unmuted**.'.format(
DisplayName.name(ctx.message.author), checkRead,
self.suppressed(ctx.guild, ctx.guild.name))
else:
msg = '*{}* has been **Muted** *until further notice*.'.format(
DisplayName.name(member))
pm = 'You have been **Muted** by *{}* *until further notice*.\n\nYou will not be able to send messages on *{}* until you have been **Unmuted**.'.format(
DisplayName.name(ctx.message.author),
self.suppressed(ctx.guild, ctx.guild.name))
if suppress:
msg = Nullify.clean(msg)
await mess.edit(content=msg)
try:
await member.send(pm)
except Exception:
pass
async def addgif(self, ctx, *, role: str = None):
"""Adds a new role to the gif list (admin only)."""
usage = 'Usage: `{}addgif [role]`'.format(ctx.prefix)
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.guild, "SuppressMentions"):
suppress = True
else:
suppress = False
isAdmin = ctx.message.author.permissions_in(
ctx.message.channel).administrator
# Only allow admins to change server stats
if not isAdmin:
await ctx.message.channel.send(
'You do not have sufficient privileges to access this command.'
)
return
if role == None:
await ctx.message.channel.send(usage)
return
roleName = role
if type(role) is str:
if role.lower() == "everyone" or role.lower() == "@everyone":
role = ctx.guild.default_role
else:
role = DisplayName.roleForName(roleName, ctx.guild)
if not role:
msg = 'I couldn\'t find *{}*...'.format(roleName)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await ctx.message.channel.send(msg)
return
# Now we see if we already have that role in our list
promoArray = self.settings.getServerStat(ctx.message.guild, "GifArray")
for aRole in promoArray:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
# We found it - throw an error message and return
msg = '**{}** is already in the list.'.format(role.name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await ctx.message.channel.send(msg)
return
# If we made it this far - then we can add it
promoArray.append({'ID': role.id, 'Name': role.name})
self.settings.setServerStat(ctx.message.guild, "GifArray", promoArray)
msg = '**{}** added to list.'.format(role.name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await ctx.message.channel.send(msg)
return
async def listen(self, ctx, *, member=None):
"""Removes a member from the bot's "ignore" list (bot-admin only)."""
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.guild, "SuppressMentions"):
suppress = True
else:
suppress = False
isAdmin = ctx.message.author.permissions_in(
ctx.message.channel).administrator
if not isAdmin:
checkAdmin = self.settings.getServerStat(ctx.message.guild,
"AdminArray")
for role in ctx.message.author.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
isAdmin = True
# Only allow admins to change server stats
if not isAdmin:
await ctx.channel.send(
'You do not have sufficient privileges to access this command.'
)
return
if member == None:
msg = 'Usage: `{}listen [member]`'.format(ctx.prefix)
await ctx.channel.send(msg)
return
if type(member) is str:
memberName = member
member = DisplayName.memberForName(memberName, ctx.message.guild)
if not member:
msg = 'I couldn\'t find *{}*...'.format(memberName)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await ctx.channel.send(msg)
return
ignoreList = self.settings.getServerStat(ctx.message.guild,
"IgnoredUsers")
found = False
for user in ignoreList:
if str(member.id) == str(user["ID"]):
# Found our user - already ignored
found = True
msg = '*{}* no longer being ignored.'.format(
DisplayName.name(member))
ignoreList.remove(user)
self.settings.setServerStat(ctx.message.guild, "IgnoredUsers",
ignoreList)
if not found:
# Whatchu talkin bout Willis?
msg = '*{}* wasn\'t being ignored...'.format(
DisplayName.name(member))
await ctx.channel.send(msg)
async def ban(self, ctx, *, member: str = None):
"""Bans the selected member (bot-admin only)."""
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.guild, "SuppressMentions"):
suppress = True
else:
suppress = False
isAdmin = ctx.message.author.permissions_in(
ctx.message.channel).administrator
if not isAdmin:
checkAdmin = self.settings.getServerStat(ctx.message.guild,
"AdminArray")
for role in ctx.message.author.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
isAdmin = True
# Only allow admins to ban
if not isAdmin:
await ctx.channel.send(
'You do not have sufficient privileges to access this command.'
)
return
if not member:
await ctx.channel.send('Usage: `{}ban [member]`'.format(ctx.prefix)
)
return
# Resolve member name -> member
newMem = DisplayName.memberForName(member, ctx.message.guild)
if not newMem:
msg = 'I couldn\'t find *{}*.'.format(member)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await ctx.channel.send(msg)
return
# newMem = valid member
member = newMem
if member.id == ctx.message.author.id:
await ctx.channel.send('Ahh - the ol\' self-ban. Good try.')
return
# Check if we're banning the bot
if member.id == self.bot.user.id:
await ctx.channel.send(
'Oh - you probably meant to ban *yourself* instead, right?')
return
# Check if the targeted user is admin
isTAdmin = member.permissions_in(ctx.message.channel).administrator
if not isTAdmin:
checkAdmin = self.settings.getServerStat(ctx.message.guild,
"AdminArray")
for role in member.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
isTAdmin = True
# Can't ban other admins
if isTAdmin:
await ctx.channel.send(
'You can\'t ban other admins with this command.')
return
# We can ban
await ctx.channel.send(
'If this were live - you would have **banned** *{}*'.format(
DisplayName.name(member)))
async def setrole(self, ctx, *, role=None):
"""Sets your role from the user role list. You can only have one at a time."""
block_list = self.settings.getServerStat(ctx.guild, "UserRoleBlock")
if ctx.author.id in block_list:
await ctx.send("You are currently blocked from using this command."
)
return
server = ctx.message.guild
channel = ctx.message.channel
if not self.settings.getServerStat(server, "OnlyOneUserRole"):
await ctx.invoke(self.addrole, role=role)
return
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(server, "SuppressMentions"):
suppress = True
else:
suppress = False
# Get the array
try:
promoArray = self.settings.getServerStat(server, "UserRoles")
except Exception:
promoArray = []
if promoArray == None:
promoArray = []
if role == None:
# Remove us from all roles
remRole = []
for arole in promoArray:
roleTest = DisplayName.roleForID(arole['ID'], server)
if not roleTest:
# Not a real role - skip
continue
if roleTest in ctx.message.author.roles:
# We have this in our roles - remove it
remRole.append(roleTest)
if len(remRole):
self.settings.role.rem_roles(ctx.author, remRole)
# Give a quick status
msg = '*{}* has been moved out of all roles in the list!'.format(
DisplayName.name(ctx.message.author))
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
# Check if role is real
roleCheck = DisplayName.roleForName(role, server)
if not roleCheck:
# No luck...
msg = '*{}* not found in list.\n\nTo see a list of user roles - run `{}listuserroles`'.format(
role, ctx.prefix)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
# Got a role - set it
role = roleCheck
addRole = []
remRole = []
for arole in promoArray:
roleTest = DisplayName.roleForID(arole['ID'], server)
if not roleTest:
# Not a real role - skip
continue
if str(arole['ID']) == str(role.id):
# We found it!
addRole.append(roleTest)
elif roleTest in ctx.message.author.roles:
# Not our intended role and we have this in our roles - remove it
remRole.append(roleTest)
if not len(addRole):
# We didn't find that role
msg = '*{}* not found in list.\n\nTo see a list of user roles - run `{}listuserroles`'.format(
role.name, ctx.prefix)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
if len(remRole) or len(addRole):
self.settings.role.change_roles(ctx.author,
add_roles=addRole,
rem_roles=remRole)
msg = '*{}* has been moved to **{}!**'.format(
DisplayName.name(ctx.message.author), role.name)
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
async def addrole(self, ctx, *, role=None):
"""Adds a role from the user role list to your roles. You can have multiples at a time."""
block_list = self.settings.getServerStat(ctx.guild, "UserRoleBlock")
if ctx.author.id in block_list:
await ctx.send("You are currently blocked from using this command."
)
return
if role == None:
await ctx.send("Usage: `{}addrole [role name]`".format(ctx.prefix))
return
server = ctx.message.guild
channel = ctx.message.channel
if self.settings.getServerStat(server, "OnlyOneUserRole"):
await ctx.invoke(self.setrole, role=role)
return
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(server, "SuppressMentions"):
suppress = True
else:
suppress = False
# Get the array
try:
promoArray = self.settings.getServerStat(server, "UserRoles")
except Exception:
promoArray = []
if promoArray == None:
promoArray = []
# Check if role is real
roleCheck = DisplayName.roleForName(role, server)
if not roleCheck:
# No luck...
msg = '*{}* not found in list.\n\nTo see a list of user roles - run `{}listuserroles`'.format(
role, ctx.prefix)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
# Got a role - set it
role = roleCheck
addRole = []
for arole in promoArray:
roleTest = DisplayName.roleForID(arole['ID'], server)
if not roleTest:
# Not a real role - skip
continue
if str(arole['ID']) == str(role.id):
# We found it!
if roleTest in ctx.author.roles:
# We already have it
await ctx.send("You already have that role.")
return
addRole.append(roleTest)
break
if not len(addRole):
# We didn't find that role
msg = '*{}* not found in list.\n\nTo see a list of user roles - run `{}listuserroles`'.format(
role.name, ctx.prefix)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
if len(addRole):
self.settings.role.add_roles(ctx.author, addRole)
msg = '*{}* has acquired **{}!**'.format(
DisplayName.name(ctx.message.author), role.name)
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
async def removeuserrole(self, ctx, *, role=None):
"""Removes a role from the user role system (admin only)."""
author = ctx.message.author
server = ctx.message.guild
channel = ctx.message.channel
usage = 'Usage: `{}removeuserrole [role]`'.format(ctx.prefix)
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(server, "SuppressMentions"):
suppress = True
else:
suppress = False
isAdmin = self._is_admin(ctx.message.author, ctx.message.channel,
ctx.message.guild)
# Only allow admins to change server stats
if not isAdmin:
await channel.send(
'You do not have sufficient privileges to access this command.'
)
return
if role == None:
await channel.send(usage)
return
if type(role) is str:
if role == "everyone":
role = "@everyone"
# It' a string - the hope continues
# Let's clear out by name first - then by role id
try:
promoArray = self.settings.getServerStat(server, "UserRoles")
except Exception:
promoArray = []
if promoArray == None:
promoArray = []
for aRole in promoArray:
# Get the role that corresponds to the name
if aRole['Name'].lower() == role.lower():
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(server, "UserRoles",
promoArray)
msg = '**{}** removed successfully.'.format(aRole['Name'])
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
# At this point - no name
# Let's see if it's a role that's had a name change
roleCheck = DisplayName.roleForName(role, server)
if roleCheck:
# We got a role
# If we're here - then the role is an actual role
try:
promoArray = self.settings.getServerStat(
server, "UserRoles")
except Exception:
promoArray = []
if promoArray == None:
promoArray = []
for aRole in promoArray:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(roleCheck.id):
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(server, "UserRoles",
promoArray)
msg = '**{}** removed successfully.'.format(
aRole['Name'])
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
# If we made it this far - then we didn't find it
msg = '*{}* not found in list.'.format(roleCheck.name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
# If we're here - then the role is an actual role - I think?
try:
promoArray = self.settings.getServerStat(server, "UserRoles")
except Exception:
promoArray = []
if promoArray == None:
promoArray = []
for aRole in promoArray:
# Get the role that corresponds to the id
if str(arole['ID']) == str(role.id):
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(server, "UserRoles", promoArray)
msg = '**{}** removed successfully.'.format(aRole['Name'])
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
# If we made it this far - then we didn't find it
msg = '*{}* not found in list.'.format(role.name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
async def removexprole(self, ctx, *, role = None):
"""Removes a role from the xp promotion/demotion system (admin only)."""
author = ctx.message.author
server = ctx.message.server
channel = ctx.message.channel
usage = 'Usage: `{}removexprole [role]`'.format(ctx.prefix)
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(server, "SuppressMentions").lower() == "yes":
suppress = True
else:
suppress = False
isAdmin = author.permissions_in(channel).administrator
# Only allow admins to change server stats
if not isAdmin:
await self.bot.send_message(channel, 'You do not have sufficient privileges to access this command.')
return
if role == None:
await self.bot.send_message(channel, usage)
return
if type(role) is str:
if role == "everyone":
role = "@everyone"
# It' a string - the hope continues
# Let's clear out by name first - then by role id
promoArray = self.settings.getServerStat(server, "PromotionArray")
for aRole in promoArray:
# Get the role that corresponds to the name
if aRole['Name'].lower() == role.lower():
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(server, "PromotionArray", promoArray)
msg = '**{}** removed successfully.'.format(aRole['Name'])
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(channel, msg)
return
# At this point - no name
# Let's see if it's a role that's had a name change
roleCheck = DisplayName.roleForName(role, server)
if roleCheck:
# We got a role
# If we're here - then the role is an actual role
promoArray = self.settings.getServerStat(server, "PromotionArray")
for aRole in promoArray:
# Get the role that corresponds to the id
if aRole['ID'] == roleCheck.id:
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(server, "PromotionArray", promoArray)
msg = '**{}** removed successfully.'.format(aRole['Name'])
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(channel, msg)
return
# If we made it this far - then we didn't find it
msg = '{} not found in list.'.format(roleCheck.name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(channel, msg)
return
# If we're here - then the role is an actual role - I think?
promoArray = self.settings.getServerStat(server, "PromotionArray")
for aRole in promoArray:
# Get the role that corresponds to the id
if aRole['ID'] == role.id:
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(server, "PromotionArray", promoArray)
msg = '**{}** removed successfully.'.format(aRole['Name'])
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(channel, msg)
return
# If we made it this far - then we didn't find it
msg = '{} not found in list.'.format(role.name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(channel, msg)
async def vk(self, ctx, *, user=None):
"""Places your vote to have the passed user kicked."""
# Should be a dict like this:
# { "ID" : 123456789, "Kicks" : [ { "ID" : 123456789, "Added" : 123456789 } ] }
if user == None:
await ctx.send("Usage: `{}vk [user]`".format(ctx.prefix))
return
mute_votes = self.settings.getServerStat(ctx.guild, "VotesToMute")
ment_votes = self.settings.getServerStat(ctx.guild, "VotesToMention")
mute_time = self.settings.getServerStat(ctx.guild, "VotesMuteTime")
ment_chan = self.settings.getServerStat(ctx.guild, "VoteKickChannel")
vote_ment = self.settings.getServerStat(ctx.guild, "VoteKickMention")
vote_anon = self.settings.getServerStat(ctx.guild, "VoteKickAnon")
if vote_anon:
await ctx.message.delete()
# Check if mention and mute are disabled
if (ment_votes == 0 or ment_chan == None
or ment_chan == None) and (mute_votes == 0 or mute_time == 0):
await ctx.send('This function is not setup yet.')
return
check_user = DisplayName.memberForName(user, ctx.guild)
if not check_user:
await ctx.send("I couldn't find *{}*...".format(
Nullify.clean(user)))
return
# Check if we're trying to kick ourselves
if check_user.id == ctx.author.id:
await ctx.send(
"You should probably find a way to be okay with yourself. Kicking yourself will get you nowhere."
)
return
# Check if we're trying to kick an admin
isAdmin = check_user.permissions_in(ctx.message.channel).administrator
if not isAdmin:
checkAdmin = self.settings.getServerStat(ctx.message.guild,
"AdminArray")
for role in check_user.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
isAdmin = True
if isAdmin:
await ctx.channel.send(
'You cannot vote to kick the admins. Please work out any issues you may have with them in a civil manner.'
)
return
vote_list = self.settings.getServerStat(ctx.guild, "VoteKickArray")
for member in vote_list:
if member["ID"] == check_user.id:
# They're in the list - let's see if you've already voted for them
for vote in member["Kicks"]:
if vote["ID"] == ctx.author.id:
await ctx.send(
"You've already voted to kick that member. You cannot vote against them again while your vote is still active."
)
return
# We haven't voted for them yet - add our vote
member["Kicks"].append({
"ID": ctx.author.id,
"Added": time.time()
})
await ctx.send("Vote kick added for *{}!*".format(
DisplayName.name(check_user)))
await self._check_votes(ctx, check_user)
return
# Never found the member
vote_list.append({
"ID": check_user.id,
"Muted": False,
"Mentioned": False,
"Kicks": [{
"ID": ctx.author.id,
"Added": time.time()
}]
})
await ctx.send("Vote kick added for *{}!*".format(
DisplayName.name(check_user)))
await self._check_votes(ctx, check_user)
async def removeadmin(self, ctx, *, role : str = None):
"""Removes a role from the admin list (admin only)."""
usage = 'Usage: `{}removeadmin [role]`'.format(ctx.prefix)
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.server, "SuppressMentions").lower() == "yes":
suppress = True
else:
suppress = False
isAdmin = ctx.message.author.permissions_in(ctx.message.channel).administrator
# Only allow admins to change server stats
if not isAdmin:
await self.bot.send_message(ctx.message.channel, 'You do not have sufficient privileges to access this command.')
return
if role == None:
await self.bot.send_message(ctx.message.channel, usage)
return
# Name placeholder
roleName = role
if type(role) is str:
if role == "everyone":
role = "@everyone"
# If this fails - role will be None, then we know to look at names only
role = DisplayName.roleForName(roleName, ctx.message.server)
# If we're here - then the role is a real one
promoArray = self.settings.getServerStat(ctx.message.server, "AdminArray")
for aRole in promoArray:
# Check for Name
if aRole['Name'].lower() == roleName.lower():
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(ctx.message.server, "AdminArray", promoArray)
msg = '**{}** removed successfully.'.format(aRole['Name'])
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(ctx.message.channel, msg)
return
# Get the role that corresponds to the id
if role and (aRole['ID'] == role.id):
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(ctx.message.server, "AdminArray", promoArray)
msg = '**{}** removed successfully.'.format(role.name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(ctx.message.channel, msg)
return
# If we made it this far - then we didn't find it
msg = '**{}** not found in list.'.format(aRole['Name'])
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(ctx.message.channel, msg)
async def madlibs(self, ctx):
"""Let's play MadLibs!"""
channel = ctx.message.channel
author = ctx.message.author
server = ctx.message.guild
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.guild,
"SuppressMentions").lower() == "yes":
suppress = True
else:
suppress = False
# Check if we have a MadLibs channel - and if so, restrict to that
channelID = self.settings.getServerStat(server, "MadLibsChannel")
if not (not channelID or channelID == ""):
# We need the channel id
if not str(channelID) == str(channel.id):
msg = 'This isn\'t the channel for that...'
for chan in server.channels:
if str(chan.id) == str(channelID):
msg = 'This isn\'t the channel for that. Take the MadLibs to the **{}** channel.'.format(
chan.name)
await channel.send(msg)
return
# Check if our folder exists
if not os.path.isdir("./Cogs/MadLibs"):
msg = 'I\'m not configured for MadLibs yet...'
await channel.send(msg)
return
# Folder exists - let's see if it has any files
choices = [] # Empty array
for file in os.listdir("./Cogs/MadLibs"):
if file.endswith(".txt"):
choices.append(file)
if len(choices) == 0:
# No madlibs...
msg = 'I\'m not configured for MadLibs yet...'
await channel.send(msg)
return
# Check if we're already in a game
if self.settings.getServerStat(server, "PlayingMadLibs"):
msg = 'I\'m already playing MadLibs - use `{}{} [your word]` to submit answers.'.format(
ctx.prefix, self.prefix)
await channel.send(msg)
return
self.settings.setServerStat(server, "PlayingMadLibs", "Yes")
# Get a random madlib from those available
randnum = random.randint(0, (len(choices) - 1))
randLib = choices[randnum]
# Let's load our text and get to work
with open("./Cogs/MadLibs/{}".format(randLib), 'r') as myfile:
data = myfile.read()
# Set up an empty arry
words = []
# Match
matches = re.finditer(self.regex, data)
# Iterate matches
for match in matches:
words.append(match.group(0))
# Create empty substitution array
subs = []
# Iterate words and ask for input
i = 0
while i < len(words):
# Ask for the next word
vowels = "aeiou"
word = words[i][2:-2]
if word[:1].lower() in vowels:
msg = "I need an **{}** (word *{}/{}*). `{}{} [your word]`".format(
words[i][2:-2], str(i + 1), str(len(words)), ctx.prefix,
self.prefix)
else:
msg = "I need a **{}** (word *{}/{}*). `{}{} [your word]`".format(
words[i][2:-2], str(i + 1), str(len(words)), ctx.prefix,
self.prefix)
await channel.send(msg)
# Setup the check
def check(msg):
return msg.content.startswith("{}{}".format(
ctx.prefix, self.prefix)) and msg.channel == channel
# Wait for a response
try:
talk = await self.bot.wait_for('message',
check=check,
timeout=60)
except Exception:
talk = None
if not talk:
# We timed out - leave the loop
msg = "*{}*, I'm done waiting... we'll play another time.".format(
DisplayName.name(author))
await channel.send(msg)
self.settings.setServerStat(server, "PlayingMadLibs", None)
return
# Check if the message is to leave
if talk.content.lower().startswith('{}{}'.format(
ctx.prefix, self.leavePrefix.lower())):
if talk.author is author:
msg = "Alright, *{}*. We'll play another time.".format(
DisplayName.name(author))
await channel.send(msg)
self.settings.setServerStat(server, "PlayingMadLibs", None)
return
else:
# Not the originator
msg = "Only the originator (*{}*) can leave the MadLibs.".format(
DisplayName.name(author))
await channel.send(msg)
continue
# We got a relevant message
word = talk.content
# Let's remove the $ml prefix (with or without space)
if word.startswith('{}{} '.format(ctx.prefix.lower(),
self.prefix.lower())):
word = word[len(ctx.prefix) + len(self.prefix) + 1:]
if word.startswith('{}{}'.format(ctx.prefix.lower(),
self.prefix.lower())):
word = word[len(ctx.prefix) + len(self.prefix):]
# Check capitalization
if words[i][:3].isupper():
# Capitalized
word = string.capwords(word)
# Add to our list
subs.append(word)
# Increment our index
i += 1
# Let's replace
for asub in subs:
# Only replace the first occurence
data = re.sub(self.regex, "**{}**".format(asub), data, 1)
self.settings.setServerStat(server, "PlayingMadLibs", None)
# Check for suppress
if suppress:
data = Nullify.clean(data)
# Message the output
await channel.send(data)
async def prompt(self, hw_id, ctx, message, dest=None, author=None):
# Get author name
authorName = None
if author:
if type(author) is str:
authorName = author
else:
try:
authorName = DisplayName.name(author)
except Exception:
pass
else:
if message:
try:
author = message.author
except Exception:
pass
try:
authorName = DisplayName.name(message.author)
except Exception:
pass
if not dest:
dest = ctx.channel
await dest.send(Utils.suppressed(ctx, message))
while True:
def littleCheck(m):
return ctx.author.id == m.author.id and self.channelCheck(
m, dest) and len(m.content)
try:
talk = await self.bot.wait_for('message',
check=littleCheck,
timeout=300)
except Exception:
talk = None
# See if we're still in the right context
if not hw_id == self.hwactive.get(str(ctx.author.id), None):
return None
# Hardware ended
if not self.stillHardwaring(ctx.author):
return None
if not talk:
msg = "*{}*, I'm out of time...".format(authorName)
await dest.send(msg)
return None
else:
# Check for a stop
if talk.content.lower() == 'stop':
msg = "No problem, *{}!* See you later!".format(
authorName, ctx.prefix)
await dest.send(msg)
return None
# Make sure
conf = await self.confirm(hw_id, ctx, talk, dest, "", author)
if conf == True:
# We're sure - return the value
return talk
elif conf == False:
# Not sure - ask again
return await self.prompt(hw_id, ctx, message, dest, author)
else:
# Timed out
return None
async def torment(self, ctx, *, member=None, times: int = None):
"""Deals some vigilante justice (owner only)."""
channel = ctx.message.channel
author = ctx.message.author
server = ctx.message.guild
message = ctx.message
# Only allow owner to change server stats
isOwner = self.settings.isOwner(ctx.author)
if isOwner == None:
return
elif isOwner == False:
return
usage = 'Usage: `{}torment [role/member] [times]`'.format(ctx.prefix)
isRole = False
if member == None:
await ctx.channel.send(usage)
return
# Check for formatting issues
if times == None:
# Either xp wasn't set - or it's the last section
if type(member) is str:
# It' a string - the hope continues
roleCheck = DisplayName.checkRoleForInt(member, server)
if roleCheck and roleCheck["Role"]:
isRole = True
member = roleCheck["Role"]
times = roleCheck["Int"]
else:
# Role is invalid - check for member instead
nameCheck = DisplayName.checkNameForInt(member, server)
if not nameCheck:
await ctx.channel.send(usage)
return
if not nameCheck["Member"]:
msg = 'I couldn\'t find that user or role on the server.'.format(
member)
await ctx.channel.send(msg)
return
member = nameCheck["Member"]
times = nameCheck["Int"]
# Set the torment flag
self.toTorment = True
if times == None:
# Still no times - roll back to default
times = 25
if times > 100:
times = 100
if times == 0:
await ctx.channel.send(
'Oooooh - I bet they feel *sooooo* tormented...')
return
if times < 0:
await ctx.channel.send('I just uh... *un-tormented* them. Yeah.')
return
# Delete original torment message
await message.delete()
for i in range(0, times):
# Do this over time
try:
await channel.send('*{}*'.format(member.mention))
except Exception:
pass
for j in range(0, self.waitBetween):
# Wait for 1 second, then check if we should cancel - then wait some more
await asyncio.sleep(1)
if not self.toTorment:
return
async def renhw(self, ctx, *, build=None):
"""Renames a build from your build list."""
hwChannel = None
if ctx.guild:
# Not a pm
hwChannel = self.settings.getServerStat(ctx.guild,
"HardwareChannel")
if not (not hwChannel or hwChannel == ""):
# We need the channel id
if not str(hwChannel) == str(ctx.channel.id):
msg = 'This isn\'t the channel for that...'
for chan in ctx.guild.channels:
if str(chan.id) == str(hwChannel):
msg = 'This isn\'t the channel for that. Take the hardware talk to the **{}** channel.'.format(
chan.name)
await ctx.send(msg)
return
else:
hwChannel = self.bot.get_channel(hwChannel)
if not hwChannel:
# Nothing set - pm
hwChannel = ctx.author
# Make sure we're not already in a parts transaction
if str(ctx.author.id) in self.hwactive:
await ctx.send(
"You're already in a hardware session! You can leave with `{}cancelhw`"
.format(ctx.prefix))
return
buildList = self.settings.getGlobalUserStat(ctx.author, "Hardware")
if buildList == None:
buildList = []
if not len(buildList):
# No parts!
msg = 'You have no builds on file! You can add some with the `{}newhw` command.'.format(
ctx.prefix)
await ctx.send(msg)
return
buildList = sorted(buildList, key=lambda x: x['Name'].lower())
mainBuild = None
# Get build by name first - then by number
if build is not None:
for b in buildList:
if b['Name'].lower() == build.lower():
# Found it
mainBuild = b
break
if not mainBuild:
try:
build = int(build) - 1
if build >= 0 and build < len(buildList):
mainBuild = buildList[build]
except:
pass
else:
# No build passed - get the main if it exists
for b in buildList:
if b['Main']:
mainBuild = b
break
if not mainBuild:
msg = "I couldn't find that build or number."
await ctx.send(msg)
return
# Set our HWActive flag
hw_id = self.gen_id()
self.hwactive[str(ctx.author.id)] = hw_id
# Post the dm reaction
if hwChannel == ctx.author and ctx.channel != ctx.author.dm_channel:
await ctx.message.add_reaction("📬")
# Here, we have a build
bname = Utils.suppressed(ctx, mainBuild['Name'])
msg = 'Alright, *{}*, what do you want to rename "{}" to?'.format(
DisplayName.name(ctx.author), bname)
while True:
try:
buildName = await self.prompt(hw_id, ctx, msg, hwChannel,
DisplayName.name(ctx.author))
except:
# Can't send to the destination
self._stop_hw(ctx.author)
if hwChannel == ctx.author:
# Must not accept pms
await ctx.send(
"It looks like you don't accept pms. Please enable them and try again."
)
return
if not buildName:
self._stop_hw(ctx.author)
return
buildExists = False
for build in buildList:
if build['Name'].lower() == buildName.content.lower():
mesg = 'It looks like you already have a build by that name, *{}*. Try again.'.format(
DisplayName.name(ctx.author))
await hwChannel.send(mesg)
buildExists = True
break
if not buildExists:
mainBuild['Name'] = buildName.content
# Flush settings to all servers
self.settings.setGlobalUserStat(ctx.author, "Hardware",
buildList)
break
bname2 = Utils.suppressed(ctx, buildName.content)
msg = '*{}*, {} was renamed to {} successfully!'.format(
DisplayName.name(ctx.author), bname, bname2)
self._stop_hw(ctx.author)
await hwChannel.send(msg)
async def taginfo(self, ctx, *, name : str = None):
"""Displays info about a tag from the tag list."""
channel = ctx.message.channel
author = ctx.message.author
server = ctx.message.guild
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.guild, "SuppressMentions"):
suppress = True
else:
suppress = False
if not name:
msg = 'Usage: `{}taginfo "[tag name]"`'.format(ctx.prefix)
await channel.send(msg)
return
tagList = self.settings.getServerStat(server, "Tags")
if not tagList or tagList == []:
msg = 'No tags in list! You can add some with the `{}addtag "[tag name]" [tag]` command!'.format(ctx.prefix)
await channel.send(msg)
return
for atag in tagList:
if atag['Name'].lower() == name.lower():
currentTime = int(time.time())
msg = '**{}:**'.format(atag['Name'])
try:
memID = DisplayName.memberForID(atag['CreatedID'], server)
except KeyError as e:
memID = None
if memID:
msg = '{}\nCreated By: *{}*'.format(msg, DisplayName.name(memID))
else:
try:
msg = '{}\nCreated By: *{}*'.format(msg, atag['CreatedBy'])
except KeyError as e:
msg = '{}\nCreated By: `UNKNOWN`'.format(msg)
try:
createdTime = int(atag['Created'])
timeString = ReadableTime.getReadableTimeBetween(createdTime, currentTime)
msg = '{}\nCreated : *{}* ago'.format(msg, timeString)
except KeyError as e:
pass
try:
msg = '{}\nUpdated By: *{}*'.format(msg, atag['UpdatedBy'])
except KeyError as e:
pass
try:
createdTime = atag['Updated']
createdTime = int(createdTime)
timeString = ReadableTime.getReadableTimeBetween(createdTime, currentTime)
msg = '{}\nUpdated : *{}* ago'.format(msg, timeString)
except:
pass
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
return
msg = 'Tag "*{}*" not found!'.format(name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
async def rawhw(self, ctx, *, user: str = None, build=None):
"""Lists the raw markdown for either the user's default build - or the passed build."""
if not user:
user = "******".format(ctx.author.name, ctx.author.discriminator)
# Let's check for username and build name
parts = user.split()
memFromName = None
buildParts = None
for j in range(len(parts)):
# Reverse search direction
i = len(parts) - 1 - j
# Name = 0 up to i joined by space
nameStr = ' '.join(parts[0:i])
buildStr = ' '.join(parts[i:])
memFromName = DisplayName.memberForName(nameStr, ctx.guild)
if memFromName:
buildList = self.settings.getGlobalUserStat(
memFromName, "Hardware")
if buildList == None:
buildList = []
for build in buildList:
if build['Name'].lower() == buildStr.lower():
# Ha! Found it!
buildParts = build
break
if buildParts:
# We're in business
break
else:
memFromName = None
if not memFromName:
# Try again with numbers
for j in range(len(parts)):
# Reverse search direction
i = len(parts) - 1 - j
# Name = 0 up to i joined by space
nameStr = ' '.join(parts[0:i])
buildStr = ' '.join(parts[i:])
memFromName = DisplayName.memberForName(nameStr, ctx.guild)
if memFromName:
buildList = self.settings.getGlobalUserStat(
memFromName, "Hardware")
if buildList == None:
buildList = []
buildList = sorted(buildList,
key=lambda x: x['Name'].lower())
try:
buildStr = int(buildStr) - 1
if buildStr >= 0 and buildStr < len(buildList):
buildParts = buildList[buildStr]
except Exception:
memFromName = None
buildParts = None
if buildParts:
# We're in business
break
else:
memFromName = None
if not memFromName:
# One last shot - check if it's a build for us
buildList = self.settings.getGlobalUserStat(ctx.author, "Hardware")
if buildList == None:
buildList = []
buildList = sorted(buildList, key=lambda x: x['Name'].lower())
for build in buildList:
if build['Name'].lower() == user.lower():
memFromName = ctx.author
buildParts = build
break
if not memFromName:
# Okay - *this* time is the last - check for number
try:
user_as_build = int(user) - 1
if user_as_build >= 0 and user_as_build < len(buildList):
buildParts = buildList[user_as_build]
memFromName = ctx.author
except Exception:
pass
if not memFromName:
# Last check for a user passed as the only param
memFromName = DisplayName.memberForName(user, ctx.guild)
if not memFromName:
# We couldn't find them :(
msg = "I couldn't find that user/build combo..."
return await ctx.send(msg)
if buildParts == None:
# Check if that user has no builds
buildList = self.settings.getGlobalUserStat(
memFromName, "Hardware")
if buildList == None:
buildList = []
if not len(buildList):
# No parts!
msg = '*{}* has no builds on file! They can add some with the `{}newhw` command.'.format(
DisplayName.name(memFromName), ctx.prefix)
return await ctx.send(msg)
# Must be the default build
for build in buildList:
if build['Main']:
buildParts = build
break
if not buildParts:
# Well... uh... no defaults
msg = "I couldn't find that user/build combo..."
return await ctx.send(msg)
# At this point - we *should* have a user and a build
p = discord.utils.escape_markdown(buildParts['Hardware'])
msg = "__**{}'s {} (Raw Markdown):**__\n\n{}".format(
DisplayName.name(memFromName), buildParts['Name'], p)
await ctx.send(Utils.suppressed(ctx, msg))
async def addtag(self, ctx, name : str = None, *, tag : str = None):
"""Add a tag to the tag list."""
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.guild, "SuppressMentions"):
suppress = True
else:
suppress = False
channel = ctx.message.channel
author = ctx.message.author
server = ctx.message.guild
# Check for role requirements
requiredRole = self.settings.getServerStat(server, "RequiredTagRole")
if requiredRole == "":
#admin only
isAdmin = author.permissions_in(channel).administrator
if not isAdmin:
await channel.send('You do not have sufficient privileges to access this command.')
return
else:
#role requirement
hasPerms = False
for role in author.roles:
if str(role.id) == str(requiredRole):
hasPerms = True
if not hasPerms and not ctx.message.author.permissions_in(ctx.message.channel).administrator:
await channel.send('You do not have sufficient privileges to access this command.')
return
# Passed role requirements!
if name == None or tag == None:
msg = 'Usage: `{}addtag "[tag name]" [tag]`'.format(ctx.prefix)
await channel.send(msg)
return
tagList = self.settings.getServerStat(server, "Tags")
if not tagList:
tagList = []
found = False
currentTime = int(time.time())
for atag in tagList:
if atag['Name'].lower() == name.lower():
# The tag exists!
msg = '*{}* updated!'.format(name)
atag['URL'] = tag
atag['UpdatedBy'] = DisplayName.name(author)
atag['UpdatedID'] = author.id
atag['Updated'] = currentTime
found = True
if not found:
tagList.append({"Name" : name, "URL" : tag, "CreatedBy" : DisplayName.name(author), "CreatedID": author.id, "Created" : currentTime})
msg = '*{}* added to tag list!'.format(name)
self.settings.setServerStat(server, "Tags", tagList)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await channel.send(msg)
async def highfive(self, ctx, *, member: str = None):
"""It's like clapping with 2 people!"""
authorName = DisplayName.name(ctx.message.author)
# Check if we're eating nothing
if member == None:
nothingList = [
'you stand alone for an eternity, hand raised up - desperate for any sort of recognition...',
'with a wild swing you throw your hand forward - the momentum carries you to the ground and you just lay there - high fiveless...',
'the only sound you hear as a soft *whoosh* as your hand connects with nothing...'
]
randnum = random.randint(0, len(nothingList) - 1)
msg = '*{}*, {}'.format(authorName, nothingList[randnum])
msg = Nullify.clean(msg)
await ctx.channel.send(msg)
return
# Check if we're eating a member
memberCheck = DisplayName.memberForName(member, ctx.message.guild)
if memberCheck:
# We're eating a member - let's do a bot-check
if memberCheck.id == self.bot.user.id:
# It's me!
memberList = [
'the sky erupts with 1\'s and 0\'s as our hands meet in an epic high five of glory!',
'you beam up to the cloud and receive a quick high five from me before downloading back to Earth.',
'I unleash a fork-bomb of high five processes!',
'01001000011010010110011101101000001000000100011001101001011101100110010100100001'
]
elif memberCheck.id == ctx.message.author.id:
# We're eating... ourselves?
memberList = [
'ahh - high fiving yourself, classy...',
'that\'s uh... that\'s just clapping...',
'you run in a large circle - *totally* high fiving all your friends...',
'now you\'re at both ends of a high five!'
]
else:
memName = DisplayName.name(memberCheck)
memberList = [
'you and *{}* jump up for an epic high five - freeze-framing as the credits roll and some wicked 80s synth plays out.'
.format(memName),
'you and *{}* elevate to a higher plane of existence in wake of that tremendous high five!'
.format(memName),
'a 2 hour, 3 episode anime-esque fight scene unfolds as you and *{}* engage in a world-ending high five!'
.format(memName),
'it *was* tomorrow - before you and *{}* high fived with enough force to spin the Earth in reverse!'
.format(memName),
'like two righteous torpedoes - you and *{}* connect palms, subsequently deafening everyone in a 300-mile radius!'
.format(memName)
]
randnum = random.randint(0, len(memberList) - 1)
msg = '*{}*, {}'.format(authorName, memberList[randnum])
msg = Nullify.clean(msg)
await ctx.channel.send(msg)
return
# Assume we're eating something else
itemList = [
'neat... you just high fived *{}*.'.format(member),
'your hand flops through the air - hitting *{}* with a soft thud.'.
format(member),
'you reach out a hand, gently pressing your palm to *{}*. A soft *"high five"* escapes your lips as a tear runs down your cheek...'
.format(member),
'like an open-handed piston of ferocity - you drive your palm into *{}*.'
.format(member)
]
randnum = random.randint(0, len(itemList) - 1)
msg = '*{}*, {}'.format(authorName, itemList[randnum])
msg = Nullify.clean(msg)
await ctx.channel.send(msg)
return
async def feed(self, ctx, food : int = None):
"""Feed the bot some xp!"""
# feed the bot, and maybe you'll get something in return!
msg = 'Usage: `{}feed [xp reserve feeding]`'.format(ctx.prefix)
channel = ctx.message.channel
author = ctx.message.author
server = ctx.message.guild
if food == None:
await channel.send(msg)
return
if not type(food) == int:
await channel.send(msg)
return
isAdmin = author.permissions_in(channel).administrator
checkAdmin = self.settings.getServerStat(ctx.message.guild, "AdminArray")
# Check for bot admin
isBotAdmin = False
for role in ctx.message.author.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
isBotAdmin = True
break
botAdminAsAdmin = self.settings.getServerStat(server, "BotAdminAsAdmin")
adminUnlim = self.settings.getServerStat(server, "AdminUnlimited")
reserveXP = self.settings.getUserStat(author, server, "XPReserve")
minRole = self.settings.getServerStat(server, "MinimumXPRole")
requiredXP = self.settings.getServerStat(server, "RequiredXPRole")
isKill = self.settings.getServerStat(server, "Killed")
hunger = int(self.settings.getServerStat(server, "Hunger"))
xpblock = self.settings.getServerStat(server, "XpBlockArray")
approve = True
decrement = True
# Check Food
if food > int(reserveXP):
approve = False
msg = 'You can\'t feed me *{:,}*, you only have *{:,}* xp reserve!'.format(food, reserveXP)
if food < 0:
msg = 'You can\'t feed me less than nothing! You think this is funny?!'
approve = False
# Avoid admins gaining xp
decrement = False
if food == 0:
msg = 'You can\'t feed me *nothing!*'
approve = False
#if author.top_role.position < int(minRole):
#approve = False
#msg = 'You don\'t have the permissions to feed me.'
# RequiredXPRole
if not self._can_xp(author, server):
approve = False
msg = 'You don\'t have the permissions to feed me.'
# Check bot admin
if isBotAdmin and botAdminAsAdmin:
# Approve as admin
approve = True
if adminUnlim:
# No limit
decrement = False
else:
if food < 0:
# Don't decrement if negative
decrement = False
if food > int(reserveXP):
# Don't approve if we don't have enough
msg = 'You can\'t feed me *{:,}*, you only have *{:,}* xp reserve!'.format(food, reserveXP)
approve = False
# Check admin last - so it overrides anything else
if isAdmin:
# No limit - approve
approve = True
if adminUnlim:
# No limit
decrement = False
else:
if food < 0:
# Don't decrement if negative
decrement = False
if food > int(reserveXP):
# Don't approve if we don't have enough
msg = 'You can\'t feed me *{:,}*, you only have *{:,}* xp reserve!'.format(food, reserveXP)
approve = False
# Check if we're blocked
if ctx.author.id in xpblock:
msg = "You can't feed the bot!"
approve = False
else:
for role in ctx.author.roles:
if role.id in xpblock:
msg = "Your role cannot feed the bot!"
approve = False
if approve:
# Feed was approved - let's take the XPReserve right away
# Apply food - then check health
hunger -= food
self.settings.setServerStat(server, "Hunger", hunger)
takeReserve = -1*food
if decrement:
self.settings.incrementStat(author, server, "XPReserve", takeReserve)
if isKill:
# Bot's dead...
msg = '*{}* carelessly shoves *{:,} xp* into the carcass of *{}*... maybe resurrect them first next time?'.format(DisplayName.name(author), food, DisplayName.serverNick(self.bot.user, server))
await channel.send(msg)
return
# Bet more, less chance of winning, but more winnings!
chanceToWin = 50
payout = int(food*2)
# 1/chanceToWin that user will win - and payout is double the food
randnum = random.randint(1, chanceToWin)
if randnum == 1:
# YOU WON!!
self.settings.incrementStat(author, server, "XP", int(payout))
msg = '*{}\'s* offering of *{:,}* has made me feel *exceptionally* generous. Please accept this *magical* package with *{:,} xp!*'.format(DisplayName.name(author), food, int(payout))
# Got XP - let's see if we need to promote
await CheckRoles.checkroles(author, channel, self.settings, self.bot)
else:
msg = '*{}* fed me *{:,} xp!* Thank you, kind soul! Perhaps I\'ll spare you...'.format(DisplayName.name(author), food)
if hunger <= -150:
# Kill the bot here
self.settings.setServerStat(server, "Killed", True)
self.settings.setServerStat(server, "KilledBy", author.id)
msg = '{}\n\nI am kill...\n\n*{}* did it...'.format(msg, DisplayName.name(author))
elif hunger <= -100:
msg = '{}\n\nYou *are* going to kill me... Stop *now* if you have a heart!'.format(msg)
elif hunger <= -75:
msg = '{}\n\nI\'m looking fat to an extremely unhealthy degree... maybe you should think about *my* health?'.format(msg)
elif hunger <= -50:
msg = '{}\n\nI\'m obese :( ... Eating is my enemy right now.'.format(msg)
elif hunger <= -25:
msg = '{}\n\nI\'m kinda fat... Diet time?'.format(msg)
elif hunger <= -10:
msg = '{}\n\nI\'m getting pudgy... I may get fat if you keep going.'.format(msg)
elif hunger <= -1:
msg = '{}\n\nI\'m getting stuffed... maybe I should take a break from eating...'.format(msg)
elif hunger == 0:
msg = '{}\n\nIf you keep feeding me, I *may* get fat...'.format(msg)
await channel.send(msg)
async def hastemp(self, ctx, *, member = None):
"""Displays any temp roles the passed user has, and the remaining time."""
# Check for admin status
isAdmin = ctx.author.permissions_in(ctx.channel).administrator
if not isAdmin:
checkAdmin = self.settings.getServerStat(ctx.guild, "AdminArray")
for role in ctx.author.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
isAdmin = True
if not isAdmin:
await ctx.send("You do not have permission to use this command.")
return
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.guild, "SuppressMentions"):
suppress = True
else:
suppress = False
# Get the array
try:
promoArray = self.settings.getServerStat(server, "TempRoleList")
except Exception:
promoArray = []
if member == None:
member = ctx.author
else:
member_name = member
member = DisplayName.memberForName(member, ctx.guild)
if not member:
msg = 'I couldn\'t find *{}*...'.format(member_name)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await ctx.send(msg)
return
# Got the member - let's check for roles
temp_roles = self.settings.getUserStat(member, ctx.guild, "TempRoles")
if not len(temp_roles):
await ctx.send("*{}* has no logged temp roles!".format(DisplayName.name(member)))
return
roleText = "**__Current Temp Roles For {}:__**\n\n".format(DisplayName.name(member))
c = time.time()
for arole in temp_roles:
# Get current role name based on id
foundRole = False
timeleft = arole["Cooldown"]-int(time.time())
for role in ctx.guild.roles:
if str(role.id) == str(arole['ID']):
# We found it
foundRole = True
if not "AddedBy" in arole:
added = "automatically"
else:
add_user = DisplayName.name(DisplayName.memberForID(arole["AddedBy"], ctx.guild))
if not add_user:
add_user = str(arole["AddedBy"])
added = "by {}".format(add_user)
roleText = '{}**{}** - added {} - *{}* remain\n'.format(roleText, role.name, added, ReadableTime.getReadableTimeBetween(0, timeleft))
if not foundRole:
roleText = '{}**{}** (removed from server)\n'.format(roleText, arole['Name'])
# Check for suppress
if suppress:
roleText = Nullify.clean(roleText)
await ctx.send(roleText)
async def addxprole(self, ctx, *, role = None, xp : int = None):
"""Adds a new role to the xp promotion/demotion system (admin only)."""
author = ctx.message.author
server = ctx.message.server
channel = ctx.message.channel
usage = 'Usage: `{}addxprole [role] [required xp]`'.format(ctx.prefix)
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(server, "SuppressMentions").lower() == "yes":
suppress = True
else:
suppress = False
isAdmin = author.permissions_in(channel).administrator
# Only allow admins to change server stats
if not isAdmin:
await self.bot.send_message(channel, 'You do not have sufficient privileges to access this command.')
return
if xp == None:
# Either xp wasn't set - or it's the last section
if type(role) is str:
if role == "everyone":
role = "@everyone"
# It' a string - the hope continues
roleCheck = DisplayName.checkRoleForInt(role, server)
if not roleCheck:
await self.bot.send_message(ctx.message.channel, usage)
return
if not roleCheck["Role"]:
msg = 'I couldn\'t find *{}* on the server.'.format(role)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(ctx.message.channel, msg)
return
role = roleCheck["Role"]
xp = roleCheck["Int"]
if xp == None:
await self.bot.send_message(channel, usage)
return
if not type(xp) is int:
await self.bot.send_message(channel, usage)
return
# Now we see if we already have that role in our list
promoArray = self.settings.getServerStat(server, "PromotionArray")
for aRole in promoArray:
# Get the role that corresponds to the id
if aRole['ID'] == role.id:
# We found it - throw an error message and return
msg = '**{}** is already in the list. Required xp: *{}*'.format(role.name, aRole['XP'])
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(channel, msg)
return
# If we made it this far - then we can add it
promoArray.append({ 'ID' : role.id, 'Name' : role.name, 'XP' : xp })
self.settings.setServerStat(server, "PromotionArray", promoArray)
msg = '**{}** added to list. Required xp: *{}*'.format(role.name, xp)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await self.bot.send_message(channel, msg)
return
async def temp(self, ctx, member = None, role = None, *, cooldown = None):
"""Gives the passed member the temporary role for the passed amount of time - needs quotes around member and role (bot-admin only)."""
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(ctx.message.guild, "SuppressMentions"):
suppress = True
else:
suppress = False
isAdmin = ctx.message.author.permissions_in(ctx.message.channel).administrator
if not isAdmin:
checkAdmin = self.settings.getServerStat(ctx.message.guild, "AdminArray")
for arole in ctx.message.author.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(arole.id):
isAdmin = True
# Only allow admins to change server stats
if not isAdmin:
await ctx.channel.send('You do not have sufficient privileges to access this command.')
return
if member == None or role == None:
msg = 'Usage: `{}temp "[member]" "[role]" [cooldown]`'.format(ctx.prefix)
await ctx.channel.send(msg)
return
# Get member and role
member_from_name = DisplayName.memberForName(member, ctx.guild)
role_from_name = DisplayName.roleForName(role, ctx.guild)
if not member_from_name and not role_from_name:
msg = "I couldn't find either the role or member..."
await ctx.send(msg)
return
if not member_from_name:
msg = 'I couldn\'t find *{}*...'.format(member)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await ctx.send(msg)
return
# Don't allow us to temp admins or bot admins
isAdmin = member_from_name.permissions_in(ctx.channel).administrator
if not isAdmin:
checkAdmin = self.settings.getServerStat(ctx.guild, "AdminArray")
for arole in member_from_name.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(arole.id):
isAdmin = True
# Only allow admins to change server stats
if isAdmin:
await ctx.channel.send("You can't apply temp roles to other admins or bot-admins.")
return
if not role_from_name:
msg = 'I couldn\'t find *{}*...'.format(role)
# Check for suppress
if suppress:
msg = Nullify.clean(msg)
await ctx.send(msg)
return
# Make sure our role is in the list
promoArray = self.settings.getServerStat(ctx.guild, "TempRoleList")
if not role_from_name.id in [int(x["ID"]) for x in promoArray]:
# No dice
await ctx.send("That role is not in the temp role list!")
return
if cooldown == None:
await ctx.send("You must specify a time greater than 0 seconds.")
return
if not cooldown == None:
# Get the end time
end_time = None
try:
# Get current time - and end time
currentTime = int(time.time())
cal = parsedatetime.Calendar()
time_struct, parse_status = cal.parse(cooldown)
start = datetime(*time_struct[:6])
end = time.mktime(start.timetuple())
# Get the time from now to end time
end_time = end-currentTime
except:
pass
if end_time == None:
# We didn't get a time
await ctx.send("That time value is invalid.")
return
# Set the cooldown
cooldown = end_time
if cooldown < 1:
await ctx.send("You must specify a time greater than 0 seconds.")
return
message = await ctx.send("Applying...")
# Here we have a member, role, and end time - apply them!
user_roles = self.settings.getUserStat(member_from_name, ctx.guild, "TempRoles")
# Check and see if we're overriding a current time
found = False
temp_role = {}
for r in user_roles:
if int(r["ID"]) == role_from_name.id:
# Already have it - update the cooldown
r["Cooldown"] = cooldown + int(time.time()) if cooldown != None else cooldown
r["AddedBy"] = ctx.author.id
temp_role = r
found = True
break
if not found:
# Add it anew
temp_role["ID"] = role_from_name.id
temp_role["Cooldown"] = cooldown + int(time.time()) if cooldown != None else cooldown
temp_role["AddedBy"] = ctx.author.id
user_roles.append(temp_role)
self.settings.setUserStat(member_from_name, ctx.guild, "TempRoles", user_roles)
if not role_from_name in member_from_name.roles:
self.settings.role.add_roles(member_from_name, [role_from_name])
if not cooldown == None:
# We have a cooldown
msg = "*{}* has been given **{}** for *{}*.".format(
DisplayName.name(member_from_name),
role_from_name.name,
ReadableTime.getReadableTimeBetween(0, cooldown)
)
pm = "You have been given **{}** in *{}* for *{}*".format(
role_from_name.name,
ctx.guild.name,
ReadableTime.getReadableTimeBetween(0, cooldown)
)
self.loop_list.append(self.bot.loop.create_task(self.check_temp_roles(member_from_name, temp_role)))
else:
msg = "*{}* has been given **{}** *until further notice*.".format(
DisplayName.name(member_from_name),
role_from_name.name
)
pm = "You have been given **{}** in *{} until further notice*.".format(
role_from_name.name,
ctx.guild.name
)
# Announce it
if suppress:
msg = Nullify.clean(msg)
await message.edit(content=msg)
# Check if we pm
if self.settings.getServerStat(ctx.guild, "TempRolePM"):
try:
await member_from_name.send(pm)
except:
pass
async def removexprole(self, ctx, *, role=None):
"""Removes a role from the xp promotion/demotion system (admin only)."""
author = ctx.message.author
server = ctx.message.guild
channel = ctx.message.channel
usage = 'Usage: `{}removexprole [role]`'.format(ctx.prefix)
# Check if we're suppressing @here and @everyone mentions
if self.settings.getServerStat(server, "SuppressMentions"):
suppress = True
else:
suppress = False
if not await Utils.is_admin_reply(ctx): return
if role == None:
await channel.send(usage)
return
if type(role) is str:
if role == "everyone":
role = "@everyone"
# It' a string - the hope continues
# Let's clear out by name first - then by role id
promoArray = self.settings.getServerStat(server, "PromotionArray")
for aRole in promoArray:
# Get the role that corresponds to the name
if aRole['Name'].lower() == role.lower() or str(
aRole["ID"]) == str(role):
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(server, "PromotionArray",
promoArray)
msg = '**{}** removed successfully.'.format(aRole['Name'])
msg = Utils.suppressed(ctx, msg)
await channel.send(msg)
return
# At this point - no name
# Let's see if it's a role that's had a name change
roleCheck = DisplayName.roleForName(role, server)
if roleCheck:
# We got a role
# If we're here - then the role is an actual role
promoArray = self.settings.getServerStat(
server, "PromotionArray")
for aRole in promoArray:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(roleCheck.id):
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(server, "PromotionArray",
promoArray)
msg = '**{}** removed successfully.'.format(
aRole['Name'])
msg = Utils.suppressed(ctx, msg)
await channel.send(msg)
return
# If we made it this far - then we didn't find it
msg = '{} not found in list.'.format(role)
msg = Utils.suppressed(ctx, msg)
await channel.send(msg)
return
# If we're here - then the role is an actual role - I think?
promoArray = self.settings.getServerStat(server, "PromotionArray")
for aRole in promoArray:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
# We found it - let's remove it
promoArray.remove(aRole)
self.settings.setServerStat(server, "PromotionArray",
promoArray)
msg = '**{}** removed successfully.'.format(aRole['Name'])
msg = Utils.suppressed(ctx, msg)
await channel.send(msg)
return
# If we made it this far - then we didn't find it
msg = '{} not found in list.'.format(role.name)
msg = Utils.suppressed(ctx, msg)
await channel.send(msg)
