async def whitelist(self, ctx, *, content):
"""
Allows A User To Whitelist Themselves On The Connected MC Server
"""
await ctx.message.delete()
# Return If There Is No Argument
if content.strip == "":
return
# Get Users Database Entry
cur.execute("select whitelist from user_data where discord_user_id = %s", (str(ctx.author.id),))
is_present = cur.fetchone()
if is_present is None:
await global_functions.add_user_db_row(ctx.author)
# Check If They Have Already Used The Command Or The User Is Not A Bot Admin
if is_present is False and ctx.author.id != 451848182327148554:
await ctx.send(embed=await global_functions.create_embed(title="fail",
description=
"You Already Have An Account Whitelisted\n"
"If You Changed Your Account Name Or Got A New "
"Account Please Contact A Staff Member.",),
delete_after=30)
return
# Else Add Them To The Whitelist And Update Database
else:
user_id = str(ctx.author.id)
sql = "UPDATE user_data SET whitelist=false WHERE discord_user_id=%s"
cur.execute(sql, (user_id,))
DB_conn.commit()
# MCClient.client.send_console_command(srv_id, "whitelist add " + content)
await ctx.send(embed=await global_functions.create_embed(title="Success",
description=
"Minecraft User {} Has Been Added To The"
" Whitelist".format(content)),
delete_after=30)
async def add_user_db_row(member):
cur.execute(
"INSERT INTO user_data (discord_user, discord_user_id, whitelist, guild_id) "
"VALUES ('{}', {}, True, {});".format(
member.name + "#" + member.discriminator, member.id,
member.guild.id))
DB_conn.commit()
async def list(self, ctx):
await ctx.message.delete()
sql = f"SELECT emoji_id, message_id, role_id, channel_id FROM reaction_roles " \
f"WHERE guild_id='{ctx.guild.id}'"
cur.execute(sql, ())
rr_list = cur.fetchall()
rr_string = ""
for row in rr_list:
if len(row[0]) == 18:
emoji = await ctx.guild.fetch_emoji(int(row[0]))
emoji = f"<:{emoji.name}:{row[0]}>"
else:
emoji = row[0]
role = ctx.guild.get_role(int(row[2]))
if role is None:
role = "Not Found"
else:
role = role.mention
rr_string = f"{rr_string}» [Message](https://discordapp.com/channels/{ctx.guild.id}/{row[3]}/{row[1]}) | Emoji : {emoji} | Role: {role}\n"
embed = discord.Embed(
title=f"{ctx.guild.name}'s Reaction Roles",
description=rr_string,
type="rich",
)
await ctx.send(embed=embed)
async def remove(self, ctx, emoji, message_id):
# if len(emoji) != 1 and (len(emoji) != 18 or emoji.isdigit()):
if len(message_id) != 18 or not message_id.isdigit():
await ctx.send(
"Make sure to follow the format `w!rr remove <emoji> <message_id>"
)
return
try:
emoji_id = await commands.PartialEmojiConverter().convert(
ctx=ctx, argument=emoji)
emoji_id = emoji_id.id
except commands.BadArgument:
emoji_id = emoji
sql = f"DELETE FROM reaction_roles " \
f"WHERE message_id='{message_id}' AND emoji_id='{emoji_id}'"
try:
await ctx.message.add_reaction(emoji)
cur.execute(sql, ())
if cur.rowcount == 0:
await ctx.send("That Is Not A Reaction Role Message/Emoji")
else:
DB_conn.commit()
await ctx.send("Successfully Deleted The Reaction Role")
except discord.HTTPException:
await ctx.send("That Is Not A Valid Emoji")
def update_pet_resource():
val = request.json
for column in request.json.keys():
if column != 'id':
sql = "update pets set {0} = '{1}' where id = {2};" .format(column, val[column], val['id'])
cur.execute(sql)
db.commit()
return jsonify({'Success': True})
async def predicate(ctx):
# Get DB row
cur.execute("SELECT role_id, bypass_role "
"FROM roles WHERE guild_id=%s and (" + module_roles + "=True OR bypass_role=True)",
(str(ctx.guild.id),))
rows = cur.fetchall()
# print(roles[0])
# print(roles[0][0])
approved_roles = []
bypass_roles = []
for role in rows:
# check if the column is not empty
# if role[0] is True:
# approved_roles.append(role[0])
# if row[0][1] is not None:
# channel = row[0][1]
# else:
# channel = []
if role[1] == 1:
bypass_roles.append(role[0])
else:
approved_roles.append(role[0])
# get the authors current roles
author_roles = []
for i in ctx.author.roles:
author_roles.append(i.id)
# If the user is admin let them continue
if ctx.author.guild_permissions.administrator:
return True
# check if the user has a bypass role if so let them continue
for item in bypass_roles:
if int(item) in author_roles:
return True
# check if the user has a allowed role if so let them continue
for item in approved_roles:
if int(item) in author_roles:
# Check if they are in an approved channel.
# Call the Channel DB
cur.execute("SELECT channel_id FROM text_channels WHERE guild_id=%s and " + module_channels + "=True",
(str(ctx.guild.id),))
rows = cur.fetchall()
# Check if channels is None.
channel_ids = []
for channel in rows:
channel_ids.append(channel[0])
# channel_ids = []
# for i in ctx.guild.text_channels:
# channel_ids.append(i.id)
if str(ctx.channel.id) in channel_ids:
return True
def update(nazwa, wagon_bazowy):
cur.execute("SELECT EXISTS(SELECT 1 FROM wagony WHERE nazwa = %s);",
(nazwa, ))
value = cur.fetchone()[0]
if value:
nazwa_wagonu = wagon_bazowy.get("nazwa")
cur.execute("UPDATE wagony SET nazwa = %S WHERE nazwa = %s)",
(nazwa, nazwa_wagonu))
else:
abort(406, "Wagon o tej nazwie nie istnieje")
def delete(nazwa):
cur.execute("SELECT EXISTS(SELECT 1 from wagony where nazwa = %s);",
(nazwa, ))
val = cur.fetchone()[0]
if val:
cur.execute("DELETE FROM wagony WHERE nazwa = %s CASCADE;", (nazwa, ))
connection.commit()
return "Deleted successfully", 201
else:
abort(404, "Wagon o tej nazwie nie znaleziona")
async def modify_database(guild: str, id_list, setting, key,
identifier_column):
for id in id_list:
sql = f"INSERT INTO {setting} ({key}, guild_id, {identifier_column}) " \
f"VALUES (true, {guild}, {id}) " \
f"ON DUPLICATE KEY UPDATE " \
f"{key}=true;"
# sql = f"UPDATE {setting} SET {key}={value} WHERE guild_id =%s"
cur.execute(sql, ())
DB_conn.commit()
async def on_member_join(member):
# Sets Up The Users Database User Info When A User Join A Server
cur.execute(
"SELECT * FROM user_data WHERE discord_user_id=%s AND guild_id=%s",
(str(member.id), str(member.guild.id)))
row = cur.fetchall()
print(row)
if row:
return
else:
await global_functions.add_user_db_row(member)
def read_all():
u_id = current_user.id
wagony = []
cur.execute(
"""SELECT (json_build_object('nazwa',b.nazwa,'numer',t.numer,'numer_wagonu',wt.numer_wagonu,'dlugosc',w.dlugosc,'czas_wjazdu',wt.czas_wjazdu,
'czas_wyjazdu',wt.czas_wyjazdu,'czas_na_torze',wt.czas_na_torze,'opuscil_tor',wt.opuscil_tor)) FROM wagony_na_torze wt, tory t,bocznica b,wagony w WHERE
wt.t_id=t.t_id AND wt.w_id = w.w_id AND t.b_id = b.b_id AND wt.opuscil_tor=FALSE AND u_id = %s;""",
(u_id, ))
results = cur.fetchone()
for row in results:
wagony.append(row)
return results
def read_all():
"""
Funkcja odpowiada na request api/firmy i zwraca liste firm
:return: list firm w json
"""
# Create the list of scores from our data
tory = []
cur.execute("SELECT * FROM wyswietl_firmy;")
results = cur.fetchone()
for row in results:
tory.append(row)
return results
def zajetosc_toru(nazwa_bocznicy, numer_toru):
"""
Funckja zwraca zajetosc podanego toru
:param nazwa_bocznicy:
:param numer_toru:
:return:
"""
u_id = current_user.id
cur.execute("SELECT zajetosc_toru(%s,%s,%s);",
(nazwa_bocznicy, numer_toru, u_id))
zajetosc = cur.fetchone()[0]
return zajetosc
def read_all():
"""
Funkcja odpowiada na request api/podsumowanie i zwraca liste
firm ktore korzystaly z bocznicy uzytkownika czas ich wszystkich wagonow na torach
oraz kwote jaka musza zaplacic
:return: podsumowanie json list
"""
# Create the list of scores from our data
u_id = current_user.id
cur.execute("SELECT podsumowanie_torow(%s,%s);", (u_id, 4))
results = cur.fetchone()
return results
async def add(self, ctx, emoji, message_id, role_id, channel_id=None):
# if len(emoji) != 1:
# emoji_id = emoji[-19:-1]
# else:
# emoji_id = emoji
try:
emoji_id = await commands.PartialEmojiConverter().convert(
ctx=ctx, argument=emoji)
emoji_id = emoji_id.id
except commands.BadArgument:
emoji_id = emoji
if channel_id is None:
channel_id = ctx.channel.id
# if len(emoji_id) != 1 and (len(emoji_id) != 18 or not emoji_id.isdigit()):
if len(message_id) != 18 or not message_id.isdigit():
if len(role_id) != 18 or not role_id.isdigit():
if channel_id is not None:
if len(channel_id) != 18 or not channel_id.isdigit():
await ctx.send(
"Make sure to follow the format `w!rr add <emoji> <message_id> <role_id> [channel_id]"
)
return
sql = f"INSERT INTO reaction_roles (message_id , emoji_id, guild_id, role_id, channel_id) " \
f"VALUES ('{message_id}', '{emoji_id}', '{ctx.guild.id}', '{role_id}', '{channel_id}')"
try:
channel = await discordClient.fetch_channel(channel_id)
try:
message = await channel.fetch_message(message_id)
try:
await message.add_reaction(emoji)
cur.execute(sql, ())
DB_conn.commit()
await ctx.send("The Reaction Role Was Added!")
except discord.Forbidden:
await ctx.send(
"I Dont Have Permission To Add Reactions Here")
except discord.HTTPException:
await ctx.send("I Could Not Find That Emoji")
except discord.NotFound:
await ctx.send(
"I Couldnt Find That Message. Make Sure The Message Is In This Channel And It Is A Valid Message ID: `w!rr id`\n"
"If The Message Is Not In This Channel Add The Channel ID After The Role ID In The Command."
)
except discord.NotFound:
await ctx.send("I Couldent Find The Channel You Wanted")
def read_one(nazwa):
wagony = []
cur.execute("SELECT sprawdz_czy_istnieje(%s)", (nazwa, ))
value = cur.fetchone()[0]
if value:
cur.execute(
"SELECT array_to_json((row_to_json(w))) FROM wagony_na_torze w WHERE numer_wagonu = %s;",
(nazwa, ))
results = cur.fetchone()
for row in results:
wagony.append(row)
return results
else:
abort(404, "Wagon o tej nazwie nie znaleziony")
def opusc_tor(numer_wagonu):
"""
Funkcja ustawia czas wyjazdu, czas pobytu i wartosc true dla
pola opuscil_tor
:param numer_wagonu:
:return:
"""
cur.execute("SELECT opusc_bocznice(%s)", (numer_wagonu, ))
value = cur.fetchone()[0]
connection.commit()
if value:
return "Wagon opuscil bocznice", 201
else:
abort(404, "Wagon o tym numerze nie znaleziony")
def delete(NIP):
"""
Funckja usuwa firme o podanym NIPie
:param NIP:
:return:
"""
cur.execute("SELECT EXISTS(SELECT 1 from firmy where NIP = %s);", (NIP, ))
print(NIP)
value = cur.fetchone()[0]
if value:
cur.execute("DELETE FROM firmy WHERE NIP=%s;", (NIP, ))
connection.commit()
return "Usunieto pomyslnie", 201
else:
abort(404, "Firma o tym NIPie nie znaleziona")
def read_all():
"""
Funckja odpowiada na request /api/tory
i zwraca kompletna liste torow uzytkownika
:return: lista torow
"""
# Create the list of scores from our data
u_id = current_user.id
tory = []
cur.execute("SELECT wyswietl_tory(%s);", (u_id, ))
results = cur.fetchone()
for row in results:
print(str(row)[1:-1])
tory.append(row)
return results
def firma_uzytkownika(NIP):
"""
Funckja aktualizuje f_id podanej firmy do uzytkownika
:param NIP:
:return:
"""
u_id = current_user.id
cur.execute("SELECT dodaj_firme_uzytkownika(%s,%s)", (NIP, u_id))
value = cur.fetchone()[0]
print(value)
connection.commit()
if value:
return "Firma dodana do uzytkownika", 201
else:
abort(404, "Firma o tym numerze nie znaleziona")
def delete(numer_wagonu):
"""
:param date:
:return:
"""
cur.execute(
"SELECT EXISTS(SELECT 1 from wagony_na_torze where numer_wagonu = %s;",
(numer_wagonu, ))
val = cur.fetchone()[0]
if val:
cur.execute("DELETE FROM wagony_na_torze WHERE numer_wagonu = %s;",
(numer_wagonu))
connection.commit()
return "Deleted successfully", 201
else:
abort(404, "Bocznica o tej nazwie nie znaleziona")
def read_one(NIP):
"""
Funckja odpowiada na request /api/firmy/{NIP} i zwraca pojedynczy rekord
:return:
"""
tory = []
cur.execute("SELECT EXISTS(SELECT 1 from firmy where NIP = %s);", (NIP, ))
value = cur.fetchone()[0]
if value:
cur.execute("SELECT wyswietl_firme(%s);", (NIP, ))
results = cur.fetchone()
for row in results:
tory.append(row)
return results
else:
abort(404, "Score in this day not found")
def firma_wagonow(NIP):
"""
Funckja aktualizuje f_id podanej firmy dla wszystkich wagonow posiadajacych taka sama nazwe firmy
:param NIP:
:return:
"""
cur.execute("SELECT nazwa FROM firmy WHERE NIP = %s;", (NIP, ))
nazwa_firmy = cur.fetchone()[0]
print(nazwa_firmy)
cur.execute("SELECT dodaj_firme_wagonow(%s,%s)", (NIP, nazwa_firmy))
value = cur.fetchone()[0]
print(value)
connection.commit()
if value:
return "Firma dodana do wagonu", 201
else:
abort(404, "Firma o tym numerze nie znaleziona")
def read_one(numer_wagonu):
"""
This function responds to a request for /api/scores/{id}
:return:
"""
wagony = []
cur.execute("SELECT sprawdz_czy_istnieje(%s)", (numer_wagonu, ))
value = cur.fetchone()[0]
if value:
cur.execute(
"SELECT array_to_json((row_to_json(w))) FROM wagony_na_torze w WHERE numer_wagonu = %s;",
(numer_wagonu, ))
results = cur.fetchone()
for row in results:
wagony.append(row)
return results
else:
abort(404, "Wagon o tym numerze nie znaleziony")
def delete(nazwa):
"""
Funkcja usuwa bocznice o zadanej nazwie
:param date:
:return:
"""
u_id = current_user.id
cur.execute(
"SELECT EXISTS(SELECT 1 from bocznica where nazwa = %s AND u_id = %s);",
(nazwa, u_id))
val = cur.fetchone()[0]
if val:
cur.execute("DELETE FROM bocznica WHERE nazwa = %s AND u_id= %s;",
(nazwa, u_id))
connection.commit()
return "Usunieto pomyslnie", 201
else:
abort(404, "Bocznica o tej nazwie nie znaleziona")
def signup_post():
email = request.form.get('email')
name = request.form.get('name')
password = request.form.get('password')
print(email)
cur.execute(
"SELECT EXISTS(SELECT 1 FROM uzytkownik where email_uzytkownika = %s);",
(email, ))
value = cur.fetchone()[0]
if value:
flash('Email address already exists')
return redirect(url_for('auth.signup'))
cur.execute(
"INSERT INTO uzytkownik (email_uzytkownika,nazwa_uzytkownika,haslo) values (%s,%s,%s);",
(email, name, password))
connection.commit()
return redirect(url_for('profile'))
def read_one(t_id):
"""
Funckja odpowiada na request /api/tory/{t_id}
i zwraca jeden tor
:return:
"""
tory = []
cur.execute("SELECT EXISTS(SELECT 1 from tory where t_id = %s);", (t_id, ))
value = cur.fetchone()[0]
if value:
cur.execute(
"SELECT array_to_json(array_agg(row_to_json(t))) FROM tory t WHERE t_id = %s;",
(t_id, ))
results = cur.fetchone()
for row in results:
tory.append(row)
return results
else:
abort(404, "Tor o tym id nie znaleziony")
def login_post():
email = request.form.get('email')
password = request.form.get('password')
remember = True if request.form.get('remember') else False
cur.execute(
"SELECT EXISTS(SELECT 1 FROM uzytkownik where email_uzytkownika = %s AND haslo = %s);",
(email, password))
value = cur.fetchone()[0]
if not value:
flash('Bledy login lub haslo')
return redirect(url_for('auth.login'))
# login code goes here
cur.execute(
"SELECT u_id FROM uzytkownik WHERE email_uzytkownika = %s AND haslo = %s;",
(email, password))
user_id = cur.fetchone()[0]
user = User(user_id)
login_user(user, remember=remember)
return redirect(url_for('home'))
def create(wagon_bazowy):
nazwa = wagon_bazowy.get("nazwa")
nr_startowy = wagon_bazowy.get("nr_startowy")
nr_koncowy = wagon_bazowy.get("nr_koncowy")
dlugosc = wagon_bazowy.get("dlugosc")
wlasciciel = wagon_bazowy.get("wlasciciel")
typ_wagonu = wagon_bazowy.get("typ_wagonu")
cur.execute("SELECT EXISTS(SELECT 1 FROM wagony WHERE nazwa = %s);",
(nazwa, ))
value = cur.fetchone()[0]
if not value:
cur.execute(
"insert into wagony (nazwa, nr_startowy, nr_koncowy, dlugosc, wlasciciel, typ_wagonu) values (%s,%s,%s,%s,%s,%s);",
(nazwa, nr_startowy, nr_koncowy, dlugosc, wlasciciel, typ_wagonu))
connection.commit()
return "Dodano pomyslnie", 201
else:
abort(406, "Wagon z tym numerem juz istnieje")
def read_all():
"""
Funkcja odpowiada na request /api/bocznica
i zwraca liste bocznic dla danego uzytkownika
:return: json list bocznica
"""
# Create the list of scores from our data
u_id = current_user.id
print(u_id)
bocznica = []
cur.execute(
"SELECT (json_build_object('nazwa',b.nazwa)) FROM bocznica b WHERE u_id=%s;",
(u_id, ))
results = cur.fetchone()
print(results)
if (results[0] == None):
abort(404, "Nie masz aktualnie zadnych bocznic, dodaj je")
for row in results:
bocznica.append(row)
return results
