def pull_and_analyze_all_data_function():
"""Return: Should run in the background automatically at intervals"""
# Connect to database
connection_postgres, cursor = connect_to_postgres_function()
# Get all symbol tracking data from db
all_data_symbol_track_arr_dicts = select_all_stock_tracking_info_function(
connection_postgres, cursor)
# Get all phone number data from db
all_data_phone_numbers_arr_dicts = select_all_user_phone_numbers_function(
connection_postgres, cursor)
# Close connection
close_connection_cursor_to_database_function(connection_postgres, cursor)
# Manipulate the pulled data into set & dicts
unique_stocks_set = get_unique_stocks_set_function(
all_data_symbol_track_arr_dicts)
symbol_news_link_dict = invert_symbol_news_link_dict_function(
all_data_symbol_track_arr_dicts)
user_stocks_tracking_dict = invert_to_user_stocks_dict_function(
all_data_symbol_track_arr_dicts)
user_phone_numbers_dict = invert_to_user_phone_numbers_dict_function(
all_data_phone_numbers_arr_dicts)
# Get yfinance information for the stock symbols as dict
symbol_percent_changes_dict = get_latest_symbol_info_function(
unique_stocks_set)
# Put all the information together into a queue
queue_to_text_arr = create_queue_to_text_out_function(
user_stocks_tracking_dict, user_phone_numbers_dict,
symbol_percent_changes_dict, symbol_news_link_dict)
connection_postgres, cursor = connect_to_postgres_function()
for i in queue_to_text_arr:
send_sms_function(connection_postgres, cursor, i)
close_connection_cursor_to_database_function(connection_postgres, cursor)
def pull_and_analyze_all_data_function():
"""Return: Should run in the background automatically at intervals"""
# First check the day
num_day_of_week = datetime.datetime.today().weekday()
if num_day_of_week == 5 or num_day_of_week == 6:
print('It is the weekend. The market is closed so texts do not go out on weekend!')
return True
# Connect to database
connection_postgres, cursor = connect_to_postgres_function()
# Pull data
# Get all symbol tracking data from db
all_data_symbol_track_arr_dicts = select_all_stock_tracking_info_function(connection_postgres, cursor)
# Get all phone number data from db
all_data_phone_numbers_arr_dicts = select_all_user_phone_numbers_function(connection_postgres, cursor)
# Get all news link data from db
all_news_links_arr = select_all_google_news_links_function(connection_postgres, cursor)
# Close connection
close_connection_cursor_to_database_function(connection_postgres, cursor)
# Manipulate the pulled data into set & dicts
unique_stocks_set = get_unique_stocks_set_function(all_data_symbol_track_arr_dicts)
symbol_news_link_dict = create_news_links_dict_function(all_news_links_arr)
user_stocks_tracking_dict = invert_to_user_stocks_dict_function(all_data_symbol_track_arr_dicts)
user_phone_numbers_dict = invert_to_user_phone_numbers_dict_function(all_data_phone_numbers_arr_dicts)
# Get yfinance information for the stock symbols as dict
symbol_percent_changes_dict = get_latest_symbol_info_function(unique_stocks_set)
# Put all the information together into a queue
queue_to_text_arr = create_queue_to_text_out_function(user_stocks_tracking_dict, user_phone_numbers_dict, symbol_percent_changes_dict, symbol_news_link_dict)
# Set variables for sending summary text to myself
num_texts_to_send_out = len(queue_to_text_arr)
num_texts_failed_to_send = 0
# Open connection to database
connection_postgres, cursor = connect_to_postgres_function()
for i in queue_to_text_arr:
try:
send_sms_function(connection_postgres, cursor, i)
except:
num_texts_failed_to_send += 1
pass
# Send summary text to myself
try:
send_summary_sms_text_function(connection_postgres, cursor, num_texts_failed_to_send, num_texts_to_send_out)
except:
pass
# Close connection to database
close_connection_cursor_to_database_function(connection_postgres, cursor)
def confirm_email_page_function(confirm_email_token_url_variable):
"""Returns: confirms email token link"""
serializer_instance = URLSafeTimedSerializer(
os.environ.get('URL_SAFE_SERIALIZER_SECRET_KEY_EMAIL'))
string_to_salt = os.environ.get(
'URL_SAFE_SERIALIZER_SECRET_SALT_EMAIL').encode("utf-8")
try:
user_email_confirming = serializer_instance.loads(
confirm_email_token_url_variable,
salt=string_to_salt,
max_age=86400)
connection_postgres, cursor = connect_to_postgres_function()
update_to_confirmed_email_function(connection_postgres, cursor,
user_email_confirming)
close_connection_cursor_to_database_function(connection_postgres,
cursor)
except:
# Set the session variables outgoing
session[
'dashboard_upload_output_message'] = 'the email token has expired!'
session[
'output_message_landing_page_session'] = 'the email token has expired!'
# Redirect to page
return redirect("https://symbolnews.com/dashboard", code=301)
# Set the session variables outgoing
session['dashboard_upload_output_message'] = 'Account email confirmed!'
session['output_message_landing_page_session'] = 'Account email confirmed!'
# Redirect to page
return redirect("https://symbolnews.com/", code=301)
def jobs_queues_function():
"""Return: Should run in the background automatically at intervals"""
# Connect to database
connection_postgres, cursor = connect_to_postgres_function()
# get_company_short_name job
job_name = 'get_company_short_name'
symbols_to_get_company_short_name_arr = select_job_get_company_short_name_function(
connection_postgres, cursor, job_name)
# Loop through all symbols in job
for sym in symbols_to_get_company_short_name_arr:
# Get company short name
try:
sym_company_short_name = get_company_short_name_function(sym[0])
# If company short name not found
except:
print(
sym[0] +
' : Company short name cannot be found, or it took too long to find'
)
sym_company_short_name = 'none'
pass
# If company short name found/asigned
if sym_company_short_name != 'none':
try:
# Update table with company short name
update_stock_news_links_table_company_short_name_function(
connection_postgres, cursor, sym_company_short_name,
sym[0])
# Get updated google link
try:
google_news_link_with_company_short_name = get_google_news_page_function(
sym_company_short_name)
except:
google_news_link_with_company_short_name = 'none'
pass
# If Google news link with company short name has been found/created
if google_news_link_with_company_short_name != 'none':
try:
update_stock_news_links_table_google_link_function(
connection_postgres, cursor,
google_news_link_with_company_short_name, sym[0])
except:
pass
except:
pass
# Finally delete the symbol from the job table
try:
delete_job_company_short_name_function(connection_postgres,
cursor, job_name,
sym[0])
except:
pass
# Close connection to database
close_connection_cursor_to_database_function(connection_postgres, cursor)
def job_remind_verify_email_text_reminder_function():
"""Return: Send reminder text to users to verify their emails/check spam folder"""
# First check the day
num_day_of_week = datetime.datetime.today().weekday()
if num_day_of_week == 0 or num_day_of_week == 1 or num_day_of_week == 2 or num_day_of_week == 3 or num_day_of_week == 4 or num_day_of_week == 5:
return True
# Connect to database
connection_postgres, cursor = connect_to_postgres_function()
# Pull data - all phone needed data
users_not_confirmed_arr = select_user_email_not_confirmed_status_but_phone_yes_confirmed_function(connection_postgres, cursor)
if len(users_not_confirmed_arr) > 0:
for i in users_not_confirmed_arr:
try:
# Message the confirmation link to user
twilio_message_sid = send_reminder_phone_to_confirm_email_account_function(i[0], i[1], i[2])
# Add the UUID and timestamp for datetime that the reminder was created/sent
uuid_reminder_phone = create_uuid_function("rdpe_")
reminder_phone_timestamp = create_timestamp_function()
confirm_phone_number_token = ''
# Insert data into database table
attempt_insert_reminder_phone = insert_reminder_phone_table_function(connection_postgres, cursor, uuid_reminder_phone, reminder_phone_timestamp, i[3], confirm_phone_number_token, twilio_message_sid)
print(attempt_insert_reminder_phone)
except:
pass
# Close connection
close_connection_cursor_to_database_function(connection_postgres, cursor)
def login_attempt_function():
"""Returns: login attempt on the login_page"""
# Check if user session data is already present/signed in
if session and session.get('logged_in_user_email') != 'none':
return redirect('https://symbolnews.com/dashboard', code=301)
# Sanitize user inputs
user_email_from_html_form_sanitized = sanitize_email_input_create_account_function(request.form.get('email'))
user_password_from_html_form_sanitized = sanitize_password_input_create_account_function(request.form.get('psw'))
# If postman invalid inputs used
if user_email_from_html_form_sanitized == 'none' or user_password_from_html_form_sanitized == 'none':
print('FAILED TO LOGIN!')
return 'FAILED TO LOGIN!'
# Login attempt with valid inputs
connection_postgres, cursor = connect_to_postgres_function()
session['logged_in_user_uuid'], session['logged_in_user_email'], session['logged_in_user_first_name'], session['logged_in_user_last_name'], session['logged_in_user_phone_number'] = select_password_query_function(connection_postgres, cursor, user_email_from_html_form_sanitized, user_password_from_html_form_sanitized)
close_connection_cursor_to_database_function(connection_postgres, cursor)
# Login attempt fail
if session['logged_in_user_email'] == 'none' or session['logged_in_user_first_name'] == 'none' or session['logged_in_user_last_name'] == 'none' or session['logged_in_user_phone_number'] == 'none':
session['output_message_login_page_session'] = 'Email/Password not found!'
return redirect("https://symbolnews.com/login", code=301)
# Login attempt Success
else:
session.permanent = True
return redirect("/dashboard", code=301)
#return redirect("https://symbolnews.com/dashboard", code=301)
def delete_account_perm_function():
"""Returns: Deletes all symbols associated with an account and then deletes the account itself as well"""
if session['logged_in_user_email'] != 'none':
# Set the incoming session variables
user_email = session['logged_in_user_email']
user_first_name = session['logged_in_user_first_name']
# Connect to database
connection_postgres, cursor = connect_to_postgres_function()
# Mark account for deletion
update_user_delete_account_requested_true_function(
connection_postgres, cursor, session['logged_in_user_uuid'])
# Send account deleted email
send_email_account_deleted_function(user_email, user_first_name)
# Close database connection
close_connection_cursor_to_database_function(connection_postgres,
cursor)
# Set all session variables to none
set_session_variables_to_none_logout_function()
# Set outgoing session variables
session['output_message_landing_page_session'] = 'Account deleted!'
# Redirect to landing page
return redirect("https://symbolnews.com/", code=301)
else:
set_session_variables_to_none_logout_function()
return redirect("https://symbolnews.com/", code=301)
def confirm_new_password_set_function():
"""Returns: confirms new password was set"""
# Check if user session data is already present/signed in
if session and session.get('logged_in_user_email') != 'none':
return redirect('https://symbolnews.com/dashboard', code=301)
# Sanitize new password
user_password_from_html_form_sanitized = sanitize_password_input_create_account_function(
request.form.get('psw'))
# If postman invalid inputs used
if user_password_from_html_form_sanitized == 'none':
print('FAILED TO CREATE ACCOUNT!')
return 'FAILED TO CREATE ACCOUNT!'
# Hash the user password from html form
hashed_user_password_from_html_form = bcrypt.hashpw(
user_password_from_html_form_sanitized.encode('utf-8'),
bcrypt.gensalt())
hashed_user_password_from_html_form_decoded_for_database_insert = hashed_user_password_from_html_form.decode(
'ascii')
# Connect to postgres and update password
connection_postgres, cursor = connect_to_postgres_function()
update_password_function(
connection_postgres, cursor,
hashed_user_password_from_html_form_decoded_for_database_insert,
session['user_email_to_change_password'])
close_connection_cursor_to_database_function(connection_postgres, cursor)
session['output_message_landing_page_session'] = 'Password Updated!'
return redirect("https://symbolnews.com/", code=301)
def job_remind_verify_phone_function():
"""Return: Go into all database tables, pull table info as separate csv files, store all csv's in s3 bucket for that day"""
# Schedule for only certain days of the week
"""num_day_of_week = datetime.datetime.today().weekday()
if num_day_of_week == 0 or num_day_of_week == 1 or num_day_of_week == 2 or num_day_of_week == 3 or num_day_of_week == 4 or num_day_of_week == 5:
return True"""
# Create AWS s3 client
s3_resource = boto3.resource('s3')
s3_bucket_name = os.environ.get('AWS_SYMBOLNEWS_BUCKET_NAME')
# Connect to database
connection_postgres, cursor = connect_to_postgres_function()
# Get all table names in the current database
db_table_names_arr = select_all_database_table_names_function(
connection_postgres, cursor)
for i in db_table_names_arr:
# Get table name
table_name = i[0]
try:
# Run sql statement on the table and get all row results
cursor.execute("SELECT * FROM %s" % table_name)
result_list = cursor.fetchall()
# Get table headers, store in array
headers_tuple = cursor.description
headers_arr = []
for i in headers_tuple:
headers_arr.append(i.name)
# Create into pandas dataframe
df = pd.DataFrame(result_list, columns=headers_arr)
# Get todays date as string
todays_date_str = str(datetime.datetime.now().date())
todays_date = todays_date_str.replace("-", "")
# Upload pandas df into aws s3
csv_buffer = StringIO()
df.to_csv(csv_buffer)
s3_resource.Object(s3_bucket_name, todays_date + ' ' + table_name +
'.csv').put(Body=csv_buffer.getvalue())
except (Exception, psycopg2.Error) as error:
if (connection_postgres):
print("Error: ", error)
result_list = 'none'
return result_list
# Close connection
close_connection_cursor_to_database_function(connection_postgres, cursor)
def job_end_of_week_email_recap_function():
"""Pulls all users who recieved texts this week then sends them an end of week recap, with news links"""
# First check the day
num_day_of_week = datetime.datetime.today().weekday()
if num_day_of_week == 0 or num_day_of_week == 1 or num_day_of_week == 2 or num_day_of_week == 3 or num_day_of_week == 5 or num_day_of_week == 6:
return True
if num_day_of_week == 4:
# Connect to database
connection_postgres, cursor = connect_to_postgres_function()
# Pull user data who received texts this week
texts_this_week_arr = select_users_received_text_this_week_function(
connection_postgres, cursor)
# Pull just the symbols for users who received texts this week
texts_this_week_symbols_only_arr = select_users_received_text_this_week_symbols_only_function(
connection_postgres, cursor)
# Tuen the symbols only array into dictionary with weekly thresholds per symbol
texts_this_week_symbols_only_dict = convert_arr_dict_symbols_this_week_with_change_function(
texts_this_week_symbols_only_arr)
# Turn the user data into a nested dict that included weekly thresholds per symbol
texts_this_week_dict = convert_arr_dict_texts_this_week_function(
texts_this_week_arr, texts_this_week_symbols_only_dict)
# Get today's date for the email send subject
todays_date = datetime.datetime.today()
email_send_date = todays_date.strftime("%m/%d/%y")
# Loop through nested dictionary and email each person the highlights for the week
master_string = ''
for k, v in texts_this_week_dict.items():
# Arr of symbols for user this week
symbols_sent_arr = []
master_string = ''
# Loop through each person email
for symbol, v2 in v['symbols'].items():
# Add symbol to arr
symbols_sent_arr.append(symbol)
# Create a long string for the body of the email
string = symbol + ", " + v2[
'total_percent_change_this_week'] + ", " + v2[
'google_news_link'] + " \n\n\n"
master_string += string
# Send the email to the person
send_email_weekly_recap_sym_thresholds_function(
k, v, master_string, email_send_date, connection_postgres,
cursor, symbols_sent_arr)
# Close connection
close_connection_cursor_to_database_function(connection_postgres,
cursor)
def job_remind_verify_phone_function():
"""Return: Send reminder text to users to verify their phone number"""
# First check the day
num_day_of_week = datetime.datetime.today().weekday()
if num_day_of_week == 0 or num_day_of_week == 1 or num_day_of_week == 2 or num_day_of_week == 3 or num_day_of_week == 4 or num_day_of_week == 5:
return True
# Connect to database
connection_postgres, cursor = connect_to_postgres_function()
# Pull data - all phone needed data
users_not_confirmed_arr = select_user_phone_not_confirmed_status_function(
connection_postgres, cursor)
if len(users_not_confirmed_arr) > 0:
for i in users_not_confirmed_arr:
try:
# Create token for verification
confirm_phone_number_token = create_confirm_token_function(
i[0],
os.environ.get('URL_SAFE_SERIALIZER_SECRET_KEY_PHONE'),
os.environ.get('URL_SAFE_SERIALIZER_SECRET_SALT_PHONE'))
# Create the URL link for verification
try:
url_for(
'confirm_phone_number_page.confirm_phone_number_page_function',
confirm_phone_number_token_url_variable=
confirm_phone_number_token)
except:
pass
# Message the confirmation link to user
twilio_message_sid = send_reminder_phone_confirm_account_function(
i[0], i[1], confirm_phone_number_token)
# Add the UUID and timestamp for datetime that the reminder was created/sent
uuid_reminder_phone = create_uuid_function("rmdp_")
reminder_phone_timestamp = create_timestamp_function()
# Insert data into database table
attempt_insert_reminder_phone = insert_reminder_phone_table_function(
connection_postgres, cursor, uuid_reminder_phone,
reminder_phone_timestamp, i[2], confirm_phone_number_token,
twilio_message_sid)
print(attempt_insert_reminder_phone)
except:
pass
# Close connection
close_connection_cursor_to_database_function(connection_postgres, cursor)
def forgot_password_send_token_to_email_function():
"""Returns: reset link sent"""
# Check if user session data is already present/signed in
if session and session.get('logged_in_user_email') != 'none':
return redirect('https://symbolnews.com/dashboard', code=301)
# Sanatize the user email
user_email_from_html_form_sanitized = sanitize_email_input_create_account_function(
request.form.get('email'))
# If postman invalid inputs used
if user_email_from_html_form_sanitized == 'none':
print('FAILED TO LOGIN!')
return 'FAILED TO LOGIN!'
# Check if email exists in db
connection_postgres, cursor = connect_to_postgres_function()
does_email_exist = select_login_information_table_query_function(
connection_postgres, cursor, user_email_from_html_form_sanitized)
close_connection_cursor_to_database_function(connection_postgres, cursor)
# If email does exist then send email
if does_email_exist == 'Account already exists':
# Create tokens for email and phone number verification
confirm_email_token = create_confirm_token_function(
user_email_from_html_form_sanitized,
os.environ.get('URL_SAFE_SERIALIZER_SECRET_KEY_EMAIL'),
os.environ.get('URL_SAFE_SERIALIZER_SECRET_SALT_EMAIL'))
# Create the URL links for password change verification
url_for('set_new_password.set_new_password_function',
confirm_email_token_url_variable=confirm_email_token)
# Send the confirmation email link to user
send_email_new_password_function(user_email_from_html_form_sanitized,
confirm_email_token)
session[
'output_message_forgot_password_page_session'] = 'Email sent! Please check your email for the password reset link.'
return redirect("https://symbolnews.com/forgot_password", code=301)
# If email does not exist, just say you sent it anyway
else:
# Return the same output message so that hackers do not know if or if not email exists in database
session[
'output_message_forgot_password_page_session'] = 'Email sent! Please check your email for the password reset link.'
return redirect("https://symbolnews.com/forgot_password", code=301)
def delete_symbols_function():
"""Returns: Delete symbols from the data table"""
if session['logged_in_user_email'] != 'none':
if request.method == 'POST':
# Get the json symbols from ajax and sanitize/check if they exist
selected_symbols_to_delete_from_ajax = request.get_json()
if len(selected_symbols_to_delete_from_ajax) == 0:
set_session_variables_to_none_logout_function()
return render_template(
'templates_login_and_create_account/index.html')
symbols_arr = breakup_symbols_dict_from_ajax_function(
selected_symbols_to_delete_from_ajax)
all_symbols_arr_exist = check_if_all_symbols_arr_exist_function(
symbols_arr)
if all_symbols_arr_exist == 'none':
print('This symbol does not exist!')
set_session_variables_to_none_logout_function()
return render_template(
'templates_login_and_create_account/index.html')
connection_postgres, cursor = connect_to_postgres_function()
delete_from_stock_tracking_table_function(
connection_postgres, cursor, session['logged_in_user_uuid'],
symbols_arr)
symbol_tracking_list = select_user_tracking_list_function(
connection_postgres, cursor, session['logged_in_user_uuid'])
close_connection_cursor_to_database_function(
connection_postgres, cursor)
return jsonify(
'',
render_template(
'templates_user_logged_in/loggedin_dashboard_page_ajax_model.html',
user_email_from_session_to_html=session[
'logged_in_user_email'],
user_first_name_from_session_to_html=session[
'logged_in_user_first_name'],
user_last_name_from_session_to_html=session[
'logged_in_user_last_name'],
user_phone_number_from_session_to_html=session[
'logged_in_user_phone_number'],
symbol_tracking_list_from_python_to_html=
symbol_tracking_list))
else:
set_session_variables_to_none_logout_function()
return render_template('templates_login_and_create_account/index.html')
def creating_account_to_postgres_function():
"""Returns: Uploads new account info to Postgres database, if it does not already exist."""
# Check if user session data is already present/signed in
if session and session.get('logged_in_user_email') != 'none':
return redirect('https://symbolnews.com/dashboard', code=301)
# Get and sanitize the user inputs from html form
user_first_name_from_html_form_sanitized = sanitize_name_input_create_account_function(
request.form.get('user_first_name'))
user_last_name_from_html_form_sanitized = sanitize_name_input_create_account_function(
request.form.get('user_last_name'))
user_phone_number_from_html_form_sanitized = sanitize_phone_number_input_create_account_function(
request.form.get('phone_number'))
user_email_from_html_form_sanitized = sanitize_email_input_create_account_function(
request.form.get('email'))
user_password_from_html_form_sanitized = sanitize_password_input_create_account_function(
request.form.get('psw'))
# If postman invalid inputs used
if user_first_name_from_html_form_sanitized == 'none' or user_last_name_from_html_form_sanitized == 'none' or user_phone_number_from_html_form_sanitized == 'none' or user_email_from_html_form_sanitized == 'none' or user_password_from_html_form_sanitized == 'none':
print('FAILED TO CREATE ACCOUNT!')
return 'FAILED TO CREATE ACCOUNT!'
# Hash the user password from html form
hashed_user_password_from_html_form = bcrypt.hashpw(
user_password_from_html_form_sanitized.encode('utf-8'),
bcrypt.gensalt())
hashed_user_password_from_html_form_decoded_for_database_insert = hashed_user_password_from_html_form.decode(
'ascii')
# Connect to postgres
connection_postgres, cursor = connect_to_postgres_function()
# Search query if email is already in database
email_exists = select_login_information_table_query_function(
connection_postgres, cursor, user_email_from_html_form_sanitized)
phone_exists = select_login_information_table_query_phone_number_function(
connection_postgres, cursor,
user_phone_number_from_html_form_sanitized)
# If email account already exists in database
if email_exists == 'Account already exists' or phone_exists == 'Account already exists':
# Close connection to database
close_connection_cursor_to_database_function(connection_postgres,
cursor)
# Set outgoing session messages
session[
'output_message_create_account_page_session'] = 'Account already exists'
# Redirect to page
return redirect("https://symbolnews.com/create_account", code=301)
# Add the UUID and timestamp for datetime that the account was created
user_uuid_create_account = create_uuid_function("user_")
user_create_account_timestamp = create_timestamp_function()
# Insert query function to insert new user created data into postgres
success_message, error_message = insert_login_information_table_query_function(
connection_postgres, cursor, user_uuid_create_account,
user_create_account_timestamp,
user_first_name_from_html_form_sanitized,
user_last_name_from_html_form_sanitized,
user_phone_number_from_html_form_sanitized,
user_email_from_html_form_sanitized,
hashed_user_password_from_html_form_decoded_for_database_insert)
# Close database connection and cursor
close_connection_cursor_to_database_function(connection_postgres, cursor)
# Continue based on query insert results
if success_message == 'success' and error_message == 'none':
# Create tokens for email and phone number verification
confirm_email_token = create_confirm_token_function(
user_email_from_html_form_sanitized,
os.environ.get('URL_SAFE_SERIALIZER_SECRET_KEY_EMAIL'),
os.environ.get('URL_SAFE_SERIALIZER_SECRET_SALT_EMAIL'))
confirm_phone_number_token = create_confirm_token_function(
user_phone_number_from_html_form_sanitized,
os.environ.get('URL_SAFE_SERIALIZER_SECRET_KEY_PHONE'),
os.environ.get('URL_SAFE_SERIALIZER_SECRET_SALT_PHONE'))
# Create the URL links for email and phone number verification
url_for('confirm_email_page.confirm_email_page_function',
confirm_email_token_url_variable=confirm_email_token)
url_for(
'confirm_phone_number_page.confirm_phone_number_page_function',
confirm_phone_number_token_url_variable=confirm_phone_number_token)
# Send the confirmation email and text links to user
try:
send_phone_number_confirm_account_function(
user_phone_number_from_html_form_sanitized,
user_first_name_from_html_form_sanitized,
confirm_phone_number_token)
send_email_confirm_account_function(
user_email_from_html_form_sanitized,
user_first_name_from_html_form_sanitized, confirm_email_token)
except:
# If user inputs wrong format
# Delete user that was just input to database
connection_postgres, cursor = connect_to_postgres_function()
delete_all_user_login_information_table_data_function(
connection_postgres, cursor, user_uuid_create_account)
close_connection_cursor_to_database_function(
connection_postgres, cursor)
set_session_variables_to_none_logout_function()
session[
'output_message_create_account_page_session'] = 'Unable to create account with the phone number provided!'
return redirect("https://symbolnews.com/create_account", code=301)
# Send admin email that account was created
try:
send_admin_email_account_created_function(
user_first_name_from_html_form_sanitized,
user_last_name_from_html_form_sanitized,
user_email_from_html_form_sanitized,
user_create_account_timestamp)
except:
print('did not send email to admin')
# Flask set session variables and redirect to dashboard
session['logged_in_user_uuid'] = user_uuid_create_account
session['logged_in_user_email'] = user_email_from_html_form_sanitized
session[
'logged_in_user_first_name'] = user_first_name_from_html_form_sanitized
session[
'logged_in_user_last_name'] = user_last_name_from_html_form_sanitized
session[
'logged_in_user_phone_number'] = user_phone_number_from_html_form_sanitized
session.permanent = True
return redirect("https://symbolnews.com/dashboard", code=301)
# If above fails at any point redirect back to create account page
else:
set_session_variables_to_none_logout_function()
return redirect("https://symbolnews.com/create_account", code=301)
return redirect("https://symbolnews.com/create_account", code=301)
def dashboard_page_render_function():
"""Returns: User dashboard with user symbol tracking list"""
# Need to create a css unique key so that cache busting can be done
css_cache_busting_variable = create_uuid_function('css_')
if session and session.get(
'logged_in_user_email') != 'none' and session.get(
'logged_in_user_email') != None:
# Get info for the page render
# Connect to database
connection_postgres, cursor = connect_to_postgres_function()
# Pull tracking list from databse
symbol_tracking_list = select_user_tracking_list_function(
connection_postgres, cursor, session['logged_in_user_uuid'])
# Check if email and phone number are verified
display_output_message_email, display_output_message_phone_number = select_user_confirmed_account_status_function(
connection_postgres, cursor, session['logged_in_user_uuid'])
# If not verified yet, unhide the resend link text
resend_email_confirm_link = ''
resend_phone_number_confirm_link = ''
# Add the resend link text words to html file if they are not blank/None
if display_output_message_email != None and len(
display_output_message_email) >= 2:
resend_email_confirm_link = 'Click to resend email confirmation link.'
if display_output_message_phone_number != None and len(
display_output_message_phone_number) >= 2:
resend_phone_number_confirm_link = 'Click to resend phone number confirmation link.'
# Close the connnection to database
close_connection_cursor_to_database_function(connection_postgres,
cursor)
# When redirected to this page, first check if there is an session error message associated with this redirect
if session and session.get(
'output_message_dashboard_page_session') != None:
try:
return render_template(
'templates_user_logged_in/loggedin_dashboard_page.html',
user_email_from_session_to_html=session[
'logged_in_user_email'],
user_first_name_from_session_to_html=session[
'logged_in_user_first_name'],
user_last_name_from_session_to_html=session[
'logged_in_user_last_name'],
user_phone_number_from_session_to_html=session[
'logged_in_user_phone_number'],
symbol_tracking_list_from_python_to_html=
symbol_tracking_list,
output_message_from_python_to_html=session[
'output_message_dashboard_page_session'],
resend_email_confirm_link_to_html=resend_email_confirm_link,
resend_phone_number_confirm_link_to_html=
resend_phone_number_confirm_link,
css_cache_busting_variable_to_html=
css_cache_busting_variable)
except:
return 'failed'
finally:
session['output_message_dashboard_page_session'] = None
# Render the page
return render_template(
'templates_user_logged_in/loggedin_dashboard_page.html',
user_email_from_session_to_html=session['logged_in_user_email'],
user_first_name_from_session_to_html=session[
'logged_in_user_first_name'],
user_last_name_from_session_to_html=session[
'logged_in_user_last_name'],
user_phone_number_from_session_to_html=session[
'logged_in_user_phone_number'],
symbol_tracking_list_from_python_to_html=symbol_tracking_list,
resend_email_confirm_link_to_html=resend_email_confirm_link,
resend_phone_number_confirm_link_to_html=
resend_phone_number_confirm_link,
css_cache_busting_variable_to_html=css_cache_busting_variable)
# If no session info found
else:
set_session_variables_to_none_logout_function()
return redirect("https://symbolnews.com/", code=301)
def upload_symbol_percent_change_input_function():
"""Returns: sanatizes the user input, then uploads it into the database and data table"""
if session and session.get('logged_in_user_email') != 'none':
# Sanitize/confirm user inputs
user_symbol_from_html_form_sanitized = sanitize_symbol_input_function(
request.form.get('track_symbol'))
does_symbol_exist = yfinance_check_if_symbol_exists_function(
user_symbol_from_html_form_sanitized)
user_symbol_percent_change_from_html_form_sanitized = sanitize_symbol_percent_change_input_function(
request.form.get('track_percent_change'))
# If user inputs were invalid
if user_symbol_from_html_form_sanitized == 'none' or does_symbol_exist == 'none' or user_symbol_percent_change_from_html_form_sanitized == 'none':
session[
'output_message_dashboard_page_session'] = 'Stock Symbol must exist and be 1-5 letters long. Minimum % Change must be 7.'
return redirect("https://symbolnews.com/dashboard", code=301)
# If user inputs were valid
else:
# Create uuid and timestamp for insertion
user_table_insert_uuid = create_uuid_function("symt_")
user_track_symbol_timestamp = create_timestamp_function()
# Database insert
connection_postgres, cursor = connect_to_postgres_function()
# Check if user is already tracking this symbol
error_message_check_if_exist = select_stock_tracking_table_duplicates_function(
connection_postgres, cursor, session['logged_in_user_uuid'],
user_symbol_from_html_form_sanitized)
# If user is not already tracking this symbol
if error_message_check_if_exist == 'none':
# Insert stock tracking information into the stock_tracking_table
session[
'output_message_dashboard_page_session'] = insert_stock_tracking_table_function(
connection_postgres, cursor, user_table_insert_uuid,
user_track_symbol_timestamp,
user_symbol_from_html_form_sanitized,
user_symbol_percent_change_from_html_form_sanitized,
session['logged_in_user_uuid'])
# Get google news link for the symbol not company short name yet, a job will get the short name in order to save wait time for user
temporary_google_search_input = user_symbol_from_html_form_sanitized + '_stock'
google_news_url_link = get_google_news_page_function(
temporary_google_search_input)
# Insert into the new stock_news_links_table the 1.symbol and 2.google_link(symbol search)
try:
output_message_news_link_upload = insert_stock_news_links_table_function(
connection_postgres, cursor,
user_symbol_from_html_form_sanitized,
google_news_url_link)
except:
pass
# Insert into job/queue table so that the job can get the company short name every 10 min in the background
try:
job_queue_name = 'get_company_short_name'
output_message_job_upload = insert_jobs_queues_table_function(
connection_postgres, cursor, job_queue_name,
user_symbol_from_html_form_sanitized)
except:
pass
return redirect("/dashboard", code=301)
#return redirect("https://symbolnews.com/dashboard", code=301)
# If user is already tracking this symbol
else:
session[
'output_message_dashboard_page_session'] = error_message_check_if_exist
return redirect("/dashboard", code=301)
#return redirect("https://symbolnews.com/dashboard", code=301)
# If no session info found
else:
set_session_variables_to_none_logout_function()
return redirect("https://symbolnews.com/", code=301)
def updating_account_info_postgres_function():
# If no account information was updated
if request.form.get(
"email") == session['logged_in_user_email'] and request.form.get(
"user_first_name"
) == session['logged_in_user_first_name'] and request.form.get(
"user_last_name"
) == session['logged_in_user_last_name'] and request.form.get(
"phone_number") == session['logged_in_user_phone_number']:
return redirect("https://symbolnews.com/account", code=301)
# Check if email was updated, then sanitize input
if request.form.get("email") != session['logged_in_user_email']:
user_email_from_html_form_sanitized = sanitize_email_input_create_account_function(
request.form.get("email"))
else:
user_email_from_html_form_sanitized = session['logged_in_user_email']
# Check if first name was updated, then sanitize input
if request.form.get(
"user_first_name") != session['logged_in_user_first_name']:
user_first_name_from_html_form_sanitized = sanitize_name_input_create_account_function(
request.form.get("user_first_name"))
else:
user_first_name_from_html_form_sanitized = session[
'logged_in_user_first_name']
# Check if last name was updated, then sanitize input
if request.form.get(
"user_last_name") != session['logged_in_user_last_name']:
user_last_name_from_html_form_sanitized = sanitize_name_input_create_account_function(
request.form.get("user_last_name"))
else:
user_last_name_from_html_form_sanitized = session[
'logged_in_user_last_name']
# Check if phone number was updated, then sanitize input
if request.form.get(
"phone_number") != session['logged_in_user_phone_number']:
user_phone_number_from_html_form_sanitized = sanitize_phone_number_input_create_account_function(
request.form.get("phone_number"))
else:
user_phone_number_from_html_form_sanitized = session[
'logged_in_user_phone_number']
# If any invalid inputs/changes for form
if user_email_from_html_form_sanitized == 'none' or user_first_name_from_html_form_sanitized == 'none' or user_last_name_from_html_form_sanitized == 'none' or user_phone_number_from_html_form_sanitized == 'none':
print('FAILED TO CREATE ACCOUNT!')
return 'FAILED TO UPDATE ACCOUNT!'
# If valid inputs/changes for form
if session['logged_in_user_email'] != 'none':
# Connect to Database
connection_postgres, cursor = connect_to_postgres_function()
# Check/Update user first name
if session[
'logged_in_user_first_name'] != user_first_name_from_html_form_sanitized:
update_user_first_name_function(
connection_postgres, cursor,
user_first_name_from_html_form_sanitized,
session['logged_in_user_uuid'])
session[
'logged_in_user_first_name'] = user_first_name_from_html_form_sanitized
# Check/Update user last name
if session[
'logged_in_user_last_name'] != user_last_name_from_html_form_sanitized:
update_user_last_name_function(
connection_postgres, cursor,
user_last_name_from_html_form_sanitized,
session['logged_in_user_uuid'])
session[
'logged_in_user_last_name'] = user_last_name_from_html_form_sanitized
# Check/Update email
if session[
'logged_in_user_email'] != user_email_from_html_form_sanitized:
does_email_exist = select_login_information_table_query_function(
connection_postgres, cursor,
user_email_from_html_form_sanitized)
if does_email_exist == 'Account already exists':
output_message = 'Cannot use that email/phone number combination'
return redirect("https://symbolnews.com/account", code=301)
else:
update_user_email_function(
connection_postgres, cursor,
user_email_from_html_form_sanitized,
session['logged_in_user_uuid'])
session[
'logged_in_user_email'] = user_email_from_html_form_sanitized
update_user_email_verified_false_function(
connection_postgres, cursor,
session['logged_in_user_uuid'])
confirm_email_token = create_confirm_token_function(
user_email_from_html_form_sanitized,
os.environ.get('URL_SAFE_SERIALIZER_SECRET_KEY_EMAIL'),
os.environ.get('URL_SAFE_SERIALIZER_SECRET_SALT_EMAIL'))
url_for('confirm_email_page.confirm_email_page_function',
confirm_email_token_url_variable=confirm_email_token)
send_email_confirm_account_function(
user_email_from_html_form_sanitized,
user_first_name_from_html_form_sanitized,
confirm_email_token)
# Check/Update phone number
if session[
'logged_in_user_phone_number'] != user_phone_number_from_html_form_sanitized:
does_phone_number_exist = select_login_information_table_query_phone_number_function(
connection_postgres, cursor,
user_phone_number_from_html_form_sanitized)
if does_phone_number_exist == 'Account already exists':
output_message = 'Cannot use that email/phone number combination'
return redirect("https://symbolnews.com/account", code=301)
else:
update_user_phone_function(
connection_postgres, cursor,
user_phone_number_from_html_form_sanitized,
session['logged_in_user_uuid'])
session[
'logged_in_user_phone_number'] = user_phone_number_from_html_form_sanitized
update_user_phone_verified_false_function(
connection_postgres, cursor,
session['logged_in_user_uuid'])
confirm_phone_number_token = create_confirm_token_function(
user_phone_number_from_html_form_sanitized,
os.environ.get('URL_SAFE_SERIALIZER_SECRET_KEY_PHONE'),
os.environ.get('URL_SAFE_SERIALIZER_SECRET_SALT_PHONE'))
url_for(
'confirm_phone_number_page.confirm_phone_number_page_function',
confirm_phone_number_token_url_variable=
confirm_phone_number_token)
send_phone_number_confirm_account_function(
user_phone_number_from_html_form_sanitized,
user_first_name_from_html_form_sanitized,
confirm_phone_number_token)
# Close connection to database
close_connection_cursor_to_database_function(connection_postgres,
cursor)
output_message = 'Account Changes Saved'
return redirect("https://symbolnews.com/account", code=301)
else:
set_session_variables_to_none_logout_function()
return redirect("https://symbolnews.com/", code=301)
