async def get_skill_data(self, skill_dict):
"""Gather the skill data names from the database."""
elite = ''
heal = ''
utilities = ''
elite_id = skill_dict['elite']
heal_id = skill_dict['heal']
utilities_list = skill_dict['utilities']
elite = DatabaseHandler().fetch_results(
"SELECT skill_name FROM gw2_skills WHERE skill_id = {0}".format(
elite_id))
heal = DatabaseHandler().fetch_results(
"SELECT skill_name FROM gw2_skills WHERE skill_id = {0}".format(
heal_id))
for key in range(3):
utility_id = utilities_list[key]
skill_name = DatabaseHandler().fetch_results(
"SELECT skill_name FROM gw2_skills WHERE skill_id = {0}".
format(utility_id))
utilities = utilities + ', ' + skill_name[0]
# trim the leading ", "
utilities = utilities[2:]
return_string = ("**__Skills__** \n\n"
"Heal: {0} \n"
"Utilities: {1} \n"
"Elite: {2}".format(heal[0], utilities, elite[0]))
return return_string
async def register(self, ctx, member: discord.Member=None):
""" Register for betting.
:member: empty discord.Member object
"""
member = ctx.message.author
member_id = ctx.message.author.id
display_name = ctx.message.author.name
server_id = ctx.message.server.id
# Load some config settings
channel_id = ConfigLoader().load_server_int_setting(
server_id,
'BettingGame',
'bet_channel_id'
)
plugin_enabled = ConfigLoader().load_server_boolean_setting(
server_id,
'BettingGame',
'enabled'
)
# Have to cast ctx.message.channel and ctx.message.server to strings
if (member is not None
and int(ctx.message.channel.id) == channel_id
and plugin_enabled
):
row = DatabaseHandler().fetch_results(
"SELECT 1 FROM credit_bet WHERE userID = {0} \
and serverID = {1}".format(str(member_id), str(server_id))
)
if row is None:
query = """
INSERT INTO credit_bet (serverID, username, userID, \
displayName, credits, dateJoined, timesBet, lastClaimTime) \
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
"""
DatabaseHandler().insert_into_database(
query,
(
str(server_id),
str(member),
member_id,
display_name,
500,
str(datetime.now()),
0,
str(datetime.now())
)
)
await self.bot.say(
"{0.mention}, you are now registered! {1}bet to play! " \
"Goodluck!".format(member, self.prefix))
else:
await self.bot.say(
"{0.mention}: you're already registered. Please do {1}bet " \
"to play!".format(member, self.prefix))
async def add_api_key(self,
ctx,
apikey: str,
member: discord.Member = None):
""" Add API key to bot. """
member = ctx.message.author
member_id = ctx.message.author.id
if ctx.message.channel.is_private:
if member is not None:
row = DatabaseHandler().fetch_results(
"SELECT 1 FROM api WHERE discord_id = {0}".format(
str(member_id)))
if row is None:
permissions = ['account', 'builds', 'characters']
self.base_url = 'https://api.guildwars2.com/v2/tokeninfo?access_token='
self.response_url = self.base_url + str(apikey)
self.header = urllib.parse.urlencode(self.header_dict)
self.header = self.header.encode("utf-8")
response = urlopen(self.response_url)
response = response.read()
response = response.decode("utf-8")
self.data = json.loads(response)
granted_permissions = []
for value in self.data['permissions']:
granted_permissions.append(value)
for permission in permissions:
if permission not in granted_permissions:
return await self.bot.say(
"Missing required API permission(s). \
Require account, builds, characters.")
query = """INSERT INTO api (discord_id, api_key) VALUES (?, ?)"""
DatabaseHandler().insert_into_database(
query, (str(member_id), apikey))
return await self.bot.say(
"{0.mention}, API key added.".format(member))
else:
return await self.bot.say(
"You already have an API key registered.")
else:
return await self.bot.say(
"Some unknown error occured. Please try again.")
else:
await self.bot.delete_message(ctx.message)
return await self.bot.say(
"{0.mention}: please private message me your API key.".format(
member))
async def balance(self, ctx, member: discord.Member=None):
""" Get user balance.
:member: empty discord.Member object
"""
member = ctx.message.author
member_id = ctx.message.author.id
server_id = ctx.message.server.id
# Load some config settings
channel_id = ConfigLoader().load_server_int_setting(
server_id,
'BettingGame',
'bet_channel_id'
)
plugin_enabled = ConfigLoader().load_server_boolean_setting(
server_id,
'BettingGame',
'enabled'
)
# Have to cast ctx.message.channel and ctx.message.server to strings
if member is not None and int(ctx.message.channel.id) == channel_id and plugin_enabled:
row = DatabaseHandler().fetch_results(
"SELECT 1 FROM credit_bet WHERE userID = {0} \
and serverID = {1}".format(str(member_id), str(server_id))
)
#print("Row: {}".format(row))
if row is None:
return await self.bot.say(
"{0.mention}: please do {1}register to " \
"join the lotto.".format(member, self.prefix))
else:
remaining_credits = DatabaseHandler().fetch_results(
"SELECT credits FROM credit_bet \
WHERE userID = {0} AND serverID = {1}".format(
str(member_id),
str(server_id)
)
)
await self.bot.say(
"{0.mention}: your balance is {1}.".format(
member,
remaining_credits[0]
)
)
async def reset_lotto_entries(self, ctx, member: discord.Member=None):
"""Reset the lotto entries for the server where
where the commands is being used.
:member: empty discord.Member object
"""
member = ctx.message.author
member_id = ctx.message.author.id
server_id = ctx.message.server.id
bot_admin_users = []
bot_admin_roles = []
user_roles_list = []
for user_role in ctx.message.author.roles:
user_roles_list.append(str(int(user_role.id)))
try:
bot_admins_user_list = ConfigLoader().load_server_string_setting(
ctx.message.server.id,
'BotAdmins',
'bot_admin_users'
)
bot_admins_role_list = ConfigLoader().load_server_string_setting(
ctx.message.server.id,
'BotAdmins',
'bot_admin_roles'
)
for user in bot_admins_user_list.split():
bot_admin_users.append(user)
for role in bot_admins_role_list.split():
bot_admin_roles.append(role)
except (configparser.NoSectionError, configparser.Error):
pass
try:
if member_id == ctx.message.server.owner_id or \
int(member_id) == ConfigLoader().load_config_setting_int(
'BotSettings', 'owner_id'
) or \
str(member_id) in bot_admin_users or \
[admin_role for admin_role in user_roles_list if admin_role in bot_admin_roles]:
args = (str(server_id),)
DatabaseHandler().update_database_with_args(
"DELETE FROM credit_bet WHERE serverID = ?",
args
)
return await self.bot.say("{0.mention}: lottery table for this server reset.".format(member))
except configparser.Error as config_error:
print("Error with resetlotto command.")
async def scores(self, ctx, member: discord.Member=None):
"""Display the top 5 with > 0 points.
:member: empty discord.Member object
"""
member = ctx.message.author
server_id = ctx.message.server.id
channel_id = ConfigLoader().load_server_int_setting(
server_id,
'BettingGame',
'bet_channel_id'
)
plugin_enabled = ConfigLoader().load_server_boolean_setting(
server_id,
'BettingGame',
'enabled'
)
if (
member is not None
and int(ctx.message.channel.id) == channel_id
and plugin_enabled
):
output_string = ''
row = DatabaseHandler().fetch_all_results(
"SELECT displayName, credits, timesBet \
FROM credit_bet WHERE serverID = {0} AND credits > 0 \
ORDER BY credits DESC LIMIT 5"
.format(str(server_id))
)
if len(row) > 0:
names = {d[0] for d in row}
max_name_len = max(map(len, names))
max_name_len = 22 if max_name_len > 22 else max_name_len
spacer = max_name_len + 4
output_string = '```{0: <{1}} Credits\n'.format('User', spacer)
output_string = output_string + '{0: <{1}} -------\n'.format('----', spacer)
for item in enumerate(row):
# Add the name and credit amounts of the top 5 users.
# Truncate usernames at 22 spaces and add '..'
output_string = output_string + "{0: <{1}} {2}\n".format(
item[1][0][:22] + '..' if len(item[1][0]) > 22 else item[1][0],
spacer,
item[1][1]
)
output_string = output_string + "\n```"
return await self.bot.say(output_string)
else:
return await self.bot.say("There are no users currently in the lotto, or " \
"all participating users have 0 credits.")
def check_accepted(user_id):
"""
Check if a user has accepted the terms of service for the bot to remain Discord ToS compliant
:param user_id: discord.Member userID
:return: True if accepted, False if not
"""
row = DatabaseHandler().fetch_results(
"SELECT 1 FROM accepted_users WHERE discord_id = {0}".format(str(user_id))
)
if row is not None:
return True
return False
async def add_accepted_user(self, ctx, member: discord.Member=None):
"""
If a user accepts the bot terms of service, and has not
already accepted the terms of service, this will enter them
into the database so they won't need to accept the terms again.
"""
member = ctx.message.author
member_id = ctx.message.author.id
has_accepted = BotResources().check_accepted(member_id)
if has_accepted:
return await self.bot.say("You've already accepted my terms of service.")
else:
query = """INSERT INTO accepted_users (discord_id) VALUES (?)"""
DatabaseHandler().insert_into_database(query, (str(member_id), ))
return await self.bot.say("{0.mention}: thanks for accepting. You may now " \
"use commands.".format(member))
from resources.parse import Parser
from resources.database import DatabaseHandler
from resources.sentiment import sentiment_analysis
from pymongo import MongoClient
from bson.objectid import ObjectId
import os
import json
import requests
from resources.media_services import processVideo
app = Flask(__name__)
CORS(app)
download_handler = VideoDownloader()
client = MongoClient('mongodb://*****:*****@hacktech-2018.documents.azure.com:10255/?ssl=true&replicaSet=globaldb')
db = DatabaseHandler(client['HackTech2018'].VideoData)
headers = {
# Request headers
'Ocp-Apim-Subscription-Key': '64edd068ee5140a7b6ce2c9790c4f7f2',
}
@app.route('/')
def hello_world():
return "Welcome Bitch"
@app.route('/callback', methods=['POST'])
def callback():
bid = request.args.get('id')
state = request.args.get('state')
async def bet(self, ctx, amount: int, member: discord.Member=None):
""" Let's bet.
:amount: the amount the user has decided to bet
:member: empty discord.Member object
"""
member = ctx.message.author
member_id = ctx.message.author.id
server_id = ctx.message.server.id
# Load some config settings
channel_id = ConfigLoader().load_server_int_setting(
server_id,
'BettingGame',
'bet_channel_id'
)
# if this fails it's not a boolean so we'll fix that but disable the plugin
plugin_enabled = ConfigLoader().load_server_boolean_setting(
server_id,
'BettingGame',
'enabled'
)
minimum_bet = ConfigLoader().load_server_int_setting(
server_id,
'BettingGame',
'minimum_bet'
)
if (
isinstance(amount, int)
and plugin_enabled
and int(ctx.message.channel.id) == channel_id
):
# Have to cast ctx.message.channel.id and ctx.message.server.id to ints
if member is not None and amount >= minimum_bet:
row = DatabaseHandler().fetch_results(
"SELECT 1 FROM credit_bet WHERE userID = {0} and serverID = {1}".format(
str(member_id),
str(server_id)
)
)
if row is None:
return await self.bot.say(
"{0.mention}: please do {1}register to join the lotto.".format(
member,
self.prefix
)
)
else:
remaining_credits = DatabaseHandler().fetch_results(
"SELECT credits FROM credit_bet WHERE userID = {0} AND \
serverID = {1}".format(
str(member_id),
str(server_id)
)
)
if remaining_credits[0] < amount:
return await self.bot.say(
"Insufficient credits ({0})".format(
remaining_credits[0]
)
)
else:
bot_number = random.randint(1, 100)
user_number = random.randint(1, 100)
if bot_number > user_number:
new_balance = remaining_credits[0] - amount
DatabaseHandler().update_database(
"UPDATE credit_bet SET credits = {0} WHERE userID = {1} \
AND serverID = {2}".format(
new_balance,
str(member_id),
str(server_id)
)
)
await self.bot.say(
"Sorry, {0.mention}, you lost with a roll of {1} " \
"against {2}! Your balance is now {3}!"
.format(member, user_number, bot_number, new_balance)
)
elif user_number > bot_number:
new_balance = remaining_credits[0] + amount
DatabaseHandler().update_database(
"UPDATE credit_bet SET credits = {0} \
WHERE userID = {1} AND serverID = {2}"
.format(new_balance, str(member_id), str(server_id))
)
await self.bot.say(
"Congratulations, {0.mention}, you won with a roll " \
"of {1} against {2}! Your balance is now {3}!"
.format(member, user_number, bot_number, new_balance)
)
else:
await self.bot.say(
"It was a tie, {0.mention}, with a roll of {1}! " \
"Your balance remains {2}!".format(
member,
user_number,
remaining_credits[0]
)
)
else:
await self.bot.say("The minimum bet is {0}".format(minimum_bet))
return
async def helpme(self, ctx):
"""Free credits for those that qualify.
By default, this will check against a 24 hour timer to determinme
if the user is eligable to use the command again.
@TODO: allow owners to enable setting so that the 24 hour timer
only begins after the user has run out of credits
"""
member_id = ctx.message.author.id
member = ctx.message.author
server_id = ctx.message.server.id
# Load some config settings
channel_id = ConfigLoader().load_server_int_setting(
server_id,
'BettingGame',
'bet_channel_id'
)
# Grab the time between helpme users as set by the server
helpme_timer = ConfigLoader().load_server_int_setting(
server_id,
'BettingGame',
'helpme_cooldown'
)
# Grab the minimum credits for using helpme
minimum_credits = ConfigLoader().load_server_int_setting(
server_id,
'BettingGame',
'helpme_minimum'
)
# Grab how many credits they get when using helpme
helpme_bonus = ConfigLoader().load_server_int_setting(
server_id,
'BettingGame',
'helpme_bonus'
)
# check if the plugin enabled; if bad value, the function inside
# of main will handle catching that
plugin_enabled = ConfigLoader().load_server_boolean_setting(
server_id,
'BettingGame',
'enabled'
)
if plugin_enabled and int(ctx.message.channel.id) == channel_id:
information = DatabaseHandler().fetch_all_results(
'SELECT credits, lastClaimTime AS \
"[timestamp]" FROM credit_bet WHERE \
userID = {0} AND serverID = {1}'.format(
str(member_id),
str(server_id))
)
current_date = datetime.now()
member_credits = information[0][0]
last_used_time = information[0][1]
if member_credits >= minimum_credits:
return await self.bot.say(
"{0.mention}, you are above the minimum amount {1}; you " \
"cannot use this command (balance of {2}).".format(
member,
minimum_credits,
member_credits
)
)
else:
if last_used_time is not None:
self.total_seconds = (current_date - last_used_time).total_seconds()
if int(self.total_seconds) >= helpme_timer:
self.total_seconds = int(helpme_timer - self.total_seconds)
self.total_hours = int(self.total_seconds / 3600)
self.used_secs = int(self.total_hours * 3600)
self.seconds_left = int(self.total_seconds - self.used_secs)
self.final_minutes = int(self.seconds_left / 60)
formatted_string = "{0}h:{1}m".format(
self.total_hours * -1,
self.final_minutes * -1
)
new_credits = member_credits + helpme_bonus
args = (new_credits, str(current_date), str(member_id), str(server_id), )
DatabaseHandler().update_database_with_args(
"UPDATE credit_bet SET credits = ?, \
lastClaimTime = ? WHERE userID = ? AND serverID = ?",
args
)
return await self.bot.say(
"{0.mention}, you have been given an additional {1} credits! " \
"Your 24 cooldown ended {2} ago!".format(
member,
helpme_bonus,
formatted_string
)
)
else:
# should we output seconds too?
self.total_seconds = int(helpme_timer - self.total_seconds)
self.total_hours = int(self.total_seconds / 3600)
self.used_secs = int(self.total_hours * 3600)
self.seconds_left = int(self.total_seconds - self.used_secs)
self.final_minutes = int(self.seconds_left / 60)
final_seconds = int(self.seconds_left - (self.final_minutes * 60))
formatted_string = "{0}h:{1}m:{2}s".format(
self.total_hours,
self.final_minutes,
final_seconds
)
converted_hour = convert_seconds_to_hour(helpme_timer)
return await self.bot.say(
"{0.mention}, you can only use this command every {1} hours ({2}), " \
"and if at or below {3} credits :cry:".format(
member,
converted_hour,
formatted_string,
minimum_credits
)
)
async def build(self,
ctx,
game_type: str,
*,
character_name: str,
member: discord.Member = None):
""" Get PvE, WvW, PvP build info for supplied character. """
member = ctx.message.author
member_id = ctx.message.author.id
server_id = str(ctx.message.server.id)
plugin_enabled = ConfigLoader().load_server_boolean_setting(
server_id, 'ApiCommands', 'enabled')
# Each new part of the name needs to be upper case, so firstly we will
# make everything lower case and then do the upper casing
character_name = character_name.lower()
character_name = ' '.join(word[0].upper() + word[1:]
for word in character_name.split())
# lower case the game type, just in case
game_type = game_type.lower()
# to make this work, check if the plugin is in the list
if member is not None and plugin_enabled:
row = DatabaseHandler().fetch_results(
"""SELECT api_key FROM api WHERE discord_id = {0}""".format(
member_id))
if row is not None:
try:
character_name = character_name.replace(" ", "%20")
returned_skill_ids = await self.get_skill_ids(
character_name, row[0], game_type)
returned_char_info = await self.get_character_level(
row[0], character_name)
returned_trait_ids = await self.get_trait_ids(
character_name, row[0], game_type)
returned_skill_data = await self.get_skill_data(
returned_skill_ids)
returned_trait_data = await self.get_trait_data(
returned_trait_ids)
return_string = ("{0.mention}: \n"
"```{1}```\n\n"
"{2}\n\n"
"{3}".format(member, returned_char_info,
returned_trait_data,
returned_skill_data))
return await self.bot.say(return_string)
except urllib.error.HTTPError as error_code:
if error_code.code == 400:
print("{0}".format(character_name))
print("{0}".format(game_type))
print("{0}".format(error_code))
await self.bot.say("Character not found.")
else:
print(
"There was an error with the build command: {0}.".
format(error_code))
return
else:
return await self.bot.say(
"{0.mention}, please private message me your API key.".
format(member))
async def get_trait_data(self, trait_dict):
""" Except not really a dict. """
# @TODO : could split into three functions, help make pylint stop complaining
trait_list = []
trait_spec_list = []
trait_one = ''
trait_list_one = ''
trait_two = ''
trait_list_two = ''
trait_three = ''
trait_list_three = ''
# this is awful, but works
for item in enumerate(trait_dict):
for key in item[1]:
if key == 'traits':
for value in item[1].values():
for internal_value in value:
trait_list.append(internal_value)
else:
for value in item[1].values():
trait_spec_list.append(value)
trait_one = DatabaseHandler().fetch_results(
"SELECT spec_name FROM gw2_specs WHERE spec_id = {0}".format(
int(trait_spec_list[0])))
trait_two = DatabaseHandler().fetch_results(
"SELECT spec_name FROM gw2_specs WHERE spec_id = {0}".format(
int(trait_spec_list[1])))
trait_three = DatabaseHandler().fetch_results(
"SELECT spec_name FROM gw2_specs WHERE spec_id = {0}".format(
int(trait_spec_list[2])))
# we're cheating here since we know it's always 9 total traits
for counter in range(9):
spec_name = DatabaseHandler().fetch_results(
"SELECT trait_name FROM gw2_traits WHERE trait_id = {0}".
format(int(trait_list[counter])))
if counter in range(3):
trait_list_one = trait_list_one + ', ' + spec_name[0]
elif counter in range(3, 6):
trait_list_two = trait_list_two + ', ' + spec_name[0]
else:
trait_list_three = trait_list_three + ', ' + spec_name[0]
trait_list_one = trait_list_one[2:]
trait_list_two = trait_list_two[2:]
trait_list_three = trait_list_three[2:]
return_string = ("**__Traits__** \n\n"
"{0}: {1} \n"
"{2}: {3} \n"
"{4}: {5}".format(trait_one[0], trait_list_one,
trait_two[0], trait_list_two,
trait_three[0], trait_list_three))
return return_string