def add_ticker(self):
"""Add ticker to stock watchlist"""
try:
symbol = self.add_ticker_entry.get().upper()
price = float(self.add_price_entry.get())
pct_inc = float(self.percent_inc_entry.get())
pct_dec = float(self.percent_dec_entry.get())
price_low = price * (1 - pct_dec / 100)
price_high = price * (1 + pct_inc / 100)
except (ValueError, UnboundLocalError):
messagebox.showinfo('ERROR: MISSING ENTRY FIELDS', \
'Please make sure all fields have valid info.')
return
# error message if not all entries filled else add ticker to db
if len(symbol) == 0 or not price or not pct_dec or not pct_inc:
messagebox.showinfo('ERROR: MISSING REQUIRED FIELDS', \
"'Ticker Symbol', 'Price', and '% Dec' and "
"'% Inc' are required fields.")
else:
db = create_connection('tickers.db')
cursor = db.cursor()
cursor.execute("""INSERT INTO symbols (ticker, price, pct_dec, pct_inc,
price_low, price_high) VALUES (?, ?, ?, ?, ?, ?);""", \
(symbol, '{:.2f}'.format(price), '{:.2f}'.format(pct_dec), \
'{:.2f}'.format(pct_inc), '{:.2f}'.format(price_low), \
'{:.2f}'.format(price_high)))
close_connection(db)
# clear out entry fields
self.clear_entries()
def search():
""" Searches student """
# Connect to database
conn = connect_db(database)
conn.row_factory = dict_factory
if request.method == "POST":
print("SEARCH POST")
# Get search query
query = str(request.form.get("search_searchbar"))
column = request.form.get("search_class")
# Query databse
records = search_student(conn, query, column)
# Get headers from databse
headers = get_headers(conn)
# Number of casts
showtime = ("Saturday", "Sunday")
# Close database connection
close_connection(conn)
return render_template("index.html",
session = session,
headers = headers,
records = records,
showtime = showtime)
def delete_entry(entry_id):
"""
Deletes entry data
"""
print("DELETE ENTRY GET")
conn = connect_db(database)
conn.row_factory = dict_factory
# Function call
del_entry(conn, entry_id)
close_connection(conn)
flash("Entry deleted!")
return redirect(url_for("index"))
def register():
# Clear any user id
session.clear()
if request.method == "POST":
print("REGISTER POST")
# Connect to database
conn = connect_db(database)
conn.row_factory = dict_factory
# Get username and password from form
username = request.form.get("register_username")
password = request.form.get("register_password")
# Error check
if not username or not password or not request.form.get("register_confirm"):
return apology("Please fill in all fields", 401)
if password != request.form.get("register_confirm"):
return apology("Passwords don't match", 401)
records = search_user(conn, username)
if len(records) != 0:
return apology("Username already exists", 409)
# Error check passed. Insert user into users database
user_data = (username, generate_password_hash(password))
user_id = insert_user(conn, user_data)
# Remember user
session["user_id"] = user_id
session["username"] = username
# Close database connection
close_connection(conn)
# Redirect user to home
return redirect(url_for("index"))
else:
print("REGISTER GET")
return render_template("index.html")
def user_delete(user_id):
"""
Deletes user account
"""
print("DELETE USER GET")
# Connect to database
conn = connect_db(database)
conn.row_factory = dict_factory
# Function call
del_user(conn, user_id)
close_connection(conn)
flash("Profile deleted!")
return redirect(url_for("logout"))
def login():
"""Log user in"""
# User reached route via POST
if request.method == "POST":
print("LOGIN POST")
# Connect to database
conn = connect_db(database)
conn.row_factory = dict_factory
# Gather form input
username = request.form.get("login_username")
password = request.form.get("login_password")
# Error checking on user input
if not username or not password:
return apology("Please fill in all the required fields", 403)
# Query users table for username
records = search_user(conn, username)
# Ensure username exists and password is correct
if len(records) != 1:
return apology("username not found", 401)
elif check_password_hash(records[0]["hash"], password) == False:
return apology("Invalid password", 401)
# Remember which user has logged in
session["user_id"] = records[0]["id"]
session["username"] = records[0]["username"]
# Close database connection
close_connection(conn)
# Redirect user to home page
return redirect(url_for("index"))
# User reached route via GET
else:
print("LOGIN GET")
return render_template("login.html")
def remove_ticker(self):
"""Remove ticker from stock watchlist"""
symbol = self.add_ticker_entry.get().upper()
db = create_connection('tickers.db')
cursor = db.cursor()
cursor.execute("""SELECT count(*) FROM symbols WHERE ticker=?""",
(symbol, ))
data = cursor.fetchone()[0]
if data == 0:
messagebox.showinfo("REMOVAL ERROR", \
"Ticker doesn't exist in your watchlist.")
else:
cursor.execute("DELETE FROM symbols WHERE ticker=?;", (symbol, ))
# clear out entry fields
self.clear_entries()
close_connection(db)
def user():
"""
Displays user information. User can edit username and password
"""
# Connect to database
conn = connect_db(database)
conn.row_factory = dict_factory
if request.method == "POST":
# To update user data
print("USER POST")
# Gather data
user_id = session["user_id"]
username_old = session["username"]
username_new = request.form.get("user_username")
pw_old = request.form.get("user_old_pw")
pw_new = request.form.get("user_new_pw")
pw_confirm = request.form.get("user_new_confirm")
user_data = (username_new, generate_password_hash(pw_new))
# Compare input to existing data
records = search_user(conn, username_old)
if check_password_hash(records[0]["hash"], pw_old) == False:
return apology("Invalid password", 401)
if pw_new != pw_confirm:
return apology("Passwords don't match", 401)
# Update user data
mod_user(conn, user_data, user_id)
close_connection(conn)
flash("Profile updated!")
return redirect(url_for("index"))
else:
# Display user data
print("USER GET")
return render_template("user.html")
def index():
"""Show overview of all students in a table"""
print("INDEX GET")
# Connect to database
conn = connect_db(database)
conn.row_factory = dict_factory
# Establish number of casts and group names if not yet found in database
showtime = ("Saturday", "Sunday")
session["student_classes"] = ["Junior", "Oranje", "Paars", "Blauw", "PG", "Demo", "Vakklas"]
# Select all student data
headers = get_headers(conn)
records = student_overview(conn)
# If no data is present
if not records:
return render_template("index.html",
session = session,
showtime = showtime,
headers = headers)
# Change "None" to "-" for readability
for record in records:
for value in record:
if record[value] == None:
record[value] = "-"
#Close db connection
close_connection(conn)
return render_template("index.html",
session = session,
records = records,
headers = headers,
showtime = showtime)
# create SQLite3 database to store user's stock market information if not
# created already
if not os.path.exists('tickers.db'):
# create connection to database and create a table to store data
db = create_connection('tickers.db')
cursor = db.cursor()
create_sql_db = """
CREATE TABLE symbols (
ticker TEXT PRIMARY KEY,
price REAL,
pct_dec REAL,
pct_inc REAL,
price_low REAL,
price_high REAL);"""
cursor.execute(create_sql_db)
close_connection(db)
# create new threads
# thread1 = thread_run_GUI(1, 'GUI Thread', 1)
# thread2 = thread_check_price(2, 'Check Ticker Prices', 2)
# start new threads
# thread1.start()
# thread2.start()
# print('Exiting main thread.\n')
# run GUI application
# app = GUI()
# app.root.mainloop()
def see_list(self):
"""Creates table of watchlist to present to the user"""
top = tk.Toplevel()
top.title('Your watchlist')
(w, h) = self.root.winfo_screenwidth(), self.root.winfo_screenheight()
top.geometry('{}x{}'.format(w, h))
#create containers for widgets
top_row = tk.Frame(top, width=w, height=round(h * .05), bg='blue')
mid_row = tk.Frame(top, width=w, height=round(h * .75), bg='yellow')
bot_row = tk.Frame(top, width=w, height=round(h * .05), bg='red')
#layout containers
top.grid_rowconfigure(0, weight=1)
top.grid_rowconfigure(1, weight=1)
top.grid_columnconfigure(0, weight=1)
top.grid_columnconfigure(1, weight=0)
top_row.grid(row=0, columnspan=1)
mid_row.grid(row=1, columnspan=1)
bot_row.grid(row=2, columnspan=1)
#open connection to tickers.db
db = create_connection('tickers.db')
cursor = db.cursor()
#create widgets for displaying ticker watchlist
cursor.execute("""SELECT COUNT(*) FROM symbols""")
num_rows = cursor.fetchone()[0]
cursor.execute("""SELECT * FROM symbols""")
col_names = [name[0]
for name in cursor.description] #get column headers
col_names = list(map(lambda x: x.upper(),
col_names)) #convert headers to uppercase
num_cols = len(col_names)
#create "table" of user's watchlist for display
title = tk.Label(top_row, text='Your Watchlist', font='Times 40', bd=10, \
fg='black', bg='green', relief='raised')
title.grid(row=0)
for col_name in range(num_cols):
h = tk.Label(mid_row, text=col_names[col_name], font='Times 20', \
fg='black', bg='yellow')
h.grid(row=0, column=col_name)
cursor.execute("""SELECT ticker FROM symbols""")
portfolio = cursor.fetchall()
for row in range(num_rows):
ticker = portfolio[row][0]
cursor.execute("""SELECT * FROM symbols WHERE ticker=?""",
(ticker, ))
ticker_info = cursor.fetchall()
for col in range(num_cols):
text = ticker_info[0][col]
b = tk.Label(mid_row, text=text, fg='black', \
font='Times 20', bg='yellow', padx=20, pady=10)
b.grid(row=row + 1, column=col)
#create 'dismiss' button
dismiss_button = tk.Button(bot_row, text='Dismiss', command=top.destroy, \
font='Times 20', takefocus=1)
#layout 'dismiss' button
dismiss_button.grid(row=0, sticky='n')
#save changes to tickers.db and close connection
close_connection(db)
def __init__(self):
# configure the root window
self.root = tk.Tk()
self.root.title('Stock Change Notifier')
# set window size
(w, h) = self.root.winfo_screenwidth(), self.root.winfo_screenheight()
self.root.geometry("%dx%d+0+0" % (w, h))
# create all of the main containers
self.top_row = tk.Frame(self.root,
width=w,
height=100,
bd=10,
bg='red')
self.mid_row = tk.Frame(self.root,
width=w,
height=100,
bd=10,
bg='blue')
self.bot_row = tk.Frame(self.root,
width=w,
height=100,
bd=10,
bg='green')
# layout all of the main containers
self.root.grid_rowconfigure(0, weight=1)
self.root.grid_rowconfigure(1, weight=1)
self.root.grid_rowconfigure(2, weight=1)
self.root.grid_columnconfigure(0, weight=1)
self.root.grid_columnconfigure(1, weight=1)
self.root.grid_columnconfigure(2, weight=1)
self.top_row.grid(row=0, columnspan=3)
self.mid_row.grid(row=1, columnspan=3)
self.bot_row.grid(row=2, columnspan=3)
# create the widgets for the top row
self.see_stock_list_button = tk.Button(self.top_row, \
command=self.see_list, \
text='See Stock Watchlist', \
font='Times 20', \
activebackground='blue', bd=2, \
bg='grey', fg='black', \
highlightthickness=10, \
highlightcolor='red')
# layout the widgets in the top row
self.see_stock_list_button.grid(row=0, sticky='we')
# create the widgets for the middle row
self.add_ticker_label = tk.Label(self.mid_row, text='Ticker Symbol: ', \
font='Times 20')
self.add_ticker_entry = tk.Entry(self.mid_row, justify='left', \
font='Times 20', takefocus=1)
self.add_price_label = tk.Label(self.mid_row, text='Price: ', \
font='Times 20', justify='left')
self.add_price_entry = tk.Entry(self.mid_row, justify='left', \
font='Times 20', takefocus=1)
self.get_current_price_button = tk.Button(self.mid_row, \
command=self.lookup_current_price, \
text='Get Current Price', \
font='Times 20', bd=2, \
activebackground='blue', \
bg='grey', fg='black', \
justify='center', padx=5, \
highlightthickness=10, \
highlightcolor='red')
self.percent_inc_label = tk.Label(self.mid_row, font='Times 20', \
text='% Increase to Notify: ', \
justify='left')
self.percent_inc_entry = tk.Entry(self.mid_row, justify='left', \
font='Times 20', takefocus=1)
self.percent_dec_label = tk.Label(self.mid_row, font='Times 20', \
text='% Decrease to Notify: ', \
justify='left')
self.percent_dec_entry = tk.Entry(self.mid_row, justify='left', \
font='Times 20', takefocus=1)
# layout the widgets for the middle row
self.add_ticker_label.grid(row=0, column=0, sticky='we')
self.add_ticker_entry.grid(row=0, column=1, sticky='we')
self.add_price_label.grid(row=1, column=0, sticky='we')
self.add_price_entry.grid(row=1, column=1, sticky='we')
self.get_current_price_button.grid(row=1, column=2, sticky='we')
self.percent_inc_label.grid(row=2, column=0, sticky='we')
self.percent_inc_entry.grid(row=2, column=1, sticky='we')
self.percent_dec_label.grid(row=3, column=0, sticky='we')
self.percent_dec_entry.grid(row=3, column=1, sticky='we')
# create the widgets for the bottom row
self.add_ticker_button = tk.Button(self.bot_row, \
command=self.add_ticker, \
text='Add Ticker to List', \
font='Times 20', \
activebackground='blue', bd=2, \
bg='grey', fg='black', \
justify='center', padx=1000, \
pady=25, highlightthickness=10, \
highlightcolor='red')
self.remove_ticker_button = tk.Button(self.bot_row, \
command=self.remove_ticker, \
text='Remove Ticker from List', \
font='Times 20', \
activebackground='blue', bd=2, \
bg='grey', fg='black', \
justify='center', padx=1000, \
pady=25, highlightthickness=10, \
highlightcolor='red')
# layout the widgets for the bottom row
self.add_ticker_button.grid(row=0, sticky='we')
self.remove_ticker_button.grid(row=1, sticky='we')
# set initial focus to add_ticker_entry
self.add_ticker_entry.focus()
# allow user to tab to next widget
self.see_stock_list_button.bind('<Tab>', focus_next_widget)
self.add_ticker_entry.bind('<Tab>', focus_next_widget)
self.add_price_entry.bind('<Tab>', focus_next_widget)
self.get_current_price_button.bind('<Tab>', focus_next_widget)
self.percent_inc_entry.bind('<Tab>', focus_next_widget)
self.percent_dec_entry.bind('<Tab>', focus_next_widget)
self.add_ticker_button.bind('<Tab>', focus_next_widget)
self.remove_ticker_button.bind('<Tab>', focus_next_widget)
# allow user to shift+tab to go to previous widget
self.see_stock_list_button.bind('<Shift-KeyPress-Tab>',
focus_prev_widget)
self.add_ticker_entry.bind('<Shift-KeyPress-Tab>', focus_prev_widget)
self.add_price_entry.bind('<Shift-KeyPress-Tab>', focus_prev_widget)
self.get_current_price_button.bind('<Shift-KeyPress-Tab>',
focus_prev_widget)
self.percent_inc_entry.bind('<Shift-KeyPress-Tab>', focus_prev_widget)
self.percent_dec_entry.bind('<Shift-KeyPress-Tab>', focus_prev_widget)
self.add_ticker_button.bind('<Shift-KeyPress-Tab>', focus_prev_widget)
self.remove_ticker_button.bind('<Shift-KeyPress-Tab>',
focus_prev_widget)
# allow user to execute button on 'Enter'
self.see_stock_list_button.bind('<Return>',
lambda event: self.see_list())
self.get_current_price_button.bind(
'<Return>', lambda event: self.lookup_current_price())
self.add_ticker_button.bind('<Return>',
lambda event: self.add_ticker())
self.remove_ticker_button.bind('<Return>',
lambda event: self.remove_ticker())
# get list of ticker symbols in user's watchlist
db = create_connection('tickers.db')
cursor = db.cursor()
cursor.execute("""SELECT ticker FROM symbols""")
tickers = cursor.fetchall()
tickers = [ticker[0] for ticker in tickers]
# check prices of all tickers on user's watchlist against bounds
for ticker in tickers:
self.check_price(ticker)
close_connection(db)
# bring root window into immediate view
self.root.lift()
self.root.attributes('-topmost', True)
self.root.after_idle(self.root.attributes, '-topmost', False)
# set focus onto root window
self.root.focus_force()
