def __init__(self, bot):
self.bot = bot
try:
data = loads(open("config.json", "r").read())
self.DatabaseHelper = DBManage(url=data["MONGO"])
except FileNotFoundError:
self.DatabaseHelper = DBManage(url=os.getenv("MONGO"))
def __init__(self, bot):
self.bot = bot
try:
data = loads(open("config.json", "r").read())
self.DatabaseHelper = DBManage(url=data["MONGO"])
self.headers = data["TWITCH"]
except FileNotFoundError:
self.DatabaseHelper = DBManage(url=os.getenv("MONGO"))
self.headers = loads(os.environ["TWITCH"])
self.stream_list = dict()
class RoleAssign(commands.Cog):
def __init__(self, bot):
self.bot = bot
try:
data = loads(open("config.json", "r").read())
self.DatabaseHelper = DBManage(url=data["MONGO"])
except FileNotFoundError:
self.DatabaseHelper = DBManage(url=os.getenv("MONGO"))
@commands.Cog.listener()
async def on_ready(self):
await self.pre_process()
self.channel_maintenance.start()
async def pre_process(self):
# Create a list of role (list_roles) and member member who have them
self_assign = self.DatabaseHelper.server_query_data(
guild_id=None, mode="self_assign_all")
for data in self_assign:
guild = self.bot.get_guild(data["id"])
list_roles = dict()
for role in guild.roles:
if str(role.colour) == data["self_assign"]["color"] \
or str(role.name) in data["self_assign"]["special_role"]:
list_roles[role] = list()
if data["self_assign"]["show_members"]:
for member in guild.members:
if str(role) in [r.name for r in member.roles]:
list_roles[role].append(member)
channel = discord.utils.get(guild.channels,
name=data["self_assign"]["channel"])
await self.update_self_assign(list_roles, channel)
@staticmethod
async def update_self_assign(list_roles, channel):
async for x in channel.history():
await x.delete()
for role in list_roles.keys():
if list_roles[role]:
content = "**" + str(role) + "**```cs\n"
for member in list_roles[role]:
content += str(member) + "\n"
content += "```"
msg = await channel.send(content)
else:
msg = await channel.send("**" + str(role) + "**```\n```")
for emoji in ['✅', '❎']:
await msg.add_reaction(emoji)
@loop(minutes=30)
async def channel_maintenance(self):
await self.check_roles(self.bot, self.DatabaseHelper, ctx=None)
@commands.command(pass_context=True)
async def maintain_self_assign(self, ctx):
await self.check_roles(self.bot,
self.DatabaseHelper,
ctx=ctx,
guild_id=ctx.guild.id)
async def check_roles(self, bot, DatabaseHelper, ctx, guild_id=None):
if ctx:
self_data = DatabaseHelper.server_query_data(ctx.guild.id,
mode="self_assign")
if self_data["enable"]:
self_data = [
{
"id": ctx.guild.id,
"self_assign": self_data
},
]
else:
await ctx.send("Self assign isn't activated in this server.\n"
"use >set_self_assign to activate this feature")
return
elif guild_id:
self_data = DatabaseHelper.server_query_data(guild_id,
mode="self_assign")
self_data = [
{
"id": guild_id,
"self_assign": self_data
},
]
else:
self_data = DatabaseHelper.server_query_data(
guild_id=None, mode="self_assign_all")
# TODO: IF continuous error disable show member
while True:
error_list, self_data = await self.validate_assign(
bot=bot, self_assign=self_data)
if error_list:
for server_data in error_list:
await self.update_self_assign(server_data[0],
server_data[1])
else:
if ctx:
message = "Check Successful"
await ctx.send(message)
break
@staticmethod
async def validate_assign(bot, self_assign):
e3_list = list()
temp_self_assign = list()
for data in self_assign:
guild = bot.get_guild(data["id"])
list_roles = dict()
for role in guild.roles:
if str(role.colour) == data["self_assign"]["color"] \
or str(role.name) in data["self_assign"]["special_role"]:
list_roles[role] = list()
if data["self_assign"]["show_members"]:
for member in guild.members:
if str(role) in [r.name for r in member.roles]:
list_roles[role].append(member)
channel = discord.utils.get(guild.channels,
name=data["self_assign"]["channel"])
channel_list_role = list()
channel_list_member = dict()
async for x in channel.history():
role = str(x.content.split("**")[1])
channel_list_role.append(role)
if data["self_assign"]["show_members"]:
body = list(x.content.split("```")[1].split('\n'))[1:-1]
channel_list_member[role] = body
flag_error = False
for role in list_roles.keys():
if str(role) in channel_list_role:
channel_list_role.remove(str(role))
else:
e3_list.append([list_roles, channel])
temp_self_assign.append(data)
flag_error = True
break
else:
if len(channel_list_role) > 0:
e3_list.append([list_roles, channel])
temp_self_assign.append(data)
flag_error = True
if not flag_error and data["self_assign"]["show_members"]:
flag_nested_exit = False
for role in list_roles.keys():
for member in list_roles[role]:
if str(member) in channel_list_member[role.name]:
channel_list_member[role.name].remove(str(member))
else:
e3_list.append([list_roles, channel])
temp_self_assign.append(data)
flag_nested_exit = True
break
else:
if len(channel_list_member[role.name]) > 0:
e3_list.append([list_roles, channel])
temp_self_assign.append(data)
flag_nested_exit = True
if flag_nested_exit:
break
return e3_list, temp_self_assign
@commands.Cog.listener()
async def on_member_update(self, before, after):
if before.roles == after.roles:
return
self_assign = self.DatabaseHelper.server_query_data(
after.guild.id, "self_assign")
if self_assign["enable"] and self_assign["show_members"]:
change = list(set(after.roles) ^ set(before.roles))
if str(change[0].colour) == self_assign["color"] \
or str(change[0].name) in self_assign["special_role"]:
channel = discord.utils.get(after.guild.channels,
name=self_assign["channel"])
msg = None
async for x in channel.history():
if str(x.content.split("**")[1]) == str(change[0].name):
msg = x
head = msg.content.split("```")[0]
body = list(msg.content.split("```")[1].split('\n'))
if len(before.roles) > len(after.roles):
body.pop(body.index(str(after)))
body.pop()
if len(body) == 1:
content = head + "```\n```"
else:
body = "\n".join(body)
content = head + "```" + body + "\n```"
await msg.edit(content=content)
else:
body[len(body) - 1] = str(before)
body[0] = "cs"
body = "\n".join(body)
content = head + "```" + body + "\n```"
await msg.edit(content=content)
@commands.Cog.listener()
async def on_reaction_add(self, reaction, user):
self_assign = self.DatabaseHelper.server_query_data(
user.guild.id, "self_assign")
if self_assign["enable"]:
if reaction.count > 1 and str(
reaction.message.channel) == self_assign["channel"]:
role_name = discord.utils.get(
user.guild.roles,
name=str(reaction.message.content).split("**")[1])
if reaction.emoji == '✅':
await user.add_roles(role_name)
await reaction.remove(user)
elif reaction.emoji == '❎':
await user.remove_roles(role_name)
await reaction.remove(user)
@commands.Cog.listener()
async def on_guild_role_delete(self, role):
self_assign = self.DatabaseHelper.server_query_data(
role.guild.id, "self_assign")
if self_assign["enable"] and (str(role.colour) == self_assign["color"]
or role.name
in self_assign["special_role"]):
if str(role.name) in self_assign["special_role"]:
self_assign["special_role"].remove(role.name)
self.DatabaseHelper.server_update_self_assign(
guild_id=role.guild.id,
channel=self_assign["channel"],
color=self_assign["color"],
role=self_assign["special_role"]
if self_assign["special_role"] else None,
show_member=self_assign["show_members"])
channel = discord.utils.get(role.guild.channels,
name=self_assign["channel"])
async for x in channel.history():
if str(x.content.split("**")[1]) == role.name:
await x.delete()
break
@commands.Cog.listener()
async def on_guild_role_update(self, before, after):
self_assign = self.DatabaseHelper.server_query_data(
after.guild.id, "self_assign")
if self_assign["enable"]:
if str(after.colour) == self_assign["color"] and str(
before.colour) != self_assign["color"]:
await self.check_roles(self.bot,
self.DatabaseHelper,
ctx=None,
guild_id=after.guild.id)
elif str(before.colour) == self_assign["color"] and str(
after.colour) != self_assign["color"]:
channel = discord.utils.get(after.guild.channels,
name=self_assign["channel"])
async for x in channel.history():
if str(x.content.split("**")[1]) == after.name:
await x.delete()
break
elif (str(after.colour) == self_assign["color"]
or before.name in self_assign["special_role"]) and (str(
before.name) != str(after.name)):
if str(before.name) in self_assign["special_role"]:
self_assign["special_role"][
self_assign["special_role"].index(
before.name)] = after.name
self.DatabaseHelper.server_update_self_assign(
guild_id=after.guild.id,
channel=self_assign["channel"],
color=self_assign["color"],
role=self_assign["special_role"]
if self_assign["special_role"] else None,
show_member=self_assign["show_members"])
channel = discord.utils.get(after.guild.channels,
name=self_assign["channel"])
async for x in channel.history():
if str(x.content.split("**")[1]) == before.name:
msg = x.content.split("**")
msg[1] = after.name
msg = "**".join(msg)
await x.edit(content=msg)
@commands.Cog.listener()
async def on_guild_channel_delete(self, channel):
self_assign = self.DatabaseHelper.server_query_data(
channel.guild.id, "self_assign")
if self_assign["enable"] and channel.name == self_assign["channel"]:
self.DatabaseHelper.server_update_self_assign(
guild_id=channel.guild.id,
channel=None,
color=None,
role=None,
show_member=False,
enable=False)
@commands.Cog.listener()
async def on_guild_channel_update(self, before, after):
self_assign = self.DatabaseHelper.server_query_data(
after.guild.id, "self_assign")
if self_assign[
"enable"] and before.name != after.name and before.name == self_assign[
"channel"]:
self.DatabaseHelper.server_update_self_assign(
guild_id=after.guild.id,
channel=after.name,
color=self_assign["color"],
role=self_assign["special_role"],
show_member=self_assign["show_members"])
# noinspection PyUnusedLocal
@commands.Cog.listener()
async def on_reaction_clear(self, message, reactions):
self_assign = self.DatabaseHelper.server_query_data(
message.guild.id, "self_assign")
if self_assign["enable"] and message.channel.name == self_assign[
"channel"]:
for emoji in ['✅', '❎']:
await message.add_reaction(emoji)
@commands.Cog.listener()
async def on_reaction_remove(self, reaction, user):
self_assign = self.DatabaseHelper.server_query_data(
user.guild.id, "self_assign")
if self_assign["enable"] and reaction.message.channel.name == self_assign["channel"] \
and user.name == self.bot.user.name:
for emoji in ['✅', '❎']:
await reaction.message.add_reaction(emoji)
@commands.command(pass_context=True)
@has_permissions(administrator=True)
async def set_self_assign(self, ctx):
def check(msg):
return msg.author == ctx.message.author
message = "**Welcome to self assign configuration prompt**.\n" \
"> -> Self role assignment allows the user to manually assign a role (to himself/herself) " \
"by clicking ✅ to get the role or ❎ remove the role.\n" \
"> -> Role color is used to automatically manage the roles.\n " \
"> -> Role with selected color will automatically be " \
"added and removed from the self-assign channel.\n " \
"> -> Special roles can also be added to the list manually. Special roles can have any color. \n\n " \
"Specify a **channel** for self assign.```cs\n" \
"> Channel must already exist.\n" \
"> Do not tag the channel. Enter channel name only.\n" \
"> Text is case sensitive.\n" \
"Type \"exit\" or \"none\" to cancel prompt.```"
await ctx.send(message)
while True:
channel_name = await self.bot.wait_for('message',
check=check,
timeout=90)
if channel_name.content.lower() in ["skip", "none", "exit"]:
await ctx.send(
"Self assign can't work without a proper channel. Cancelling prompt.."
)
return
channel_name = discord.utils.get(ctx.guild.text_channels,
name=channel_name.content)
if channel_name:
break
else:
await ctx.send(
"**Error 404: Channel does not exist** (Text is case-sensitive).\n"
"Try again or type **exit** to cancel.")
await ctx.send(
"Confirm **#" + channel_name.name +
"** to be used with self assign?\n"
"```\n"
"> ALL MESSAGES IN THE GIVEN CHANNEL WILL BE DELETED.\n"
"> Ensure no one other than bot can message in the given channel.\n"
"> Ensure channel is muted as bot will refresh channel often.```"
"(Y:Yes|N:NO)")
prompt = await self.bot.wait_for('message', check=check, timeout=30)
if prompt.content.lower() not in ["y", "yes"]:
await ctx.send("Self-assign prompt cancelled.")
return
message = "Enter a Hex Color Code to be used as identifier-color.\n" \
"All role having the given color will be added to self assign channel```cs\n" \
"> Must be hex color code only. Default: #607d8b\n" \
"> Text is case sensitive.\n" \
"Type \"skip\" or \"none\" to use default color.\n" \
"Type \"exit\" to cancel prompt```"
await ctx.send(message)
while True:
color_name = await self.bot.wait_for('message',
check=check,
timeout=60)
if color_name.content.lower() in ["skip", "none"]:
color_name = "#607d8b"
break
elif color_name.content.lower() in ["exit"]:
await ctx.send("Prompt Cancelled.")
return
if re.search(r'^#(?:[0-9a-fA-F]{3}){1,2}$',
color_name.content.lower()):
await ctx.send("Color Saved.")
color_name = color_name.content.lower()
break
else:
await ctx.send("Invalid Hex Color code provided..\n"
"Try again or type **exit** to cancel.")
message = " Enter special role to be added in self assign.```cs\n" \
"> Special role can have any color.\n" \
"> Role must already exist.\n" \
"Type \"skip\" or \"none\" to skip special role.\n" \
"Type \"exit\" to cancel prompt.```"
await ctx.send(message)
role_list = list()
while True:
special_role = await self.bot.wait_for('message',
check=check,
timeout=60)
if special_role.content.lower() in ["skip", "none"]:
break
elif special_role.content.lower() in ["empty"]:
role_list = []
message = "Enter another special role to add in self assign.```cs\n" \
"> Special role can have any color.\n" \
"> Role must already exist.\n" \
"> {count} is/are already registered.\n" \
"Type \"empty\" to remove current special role.\n" \
"Type \"skip\" or \"none\" to continue with already added role.\n" \
"Type \"exit\" to cancel prompt.```".format(count=role_list if role_list else "No Role")
await ctx.send(message)
continue
elif special_role.content.lower() in ["exit"]:
await ctx.send("self-assign prompt cancelled.")
return
special_role = discord.utils.get(ctx.guild.roles,
name=special_role.content)
if special_role:
role_list.append(special_role.name)
await ctx.send(
"Do you wish to add another special role?\n(Y:Yes|N:NO)")
prompt = await self.bot.wait_for('message',
check=check,
timeout=60)
if prompt.content.lower() == "n":
break
else:
message = "Enter another special role to add in self assign.```cs\n" \
"> Special role can have any color.\n" \
"> Role must already exist.\n" \
"> {count} is/are already registered.\n" \
"Type \"empty\" to remove current special role.\n" \
"Type \"skip\" or \"none\" to continue with already added role.\n" \
"Type \"exit\" to cancel prompt.```".format(count=role_list if role_list else "No Role")
await ctx.send(message)
else:
await ctx.send(
"**Error 404: Role does not exist** (Text is case-sensitive).\n"
"Try again or type **exit** to cancel.")
show_members = False
if len(ctx.guild.members) > 200:
await ctx.send(
"Guild with more than 200 member can not use show member.")
else:
await ctx.send(
"Do you wish to show members list in self assign?\n(Y:Yes|N:NO)"
)
prompt = await self.bot.wait_for('message',
check=check,
timeout=30)
if prompt.content.lower() in ["y", "yes"]:
show_members = True
self.DatabaseHelper.server_update_self_assign(
guild_id=ctx.guild.id,
channel=channel_name.name,
color=color_name,
role=role_list,
show_member=show_members)
self_assign = self.DatabaseHelper.server_query_data(
guild_id=ctx.guild.id, mode="self_assign")
self_assign = [
{
"id": ctx.guild.id,
"self_assign": self_assign
},
]
for data in self_assign:
guild = self.bot.get_guild(data["id"])
list_roles = dict()
for role in guild.roles:
if str(role.colour) == data["self_assign"]["color"] \
or str(role.name) in data["self_assign"]["special_role"]:
list_roles[role] = list()
if data["self_assign"]["show_members"]:
for member in guild.members:
if str(role) in [r.name for r in member.roles]:
list_roles[role].append(member)
channel = discord.utils.get(guild.channels,
name=data["self_assign"]["channel"])
await self.update_self_assign(list_roles, channel)
await ctx.send(
"Configuration saved successfully. \nAll future roles with " +
color_name +
" color will be automatically added and removed to/from #" +
channel_name.name +
"\nUse >help_self_assign for more information.")
await self.check_roles(self.bot,
self.DatabaseHelper,
ctx=None,
guild_id=ctx.guild.id)
@commands.command(pass_context=True)
@has_permissions(administrator=True)
async def remove_self_assign(self, ctx):
def check(msg):
return msg.author == ctx.message.author
message = "Do you wish to remove self assign channel?\n(Y:YES|N:NO)"
await ctx.send(message)
prompt = await self.bot.wait_for('message', check=check, timeout=30)
if prompt.content.lower() in ["yes", "y"]:
self.DatabaseHelper.server_update_self_assign(
guild_id=ctx.guild.id,
channel=None,
color=None,
role=None,
show_member=False,
enable=False)
await ctx.send("Self assign channel deactivated.")
else:
await ctx.send("Prompt canceled.")
@commands.command(pass_context=True)
@has_permissions(administrator=True)
async def special_role(self, ctx):
def check(msg):
return msg.author == ctx.message.author
data = self.DatabaseHelper.server_query_data(ctx.guild.id,
"self_assign")
if not data["enable"]:
await ctx.send(
"Self assign not activated. Use set_self_assign to activate self assign,"
)
return
role_list = data["special_role"] if data["special_role"] else []
while True:
message = "Enter another special role to add in self assign.```cs\n" \
"> Special role can have any color.\n" \
"> Role must already exist.\n" \
"> {count} is/are already registered.\n" \
"Type \"empty\" to remove current special role.\n" \
"Type \"skip\" or \"none\" to continue with already added role.\n" \
"Type \"exit\" to cancel prompt.```".format(count=role_list if role_list else "No Role")
await ctx.send(message)
special_role = await self.bot.wait_for('message',
check=check,
timeout=60)
if special_role.content.lower() in ["skip", "none"]:
break
elif special_role.content.lower() in ["empty"]:
role_list = []
continue
elif special_role.content.lower() in ["exit"]:
await ctx.send("self-assign prompt cancelled.")
return
special_role = discord.utils.get(ctx.guild.roles,
name=special_role.content)
if special_role:
role_list.append(special_role.name)
await ctx.send(
"Do you wish to add another special role?\n(Y:Yes|N:NO)")
prompt = await self.bot.wait_for('message',
check=check,
timeout=60)
if prompt.content.lower() == "n":
break
else:
await ctx.send(
"**Error 404: Role does not exist** (Text is case-sensitive).\n"
"Try again or type **exit** to cancel.")
self.DatabaseHelper.server_update_self_assign(
guild_id=ctx.guild.id,
channel=data["channel"],
color=data["color"],
role=role_list if role_list else None,
show_member=data["show_members"])
self_assign = self.DatabaseHelper.server_query_data(
guild_id=ctx.guild.id, mode="self_assign")
self_assign = [
{
"id": ctx.guild.id,
"self_assign": self_assign
},
]
for data in self_assign:
guild = self.bot.get_guild(data["id"])
list_roles = dict()
for role in guild.roles:
if str(role.colour) == data["self_assign"]["color"] \
or str(role.name) in data["self_assign"]["special_role"]:
list_roles[role] = list()
if data["self_assign"]["show_members"]:
for member in guild.members:
if str(role) in [r.name for r in member.roles]:
list_roles[role].append(member)
channel = discord.utils.get(guild.channels,
name=data["self_assign"]["channel"])
await self.update_self_assign(list_roles, channel)
await ctx.send("Configuration saved successfully.\n"
"Use >help_self_assign for more information.")
await self.check_roles(self.bot,
self.DatabaseHelper,
ctx=None,
guild_id=ctx.guild.id)
@set_self_assign.error
@remove_self_assign.error
@special_role.error
async def timeout_error(self, ctx, error):
if isinstance(error, MissingPermissions):
await ctx.send(
"To prevent data loss. Only user with administrator permission can use clear command."
)
elif isinstance(error, CommandInvokeError):
await ctx.send(
"Did not receive any reply from user. Exiting config prompt.")
@commands.command(pass_context=True)
async def help_self_assign(self, ctx):
self_assign = self.DatabaseHelper.server_query_data(ctx.guild.id,
mode="self_assign")
embed = discord.Embed(title="Self Assign Role",
description="\u200b",
color=0xcc0099)
embed.set_author(
name='Bhartiya',
icon_url="https://cdn.discordapp.com/avatars/429945357808697355"
"/1610303189d607b5665cba3d037226b7.webp?size=128")
embed.set_thumbnail(
url=
"https://cdn.discordapp.com/icons/226611621059887104/c11623908b1fe534e4d129b7856848ad.webp"
)
if self_assign["enable"]:
embed.add_field(name='Show Members',
value=self_assign["show_members"],
inline=True)
embed.add_field(name='Channel',
value=self_assign["channel"],
inline=True)
embed.add_field(name='Color',
value=self_assign["color"],
inline=True)
embed.add_field(name='Special Role',
value=str(self_assign["special_role"])[1:-1],
inline=False)
embed.add_field(name='\u200b', value="Commands", inline=False)
embed.add_field(name='>set_self_assign',
value='Update settings for self assign channel.',
inline=False)
embed.add_field(
name='>maintain_self_assign',
value=
'Automatically check and fix error in self assign channel.',
inline=False)
embed.add_field(
name='>special_role',
value='Add or remove roles from special role list.',
inline=False)
embed.add_field(
name='>remove_self_assign',
value='Disable self assign channel from this server.',
inline=False)
else:
embed.add_field(name='Self Assign Role: Disable',
value="Use >set_self_assign to enable.",
inline=False)
embed.add_field(name='\u200b', value="Made by:", inline=False)
embed.set_footer(
text="VampireBl00d#2521",
icon_url="https://cdn.discordapp.com/avatars/"
"216236803710124032/287ada789e1944a72a2f826e229cba29.webp")
await ctx.send(embed=embed)
class Twitch(commands.Cog):
def __init__(self, bot):
self.bot = bot
try:
data = loads(open("config.json", "r").read())
self.DatabaseHelper = DBManage(url=data["MONGO"])
self.headers = data["TWITCH"]
except FileNotFoundError:
self.DatabaseHelper = DBManage(url=os.getenv("MONGO"))
self.headers = loads(os.environ["TWITCH"])
self.stream_list = dict()
@commands.Cog.listener()
async def on_ready(self):
self.schedule_notification.start()
@commands.Cog.listener()
async def on_member_update(self, before, after):
if not after.bot and \
after.activity is not None and \
before.activity != after.activity and \
str(after.activity.type) == "ActivityType.streaming":
data = self.DatabaseHelper.member_query_data(member_id=after.id, mode="one")
if not data:
self.DatabaseHelper.member_add_data(
member_id=after.id,
twitch_username=after.activity.url.split("/")[-1],
guild_id=after.guild.id)
# "after.activity.url.split("/")[-1]" reading user's Twitch username through activity
else:
if not data["in_server"]:
self.DatabaseHelper.member_update_server(
member_id=after.id,
server_list=[after.guild.id, ],
blocked_list=None)
elif after.guild.id not in data["in_server"]:
data["in_server"].append(after.guild.id)
self.DatabaseHelper.member_update_server(
member_id=after.id,
server_list=data["in_server"],
blocked_list=None)
@loop(minutes=15)
async def schedule_notification(self):
# Member Stream
member_data = self.DatabaseHelper.member_query_data(member_id=None, mode="all")
for member in member_data:
url = 'https://api.twitch.tv/helix/streams?user_login='******'data'] and not member["live_status"]:
self.DatabaseHelper.member_update_status(member["id"], True)
data_user = None
game_lc = None
for server_id in server_list:
server_data = self.DatabaseHelper.server_query_data(server_id, "twitch")
if server_data and server_data["enable"]:
if not data_user:
# User Data
url = 'https://api.twitch.tv/helix/users?login='******'https://api.twitch.tv/helix/games?id=' + live['data'][0]['game_id']
response = requests.get(url, headers=self.headers)
game_lc = dict(response.json())
server_ob = self.bot.get_guild(server_id)
channel = discord.utils.get(server_ob.text_channels, name=server_data["twitch_channel"])
await self.twitch_notification(data_user, channel, live, game_lc)
elif not live['data'] and member["live_status"]:
self.DatabaseHelper.member_update_status(member["id"], False)
data_user = None
for server_id in server_list:
server_data = self.DatabaseHelper.server_query_data(server_id, "twitch")
if server_data and server_data["enable"]:
if not data_user:
# User Data
url = 'https://api.twitch.tv/helix/users?login='******'twitch_followed')
for server_data in data:
twitch_data = server_data["twitch_notification"]
server = self.bot.get_guild(server_data["id"])
channel_name = discord.utils.get(server.text_channels, name=twitch_data["twitch_channel"])
for ind in range(0, len(twitch_data["other_streamer"])):
url = 'https://api.twitch.tv/helix/streams?user_login='******'data'] and not twitch_data["other_streamer"][ind]["live_status"]:
self.DatabaseHelper.server_update_twitch_streamer_status(
guild_id=server_data["id"],
pos=twitch_data["other_streamer"][ind]["username"],
live=True
)
# User Data
url = 'https://api.twitch.tv/helix/users?login='******'https://api.twitch.tv/helix/games?id=' + live['data'][0]['game_id']
response = requests.get(url, headers=self.headers)
game_lc = dict(response.json())
await self.twitch_notification(data_user, channel_name, live, game_lc)
elif not live['data'] and twitch_data["other_streamer"][ind]["live_status"]:
self.DatabaseHelper.server_update_twitch_streamer_status(
guild_id=server_data["id"],
pos=twitch_data["other_streamer"][ind]["username"],
live=False
)
url = 'https://api.twitch.tv/helix/users?login='******'data'][0]['display_name']).capitalize() + " is streaming!",
description="https://www.twitch.tv/" + data_user['data'][0]['login'], color=0xcc0099)
embed.set_thumbnail(url=data_user['data'][0]['profile_image_url'])
embed.set_author(name="Views: " + str(data_user['data'][0]['view_count']) + " | Live viewer count: " + str(
live['data'][0]['viewer_count']),
icon_url="https://images-ext-1.discordapp.net/external/IZEY6CIxPwbBTk-S6KG6WSMxyY5bUEM"
"-annntXfyqbw/https/cdn.discordapp.com/emojis/287637883022737418.png")
if str(data_user['data'][0]['broadcaster_type']) != "":
embed.add_field(name='Broadcaster Type: ',
value=str(data_user['data'][0]['broadcaster_type']).capitalize(),
inline=False)
embed.add_field(name="Playing:", value=game_lc['data'][0]['name'], inline=False)
path = live['data'][0]['thumbnail_url']
path = path.replace("{width}", "1920")
path = path.replace("{height}", "1080")
embed.set_image(url=path)
embed.add_field(name="Stream Title:", value=live['data'][0]['title'], inline=False)
embed.set_footer(text="Live | " + "Started: " + str(live['data'][0]['started_at'])[:10] + " Time: " + str(
live['data'][0]['started_at'])[11:].replace("Z", " UTC"),
icon_url="https://static.thenounproject.com/png/594409-200.png")
await channel.send("**" + data_user['data'][0]['display_name'] +
" is live.**\nSupport their stream at <https://www.twitch.tv/"
+ data_user['data'][0]['login'] + ">")
await channel.send(embed=embed)
else:
embed = discord.Embed(title=str(data_user['data'][0]['display_name']).capitalize() + " will be back soon!",
description="https://www.twitch.tv/" + data_user['data'][0]['login'], color=0xcc0099)
embed.set_thumbnail(url=data_user['data'][0]['profile_image_url'])
embed.set_author(name="Views: " + str(data_user['data'][0]['view_count']),
icon_url="https://images-ext-1.discordapp.net/external/IZEY6CIxPwbBTk-S6KG6WSMxyY5bUEM"
"-annntXfyqbw/https/cdn.discordapp.com/emojis/287637883022737418.png")
embed.set_image(url=data_user['data'][0]['offline_image_url'])
embed.set_footer(text="Offline", icon_url="https://img.icons8.com/metro/1600/offline.png")
if str(data_user['data'][0]['broadcaster_type']) != "":
embed.add_field(name='Broadcaster Type: ',
value=str(data_user['data'][0]['broadcaster_type']).capitalize(),
inline=False)
await channel.send("If user is online, Please wait 3min for API to Update")
await channel.send(embed=embed)
@commands.command(pass_context=True)
@has_permissions(administrator=True)
async def set_twitch(self, ctx):
def check(msg):
return msg.author == ctx.message.author
message = "Welcome to twitch configuration prompt.\n" \
"Specify a **channel name** to send twitch notification.```cs\n" \
"> Channel must already exist.\n" \
"> Do not tag the channel. Enter channel name only.\n" \
"> Text is case sensitive.\n" \
"Type \"exit\" or \"none\" to cancel prompt.```"
await ctx.send(message)
while True:
channel_name = await self.bot.wait_for('message', check=check, timeout=60)
if channel_name.content.lower() in ["skip", "none", "exit"]:
await ctx.send("Twitch notification prompt cancelled.")
return
channel_name = discord.utils.get(ctx.guild.text_channels, name=channel_name.content)
if channel_name:
self.DatabaseHelper.server_update_twitch(
guild_id=ctx.guild.id,
channel=channel_name.name)
await ctx.send("Configuration saved successfully.\n"
"Use >help_twitch for more information.")
return
else:
await ctx.send(
"**Error 404: Channel does not exist** (Text is case-sensitive).\n"
"Try again or type **exit** to cancel.")
@commands.command(pass_context=True)
@has_permissions(administrator=True)
async def twitch_block_user(self, ctx):
if not ctx.message.mentions:
await ctx.send("Please tag the user. Do not write username")
return
for user in ctx.message.mentions:
member_data = self.DatabaseHelper.member_query_data(user.id, "one")
if member_data:
if not member_data["blocked_from"]:
self.DatabaseHelper.member_update_server(
member_id=user.id,
blocked_list=[ctx.guild.id, ],
server_list=None
)
await ctx.send("Twitch notification for given user will not be sent.")
elif user.id not in member_data["blocked_from"]:
member_data["blocked_from"].append(ctx.guild.id)
self.DatabaseHelper.member_update_server(
member_id=user.id,
blocked_list=member_data["blocked_from"],
server_list=None
)
await ctx.send("Twitch notification for given user will not be sent.")
else:
await ctx.send("User already blocked.")
else:
await ctx.send("User not a streamer.")
@commands.command(pass_context=True)
@has_permissions(administrator=True)
async def twitch_unblock_user(self, ctx):
if not ctx.message.mentions:
await ctx.send("Please tag the user. Do not write username")
return
for user in ctx.message.mentions:
member_data = self.DatabaseHelper.member_query_data(user.id, "one")
if member_data:
if member_data["blocked_from"]:
if user.id in member_data["blocked_from"]:
member_data["blocked_from"].remove(ctx.guild.id)
self.DatabaseHelper.member_update_server(
member_id=user.id,
blocked_list=member_data["blocked_from"],
server_list=None
)
await ctx.send("Twitch notification for given user activated.")
else:
await ctx.send("User isn't blocked.")
else:
await ctx.send("User isn't blocked.")
else:
await ctx.send("User not a streamer.")
@commands.command(pass_context=True)
async def stream_add(self, ctx, username):
def check(msg):
return msg.author == ctx.message.author
twitch_data = self.DatabaseHelper.server_query_data(
guild_id=ctx.guild.id,
mode="twitch"
)
if twitch_data["enable"]:
invalid_user = await self.check_stream(ctx, username)
if invalid_user:
return
await ctx.send("Is this the user you are looking for?\n(Y:Yes|N:No)")
prompt = await self.bot.wait_for('message', check=check, timeout=30)
if prompt.content.lower() not in ["y", "yes"]:
await ctx.send("Ensure twitch username is valid.\nUser not added.")
return
if not twitch_data["other_streamer"]:
twitch_data["other_streamer"] = [username, ]
self.DatabaseHelper.server_update_twitch_streamer(
guild_id=ctx.guild.id,
streamer=[{
"username": username,
"live_status": False
}, ]
)
elif username in [uname["username"] for uname in twitch_data["other_streamer"]]:
await ctx.send("User is already followed in this server.")
return
else:
user_data = {
"username": username,
"live_status": False
}
twitch_data["other_streamer"].append(user_data)
self.DatabaseHelper.server_update_twitch_streamer(
guild_id=ctx.guild.id,
streamer=twitch_data["other_streamer"]
)
await ctx.send(username + " added to streamer list.")
else:
await ctx.send("Twitch notification disabled. Use >set_twitch")
@commands.command(pass_context=True)
async def stream_remove(self, ctx, username):
twitch_data = self.DatabaseHelper.server_query_data(
guild_id=ctx.guild.id,
mode="twitch"
)
if twitch_data["enable"]:
for ind in range(0, len(twitch_data["other_streamer"])):
if twitch_data["other_streamer"][ind]["username"] == username:
del twitch_data["other_streamer"][ind]
break
else:
await ctx.send("User isn't followed.")
return
if not twitch_data["other_streamer"]:
self.DatabaseHelper.server_update_twitch_streamer(
guild_id=ctx.guild.id,
streamer=None
)
else:
self.DatabaseHelper.server_update_twitch_streamer(
guild_id=ctx.guild.id,
streamer=twitch_data["other_streamer"]
)
await ctx.send("Username removed from list.")
else:
await ctx.send("Twitch notification disabled. Use >set_twitch")
@commands.command(pass_context=True)
@has_permissions(administrator=True)
async def remove_twitch(self, ctx):
def check(msg):
return msg.author == ctx.message.author
message = "Do you wish to remove twitch notification?\n(Y:YES|N:NO)"
await ctx.send(message)
prompt = await self.bot.wait_for('message', check=check, timeout=30)
if prompt.content.lower() in ["yes", "y"]:
self.DatabaseHelper.server_update_twitch(
guild_id=ctx.guild.id,
channel=None,
enable=False
)
self.DatabaseHelper.server_update_twitch_streamer(
guild_id=ctx.guild.id,
streamer=None
)
await ctx.send("New member notification deactivated.")
@set_twitch.error
@remove_twitch.error
@stream_add.error
@stream_remove.error
async def timeout_error(self, ctx, error):
print(error)
if isinstance(error, MissingPermissions):
await ctx.send("To prevent data loss. Only user with administrator permission can use clear command.")
elif isinstance(error, CommandInvokeError):
await ctx.send("Did not receive any reply from user. Exiting config prompt.")
@commands.command(pass_context=True)
async def help_twitch(self, ctx):
twitch = self.DatabaseHelper.server_query_data(ctx.guild.id, mode="twitch")
embed = discord.Embed(title="Twitch Notification", description="\u200b",
color=0xcc0099)
embed.set_author(name='Bhartiya',
icon_url="https://cdn.discordapp.com/avatars/429945357808697355"
"/1610303189d607b5665cba3d037226b7.webp?size=128")
embed.set_thumbnail(
url="https://cdn.discordapp.com/icons/226611621059887104/c11623908b1fe534e4d129b7856848ad.webp")
if twitch["enable"]:
embed.add_field(name='Channel',
value=twitch["twitch_channel"],
inline=False)
embed.add_field(name='Twitch user followed (Not in this server):',
value=twitch["other_streamer"] if twitch["other_streamer"] else "None",
inline=False)
embed.add_field(name='\u200b',
value="Commands",
inline=False)
embed.add_field(name='>set_twitch',
value='Update settings for twitch notification.',
inline=False)
embed.add_field(name='>stream_add TWITCH_USER',
value='Follow a twitch user who is not in this server.',
inline=False)
embed.add_field(name='>twitch_block_user MENTION_USER(S)',
value='Block twitch notification for a particular member in the server.',
inline=False)
embed.add_field(name='>twitch_unblock_user MENTION_USER(S)',
value='Un-Block twitch notification for a particular member in the server.',
inline=False)
embed.add_field(name='>stream_remove TWITCH_USER',
value='Unfollow twitch user from this server..',
inline=False)
embed.add_field(name='>remove_twitch',
value='Disable twitch notification from this server.',
inline=False)
else:
embed.add_field(name='Member Notification: Disable',
value="Use >set_twitch to enable.",
inline=False)
embed.add_field(name='>check_stream TWITCH_USERNAME',
value='Get real time information about twitch user.',
inline=False)
embed.add_field(name='\u200b', value="Made by:", inline=False)
embed.set_footer(text="VampireBl00d#2521",
icon_url="https://cdn.discordapp.com/avatars/"
"216236803710124032/287ada789e1944a72a2f826e229cba29.webp")
await ctx.send(embed=embed)
@commands.command()
async def check_stream(self, ctx, username):
# User Data
url = 'https://api.twitch.tv/helix/users?login='******'https://api.twitch.tv/helix/streams?user_login='******'data']:
# Data about the game being streamed
url = 'https://api.twitch.tv/helix/games?id=' + live['data'][0]['game_id']
response = requests.get(url, headers=self.headers)
game_lc = dict(response.json())
await self.twitch_notification(data_user, ctx.channel, live, game_lc)
else:
await self.twitch_notification(data_user, ctx.channel)
@commands.Cog.listener()
async def on_guild_remove(self, guild):
for member in guild.members:
member_data = self.DatabaseHelper.member_query_data(member.id, "one")
if member_data:
member_data["in_server"].remove(guild.id)
if member_data["blocked_from"] and guild.id in member_data["blocked_from"]:
member_data["blocked_from"].remove(guild.id)
self.DatabaseHelper.member_update_server(member_id=member.id,
server_list=member_data["in_server"],
blocked_list=member_data["blocked_from"])
else:
self.DatabaseHelper.member_update_server(member_id=member.id,
server_list=member_data["in_server"],
blocked_list=None)
@commands.Cog.listener()
async def on_member_join(self, member):
member_data = self.DatabaseHelper.member_query_data(member_id=member.id, mode="one")
if member_data and member.guild.id not in member_data["in_server"]:
member_data["in_server"].append(member.guild.id)
self.DatabaseHelper.member_update_server(member_id=member.id,
server_list=member_data["in_server"],
blocked_list=None)
@commands.Cog.listener()
async def on_member_remove(self, member):
member_data = self.DatabaseHelper.member_query_data(member_id=member.id, mode="one")
if member_data and member.guild.id in member_data["in_server"]:
member_data["in_server"].remove(member.guild.id)
if member_data["blocked_from"] and member.guild.id in member_data["blocked_from"]:
member_data["blocked_from"].remove(member.guild.id)
self.DatabaseHelper.member_update_server(member_id=member.id,
server_list=member_data["in_server"],
blocked_list=member_data["blocked_from"])
else:
self.DatabaseHelper.member_update_server(member_id=member.id,
server_list=member_data["in_server"],
blocked_list=None)
@commands.Cog.listener()
async def on_guild_channel_delete(self, channel):
server_data = self.DatabaseHelper.server_query_data(channel.guild.id, "twitch")
if server_data["enable"] and channel.name == server_data["channel"]:
self.DatabaseHelper.server_update_twitch(
guild_id=channel.guild.id,
channel=None,
enable=False)
@commands.Cog.listener()
async def on_guild_channel_update(self, before, after):
server_data = self.DatabaseHelper.server_query_data(after.guild.id, "twitch")
if server_data["enable"] and before.name != after.name and before.name == server_data["channel"]:
self.DatabaseHelper.server_update_twitch(
guild_id=after.guild.id,
channel=after.name)
class MaintainDB(commands.Cog):
def __init__(self, bot):
self.bot = bot
try:
data = loads(open("config.json", "r").read())
self.DatabaseHelper = DBManage(url=data["MONGO"])
except FileNotFoundError:
self.DatabaseHelper = DBManage(url=os.getenv("MONGO"))
@commands.Cog.listener()
async def on_ready(self):
# Validating Database
await self.bot.change_presence(activity=discord.Game(
name='Starting...'))
await self.DatabaseHelper.startup(self.bot)
# Running Bot
await self.bot.change_presence(activity=discord.Game(name='Use >help'))
@commands.Cog.listener()
async def on_guild_join(self, guild):
# Adding guild to Database
self.DatabaseHelper.server_join(guild)
embed = discord.Embed(title="Bhartiya has joined " + str(guild.name),
description="\u200b",
color=0x00ff00)
embed.set_thumbnail(
url="https://cdn.discordapp.com/avatars/429945357808697355"
"/1610303189d607b5665cba3d037226b7.webp?size=128")
embed.add_field(
name='>help',
value="Provide general information about bot and server.",
inline=False)
embed.add_field(name='List of command for Bhartiya can be found here:',
value="https://github.com/Ak55073/Bharatiya/wiki",
inline=False)
embed.add_field(name='Official bot repo',
value="https://github.com/Ak55073/Bharatiya",
inline=False)
embed.set_footer(
text="Bhartiya",
icon_url="https://cdn.discordapp.com/avatars/429945357808697355"
"/1610303189d607b5665cba3d037226b7.webp?size=128")
for channel in guild.channels:
if "general" == str(channel):
await channel.send(embed=embed)
@commands.Cog.listener()
async def on_guild_remove(self, guild):
self.DatabaseHelper.server_delete_data(guild.id)
@commands.Cog.listener()
async def on_guild_update(self, before, after):
# Changing guild name stored in Database
if before.name != after.name:
self.DatabaseHelper.server_update_name(after)
@commands.Cog.listener()
async def on_member_update(self, before, after):
# Auto assign role if playing status match any role name in server
if not after.bot and \
after.activity is not None and \
before.activity != after.activity and \
str(after.activity.type) == "ActivityType.playing":
auto_role = self.DatabaseHelper.server_query_data(
after.guild.id, "auto_role")
if auto_role:
for role in after.guild.roles:
if after.activity.name.lower() == role.name.lower():
role_assign = discord.utils.get(after.guild.roles,
name=role.name)
await after.add_roles(role_assign)
@commands.command(pass_context=True)
@has_permissions(administrator=True)
async def auto_role(self, ctx):
def check(msg):
return msg.author == ctx.message.author
message = "Do you wish to enable auto_assign?```cs\n" \
"-> Bharatiya will automatically assign the role to" \
" the user based on their gaming activity in discord.\n" \
"-> Name of the role must match(not case-sensitive) the user's playing status to assign the role.\n" \
"-> If the server has a 'Cyberpunk' role and user playing status" \
" display 'Cyberpunk 2077' then the role will not be assigned.```\n" \
"(Y:Yes | N:NO)"
await ctx.send(message)
auto_role = await self.bot.wait_for('message', check=check, timeout=60)
if auto_role.content.lower() in ["y", "yes"]:
self.DatabaseHelper.server_update_auto_role(guild_id=ctx.guild.id,
enable=True)
await ctx.send("Auto-role enabled.")
elif auto_role.content.lower() in ["n", "no"]:
self.DatabaseHelper.server_update_auto_role(guild_id=ctx.guild.id,
enable=False)
await ctx.send("Auto-role deactivated.")
else:
await ctx.send("Invalid input.")
@auto_role.error
async def timeout_error(self, ctx, error):
if isinstance(error, MissingPermissions):
await ctx.send(
"To prevent spam. Only administrator can use this command.")
elif isinstance(error, CommandInvokeError):
await ctx.send(
"Did not receive any reply from user. Exiting config prompt.")
class ServerListener(commands.Cog):
def __init__(self, bot):
self.bot = bot
try:
data = loads(open("config.json", "r").read())
self.DatabaseHelper = DBManage(url=data["MONGO"])
except FileNotFoundError:
self.DatabaseHelper = DBManage(url=os.getenv("MONGO"))
@staticmethod
async def member_notification(member, new_member_notification, mode):
embed = discord.Embed(title=("(" + str(member.id) + ")"),
description="\u200b",
color=0x00ff00)
dates = (
str(datetime.date.today()).split("-"), # Today's date
str(member.created_at).split(" ")[0].split("-")
if mode == "join" # Date of creation
else str(member.joined_at).split(" ")[0].split(
"-") # Data of joining server
) # Formatting to [yyyy,mm,dd]
days = str(
datetime.date(int(dates[0][0]), int(dates[0][1]), int(dates[0][2]))
- # Today's date
datetime.date(int(dates[1][0]), int(dates[1][1]), int(
dates[1][2])) # Date of creation or Date of Joining
) # Days since account was created or user joined server
txt_msg = None
if mode == "join": # Member joining server.
embed.set_author(name=member.display_name + " has joined " +
str(member.guild),
url="")
embed.add_field(name='Joined ' + str(member.guild) + ' on',
value=(str(datetime.datetime.now())[:16]),
inline=False)
embed.add_field(name='Account Created on',
value=(str(member.created_at)[:16] + "\n" +
days.split(",")[0] + " ago"),
inline=False)
txt_msg = "Welcome " + member.mention + " to " + str(member.guild)
if new_member_notification["message"] is not None:
txt_msg += ". " + new_member_notification["message"]
else:
txt_msg += ". Enjoy your stay."
if new_member_notification["role"] is not None:
role_assign = discord.utils.get(
member.guild.roles, name=new_member_notification["role"])
await member.add_roles(role_assign)
else:
embed.set_author(name=member.display_name + " has left " +
str(member.guild),
url="")
embed.add_field(
name='Left ' + str(member.guild) + ' on',
value=(str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M") +
"\nBeen Member for \n" + days.split(",")[0])),
inline=False)
if member.avatar_url == "":
embed.set_thumbnail(
url="https://cdn.discordapp.com/avatars/429945357808697355"
"/1610303189d607b5665cba3d037226b7.webp?size=128")
else:
embed.set_thumbnail(url=member.avatar_url)
embed.set_footer(
text="Bhartiya",
icon_url="https://cdn.discordapp.com/avatars/429945357808697355"
"/1610303189d607b5665cba3d037226b7.webp?size=128")
channel = discord.utils.get(member.guild.text_channels,
name=new_member_notification["channel"])
if txt_msg:
await channel.send(txt_msg)
await channel.send(embed=embed)
@commands.Cog.listener()
async def on_member_join(self, member):
new_member_notification = self.DatabaseHelper.server_query_data(
member.guild.id, "new_member")
if new_member_notification['enable']:
await self.member_notification(member, new_member_notification,
"join")
@commands.Cog.listener()
async def on_member_remove(self, member):
new_member_notification = self.DatabaseHelper.server_query_data(
member.guild.id, "new_member")
if new_member_notification['enable']:
await self.member_notification(member, new_member_notification,
"leave")
@commands.Cog.listener()
async def on_guild_channel_delete(self, channel):
new_member = self.DatabaseHelper.server_query_data(
channel.guild.id, "new_member")
if new_member["enable"] and channel.name == new_member["channel"]:
self.DatabaseHelper.server_update_member(guild_id=channel.guild.id,
append_message=None,
role=None,
channel=None,
enable=False)
@commands.Cog.listener()
async def on_guild_channel_update(self, before, after):
if before.name == after.name:
return
new_member = self.DatabaseHelper.server_query_data(
after.guild.id, "new_member")
if new_member["enable"] and before.name == new_member["channel"]:
self.DatabaseHelper.server_update_member(
guild_id=after.guild.id,
append_message=new_member["message"],
role=new_member["role"],
channel=after.name,
enable=new_member["enable"])
@commands.Cog.listener()
async def on_guild_role_delete(self, role):
new_member = self.DatabaseHelper.server_query_data(
role.guild.id, "new_member")
if new_member["enable"] and role.name == new_member["role"]:
self.DatabaseHelper.server_update_member(guild_id=role.guild.id,
append_message=None,
role=None,
channel=None,
enable=False)
@commands.Cog.listener()
async def on_guild_role_update(self, before, after):
if before.name == after.name:
return
new_member = self.DatabaseHelper.server_query_data(
after.guild.id, "new_member")
if new_member["enable"] and before.name == new_member["role"]:
self.DatabaseHelper.server_update_member(
guild_id=after.guild.id,
append_message=new_member["message"],
role=after.name,
channel=new_member["channel"],
enable=new_member["enable"])
@commands.command(pass_context=True)
@has_permissions(administrator=True)
async def set_member_welcome(self, ctx):
def check(msg):
return msg.author == ctx.message.author
while True:
# Message to be appended with welcome message
message = "Welcome to member join/leave configuration prompt.```cs\n" \
"Specify a custom message to be append with welcome message. \n" \
"Type \"skip\" or \"none\" to use default message.\n" \
"Type \"exit\" to cancel prompt.\n\n" \
"# Example: \n" \
"Welcome {user} to {guild}. [Append Message]```".format(user=ctx.message.author.name,
guild=ctx.guild.name)
await ctx.send(message)
append_message = await self.bot.wait_for('message',
check=check,
timeout=60)
if append_message.content.lower() in ["none", "skip"]:
append_message = None
break
elif append_message.content.lower() in ["exit"]:
await ctx.send("Member notification prompt cancelled.")
return
await ctx.send("Confirm **" + append_message.content +
"** ?\n(Y:Yes|N:NO)")
prompt = await self.bot.wait_for('message',
check=check,
timeout=60)
if prompt.content.lower() == "y":
break
# Role to assign on join
message = "Specify a role to auto-assign member on joining.```cs\n" \
"> Role must already exist.\n" \
"> Do not tag the role. Enter role name only.\n" \
"> Text is case sensitive.\n" \
"Type \"skip\" or \"none\" to not assign any role on joining.\n" \
"Type \"exit\" to cancel prompt```"
await ctx.send(message)
while True:
assign_role = await self.bot.wait_for('message',
check=check,
timeout=60)
if assign_role.content.lower() in ["skip", "none"]:
assign_role = None
break
elif assign_role.content.lower() in ["exit"]:
await ctx.send("Member notification prompt cancelled.")
return
assign_role = discord.utils.get(ctx.guild.roles,
name=assign_role.content)
if assign_role:
break
else:
await ctx.send(
"**Error 404: Role does not exist** (Text is case-sensitive).\n"
"Try again or type **exit** to cancel.")
# Channel to send notification
message = "Specify a **channel name** to send welcome message.```cs\n" \
"> Channel must already exist.\n" \
"> Do not tag the channel. Enter channel name only.\n" \
"> Text is case sensitive.\n" \
"Type \"skip\", \"none\" or \"exit\" to cancel prompt.```"
await ctx.send(message)
while True:
channel_name = await self.bot.wait_for('message',
check=check,
timeout=60)
if channel_name.content.lower() in ["skip", "none", "exit"]:
await ctx.send(
"Can't enable this feature without a valid channel.")
return
channel_name = discord.utils.get(ctx.guild.text_channels,
name=channel_name.content)
if channel_name:
break
else:
await ctx.send(
"**Error 404: Channel does not exist** (Text is case-sensitive).\n"
"Try again or type **exit** to cancel.")
data = {
"enable": True,
"message": append_message.content if append_message else None,
"role": assign_role.name if assign_role else None,
"channel": channel_name.name
}
await self.member_notification(ctx.author, data, "join")
await ctx.send("Confirm preview sent to #" + channel_name.name +
" ?\n(Y:Yes|R:Restart|N:No)")
prompt = await self.bot.wait_for('message', check=check, timeout=60)
if prompt.content.lower() == "y":
self.DatabaseHelper.server_update_member(
guild_id=ctx.guild.id,
append_message=append_message.content
if append_message else None,
role=assign_role.name if assign_role else None,
channel=channel_name.name)
await ctx.send("Configuration saved successfully.\n"
"Use >help_member_welcome for more information.")
elif prompt.content.lower() == "r":
await self.set_member_welcome(ctx)
return
else:
await ctx.send("Member notification prompt cancelled.")
@commands.command(pass_context=True)
@has_permissions(administrator=True)
async def remove_member_welcome(self, ctx):
def check(msg):
return msg.author == ctx.message.author
message = "Do you wish to remove new member join/leave notifications?\n(Y:YES|N:NO)"
await ctx.send(message)
prompt = await self.bot.wait_for('message', check=check, timeout=30)
if prompt.content.lower() in ["yes", "y"]:
self.DatabaseHelper.server_update_member(guild_id=ctx.guild.id,
append_message=None,
role=None,
channel=None,
enable=False)
await ctx.send("New member notification deactivated.\n"
"Use >help_member_welcome for more information.")
else:
await ctx.send("Prompt cancelled.")
@set_member_welcome.error
@remove_member_welcome.error
async def timeout_error(self, ctx, error):
if isinstance(error, MissingPermissions):
await ctx.send(
"To prevent spam. Only administrator can use this command.")
elif isinstance(error, CommandInvokeError):
await ctx.send(
"Did not receive any reply from user. Exiting config prompt.")
@commands.command(pass_context=True)
async def help_member_welcome(self, ctx):
member_welcome = self.DatabaseHelper.server_query_data(
ctx.guild.id, mode="new_member")
embed = discord.Embed(title="Member Join/Leave Notification",
description="\u200b",
color=0xcc0099)
embed.set_author(
name='Bhartiya',
icon_url="https://cdn.discordapp.com/avatars/429945357808697355"
"/1610303189d607b5665cba3d037226b7.webp?size=128")
embed.set_thumbnail(
url=
"https://cdn.discordapp.com/icons/226611621059887104/c11623908b1fe534e4d129b7856848ad.webp"
)
if member_welcome["enable"]:
embed.add_field(name='Role:',
value=member_welcome["role"],
inline=True)
embed.add_field(name='Channel',
value=member_welcome["channel"],
inline=True)
embed.add_field(name='Message',
value=member_welcome["message"],
inline=True)
embed.add_field(name='\u200b', value="Commands", inline=False)
embed.add_field(name='>set_member_welcome',
value='Update settings for member notification.',
inline=False)
embed.add_field(
name='>remove_member_welcome',
value='Disable member notification from this server.',
inline=False)
else:
embed.add_field(name='Member Notification: Disable',
value="Use >set_member_welcome to enable.",
inline=False)
embed.add_field(name='\u200b', value="Made by:", inline=False)
embed.set_footer(
text="VampireBl00d#2521",
icon_url="https://cdn.discordapp.com/avatars/"
"216236803710124032/287ada789e1944a72a2f826e229cba29.webp")
await ctx.send(embed=embed)
class Commands(commands.Cog):
def __init__(self, bot):
self.bot = bot
try:
data = loads(open("config.json", "r").read())
self.DatabaseHelper = DBManage(url=data["MONGO"])
except FileNotFoundError:
self.DatabaseHelper = DBManage(url=os.getenv("MONGO"))
@commands.command()
async def help(self, ctx):
embed = discord.Embed(title="A General purpose open source bot",
description="\u200b",
color=0xcc0099)
embed.set_author(
name='Bhartiya',
icon_url="https://cdn.discordapp.com/avatars/429945357808697355"
"/1610303189d607b5665cba3d037226b7.webp?size=128")
embed.set_thumbnail(
url=
"https://cdn.discordapp.com/icons/226611621059887104/c11623908b1fe534e4d129b7856848ad.webp"
)
embed.add_field(name='List of command for Bhartiya can be found here:',
value="https://github.com/Ak55073/Bharatiya/wiki",
inline=False)
embed.add_field(name='Official bot repo',
value="https://github.com/Ak55073/Bharatiya",
inline=False)
# Checking which modules are enabled
server_data = self.DatabaseHelper.server_query_data(ctx.guild.id,
mode="help")
if server_data["auto_role"]:
embed.add_field(name='Role Auto Assign: Enable',
value="Use >auto_role to disable.",
inline=False)
else:
embed.add_field(name='Role Auto Assign: Disable',
value="Use >auto_role to enable.",
inline=False)
if server_data["twitch_notification"]["enable"]:
embed.add_field(name='Twitch Notification: Enable',
value="Use >help_twitch for more information.",
inline=False)
else:
embed.add_field(name='Twitch Notification: Disable',
value="Use >help_twitch for more information.",
inline=False)
if server_data["new_member_notification"]["enable"]:
embed.add_field(
name='New Member Notification: Enable',
value="Use >help_member_welcome for more information.",
inline=False)
else:
embed.add_field(
name='New Member Notification: Disable',
value="Use >help_member_welcome for more information.",
inline=False)
if server_data["self_assign"]["enable"]:
embed.add_field(
name='Self Assign Role: Enable',
value="Use >help_self_assign for more information.",
inline=False)
else:
embed.add_field(
name='Self Assign Role: Disable',
value="Use >help_self_assign for more information.",
inline=False)
embed.add_field(name='\u200b', value="Made by:", inline=False)
embed.set_footer(
text="VampireBl00d#2521",
icon_url="https://cdn.discordapp.com/avatars/"
"216236803710124032/287ada789e1944a72a2f826e229cba29.webp")
await ctx.send(embed=embed)
await ctx.send(
"Suggestions are always welcomed, Use **>suggest_bot <message>** to send suggestions."
)
@commands.command()
async def change(self, ctx):
if str(ctx.author.id) == str(self.bot.owner_id):
await self.bot.change_presence(activity=discord.Game(
name=ctx.message.content[8:]))
@commands.command()
async def suggest_bot(self, ctx):
message = ctx.message.content[
12:] + "\n\nThis Message was sent by:\n **" + str(
ctx.message.author) + "**"
owner = await self.bot.fetch_user(str(self.bot.owner_id))
await owner.send(message)
await ctx.send("Your feedback has been received successfully.")
@commands.command(pass_context=True)
@has_permissions(manage_messages=True)
async def clear(self, ctx, number):
number = int(number) + 1
counter = 0
if number > 101:
await ctx.send("Limit should not more then 100")
return
async for x in ctx.message.channel.history(limit=number):
if counter < number:
await x.delete()
counter += 1
@clear.error
async def clear_error(self, ctx, error):
if isinstance(error, MissingPermissions):
await ctx.send(
"To prevent data loss. Only user with manage_messages permission can use clear command."
)