def getuser():
"""
Gets user from database and returns user data as JSON.
Either 'id' or 'username' must be specified, with 'id'
taking priority on what will be searched.
"""
# Get data from JSON
data = request.get_json()
# If nethier field is specified, return failure
if not data.get('id') and not data.get('username'):
return jsonify(success=False,
messages=["Username or id must be specified."])
# Get user by id if specified
elif data.get('id'):
id = str(data.get('id'))
user = db.collection('users').document(id).get()
# If user is not found, return failure
if user.exists is False:
return jsonify(success=False, messages=["User with id not found."])
# Get user by username if specified
elif data.get('username'):
username = str(data.get('username'))
user = check_collection_contains(db.collection('users'), 'username',
username)
if not user:
return jsonify(success=False, messages=["User with id not found."])
# Convert user into dictionary
data = {"id": user.id, "username": user.to_dict()['username']}
# Return user info in JSON
return jsonify(data)
def createuser():
"""
Adds new user to database based on JSON data.
"""
# Get data
data = request.get_json()
# Check that all required fields are included
if not data.get('username') or not data.get('password'):
return jsonify(success=False,
messages=["Username and password required"])
# Assign user variables
username = str(data['username'])
password = str(data['password'])
# Check that username is unique
user = check_collection_contains(db.collection('users'), 'username',
username)
if user is not None:
return jsonify(success=False, messages=["Username already taken"])
# Hash password
passhash = PasswordHasher().hash(password)
# Create and add user to database
db.collection('users').add({'username': username, 'passhash': passhash})
# Return success
return jsonify(success=True)
def index():
code = request.args.get('code')
if request.method == 'GET':
country_file = open("app/data/country-by-continent.json")
countries = json.load(country_file)
language_file = open("app/data/languages.json", encoding="utf-8")
languages = json.load(language_file)
highlightColor = "#e2656b"
event = db.collection('events').document(code).get().to_dict()
if event:
highlightColor = event['fgcolor']
return render_template('main.html', countries=countries,
languages=languages, code=code,
highlightColor=highlightColor)
# it's a POST
to_insert = request.form.to_dict()
to_insert['tag'] = code
if 'condition' in to_insert:
to_insert["condition"] = True if to_insert["condition"] == 'checked' else False
db.collection('Information').add(to_insert)
url = url_for('index')
if code:
url += '?code=' + code
session['back_link'] = url
return redirect(url_for("thanks"))
def deleteevent():
"""
Removes specified event from database and deletes all associated warnings.
"""
# Get data from JSON
data = request.get_json()
# Ensure all required fields are provided
if not data.get('id'):
return jsonify(success=False, messages=['Event ID required'])
# Get event
event = db.collection('events').document(data.get('id')).get()
# Ensure that event exists
if not event.exists:
return jsonify(success=False, messages=['Event does not exist'])
# Delete event from events
db.collection('events').document(data.get('id')).delete()
# Get any warnings for the event and delete them
warnings = db.collection('event_warnings').where('from_event_id', '==',
data.get('id')).stream()
for warning in warnings:
db.collection('event_warnings').document(warning.id).delete()
warnings = db.collection('event_warnings').where('to_event_id', '==',
data.get('id')).stream()
for warning in warnings:
db.collection('event_warnings').document(warning.id).delete()
# Return success
return jsonify(success=True)
def signup():
email = request.form['email']
company = request.form['company']
password = request.form['password']
new_user = db.collection('users').document(email)
new_user.set({'email': email, 'company': company, 'password': password})
comp = db.collection('companies').document(company).get()
if not comp.exists:
new_company = db.collection('companies').document(company)
new_company.set({'company': company, 'images': []})
return render_template('login.html')
def getuserevents():
"""
Gets all events for a given user.
"""
# Get data from JSON
data = request.get_json()
# If nethier field is specified, return failure
if not data.get('user_id'):
return jsonify(success=False, messages=["User id must be specified."])
from_time = None
to_time = None
if data.get('from_time'):
from_time = parser.parse(data.get('from_time'))
if data.get('to_time'):
to_time = parser.parse(data.get('to_time'))
# Query all events for the user sorted by start time and match criterea
query = db.collection('events')
query = query.where('user_id', '==', data.get('user_id'))
if from_time:
query = query.where('start_time', '>=', from_time)
if to_time:
query = query.where('start_time', '<=', to_time)
query = query.order_by('start_time', direction=firestore.Query.ASCENDING)
events = query.stream()
# Query all event warnings for the user that relate to any queried event
query = db.collection('event_warnings')
query = query.where('user_id', '==', data.get('user_id'))
warnings = query.stream()
# Add events and warnings to dictionary
data = dict()
data['events'] = list()
data['warnings'] = list()
# Iterate over and add events
for event in events:
event_dict = event.to_dict()
event_dict.update({"id": event.id})
data['events'].append(event_dict)
# Iterate over and add warnings
for warning in warnings:
warning_dict = warning.to_dict()
warning_dict.update({"id": warning.id})
# Only append warning if it relates to one of the events
if warning_dict['from_event_id'] in map(
lambda e: e['id'],
data['events']) or warning_dict['to_event_id'] in map(
lambda e: e['id'], data['events']):
data['warnings'].append(warning_dict)
# Return event data
return jsonify(data)
def query_all_users(self):
try:
users = db.collection(u'users').stream()
return [user.to_dict() for user in users]
except Exception as e:
message = "Could not get users from firebase.\n\n{}".format(str(e))
self.slack_bot.send_message(message=message)
def validateuser():
"""
Validates that the username and password matches.
"""
# Get data
data = request.get_json()
# Check that all required fields are included
if not data.get('username') or not data.get('password'):
return jsonify(success=False,
messages=["Username and assword required"])
# Assign user variables
username = str(data['username'])
password = str(data['password'])
# Get user
user = check_collection_contains(db.collection('users'), 'username',
username)
# Check that user exists
if user is None:
return jsonify(success=False, messages=["User does not exist"])
# Verify whether or not password is valid
try:
valid = PasswordHasher().verify(user.to_dict()['passhash'], password)
except VerifyMismatchError:
return jsonify(success=False, messages=["Invalid password"])
# Return success
return jsonify(success=True)
def upload_image():
upload = request.get_json()
url = str(upload.get('url'))
company = str(upload.get('company'))
comp = db.collection('companies').document(company)
images = comp.get().to_dict()['images']
comp.update({'images': images + [url]})
def users():
_users = db.collection('users').stream()
users = {}
for user in _users:
u = user.to_dict()
u['role'] = roles[u['role']]
users[user.id] = u
return render_template('users.html', users=users)
def retrieveCollection(collectionID):
debug(f'[retrieveCollection - INFO]: Starting.')
collectionID = f'{collectionID}'
if not (collectionID in collectionIDs):
err = f'[retrieveCollection - ERROR]: Collection name {collectionID} is not a known collection.'
debug(err)
return None, err
col_ref = db.collection(collectionID)
return col_ref, ''
def query_all_games(self):
try:
games = db.collection(u'games').stream()
dict_games = []
for game in games:
game_id = game.id
game_dict = game.to_dict()
game_dict['id'] = game_id
dict_games.append(game_dict)
dict_games.sort(key=lambda game: datetime.strptime(game.get('date'), '%a %b %d %Y'))
return dict_games
except Exception as e:
message = "Could not get games from firebase.\n\n{}".format(str(e))
self.slack_bot.send_message(message=message)
def createDocument(collectionID, documentID, creationData):
debug(f'[createDocument - INFO]: Starting.')
collectionID = f'{collectionID}'
documentID = f'{documentID}'
doc_ref = db.collection(collectionID).document(documentID)
doc_ref.set(creationData)
doc = doc_ref.get()
if not doc.exists:
err = f'[retrieveDocument - ERROR]: Document {documentID} does not exist in collection {collectionID}.'
debug(err)
return err
return ''
def retrieveDocument(collectionID, documentID, returnErrorOnNull=False):
debug(f'[retrieveDocument - INFO]: Starting.')
collectionID = f'{collectionID}'
documentID = f'{documentID}'
if not (collectionID in collectionIDs):
err = f'[retrieveDocument - ERROR]: Collection name {collectionID} is not a known collection.'
debug(err)
return None, None, err
doc_ref = db.collection(collectionID).document(documentID)
doc = doc_ref.get()
if not doc.exists:
if not returnErrorOnNull:
doc_ref.set({})
doc_ref = db.collection(collectionID).document(documentID)
doc = doc_ref.get()
else:
err = f'[retrieveDocument - ERROR]: Document {documentID} does not exist in collection {collectionID}.'
debug(err)
return None, None, err
return doc_ref, doc, ''
def user_add():
if request.method == 'GET':
return render_template('user_add.html')
# it's a POST
to_insert = request.form.to_dict()
to_insert['created'] = SERVER_TIMESTAMP
to_insert['role'] = int(to_insert['role'])
to_insert['createdby'] = session['user']['username']
user_ref = db.collection('users').document(to_insert['username'])
user_ref.set(to_insert)
session['message'] = 'Successfully modified user.'
return redirect(url_for('users'))
def addevent():
"""
Adds event to database. Also generates warnings if events
have tracel time conflicts.
"""
# Get data from JSON
data = request.get_json()
# Ensure all required fields are provided
valid = True
messages = list()
if not data.get('user_id'):
valid = False
messages.append("User id required.")
if not data.get('title'):
valid = False
messages.append("Event title required.")
if not data.get('start_time'):
valid = False
messages.append("Event start datetime required.")
if not data.get('end_time'):
valid = False
messages.append("Event end datetime required.")
# If given data is invalid, return failure with errors
if not valid:
return jsonify(success=False, messages=messages)
# Add event
timestmp, added_event = db.collection('events').add({
'address':
str(data.get('address')),
'description':
str(data.get('description')),
'start_time':
parser.parse(data.get('start_time')),
'end_time':
parser.parse(data.get('end_time')),
'title':
str(data.get('title')),
'travel_method':
str(data.get('travel_method')),
'user_id':
str(data.get('user_id')),
})
# Generate any warnings the added event
generatewarnings(added_event.get())
# Return success
return jsonify(success=True)
def login():
email = request.form['email']
password = request.form['password']
user = db.collection('users').document(email).get()
if user.exists:
user_info = user.to_dict()
correct = user_info['password']
if re.match(password, correct):
return render_template('home.html', user=user_info)
else:
print("Error: Incorrect password")
return render_template('login.html')
else:
print("Error: No user associated with email.")
return render_template('login.html')
def getevent():
"""
Gets event with given ID.
"""
# Get data from JSON
data = request.get_json()
# Ensure all required fields are provided
if not data.get('id'):
return jsonify(success=False, messages=['Event ID required'])
# Get event
event = db.collection('events').document(data.get('id')).get()
# Ensure that event exists
if not event.exists:
return jsonify(success=False, messages=['Event does not exist'])
# Get event data
data = {"id": event.id}
data.update(event.to_dict())
# Return event
return jsonify(data)
def partners():
if request.method == 'GET':
return render_template('partner.html')
# it's a POST
to_insert = request.form.to_dict()
to_insert['timestamp'] = SERVER_TIMESTAMP
to_insert['datestart'] = datestr_to_datetime(to_insert['datestart'])
to_insert['dateend'] = datestr_to_datetime(to_insert['dateend'])
print(request.files.to_dict())
if 'logo' in request.files:
file = request.files['logo']
if file.filename != '':
filename = secure_filename(file.filename)
fs_loc = join(app.config['UPLOAD_FOLDER'], filename)
file.save(fs_loc)
to_insert['filename'] = filename
bucket.blob(filename).upload_from_filename(fs_loc)
remove(fs_loc)
event_ref = db.collection('events').document(to_insert['code'])
event_ref.set(to_insert)
return render_template('partner_success.html', data=request.form.to_dict())
def login():
if request.method == 'GET':
if 'message' in session:
return render_template('login.html', message=session['message'])
else:
return render_template('login.html')
# it's a POST
to_verify = request.form.to_dict()
candidate = db.collection('users').document(
to_verify['username']).get().to_dict()
if candidate:
if to_verify['password'] == candidate['password']:
if 'message' in session:
del session['message']
session['user'] = candidate
if candidate['role'] == 2: # partner
return redirect(url_for('partners'))
elif candidate['role'] == 1: # admin
return redirect(url_for('users'))
session['message'] = 'Authentication failed.'
return redirect(url_for('login'))
def init_db_collection(name):
# Initialize db collection
return db.collection(name)
def add_game(player_id):
current_player = None
form = GameForm(request.form)
for player in stats_builder.users:
if player_id == player.get('uid'):
current_player = player
break
if current_player:
form.isCaptain.data = False
form.loserScore.data = 0
form.totalInnings.data =0
form.error.data = 0
form.pitchingStrikeouts.data = 0
form.blownSaves.data = 0
form.inningsPitched.data = 0
form.loss.data = 0
form.winnerScore.data = 0
form.selectedOpponent.data = ''
form.saves.data = 0
form.baseOnBalls.data = 0
form.hitByPitch.data = 0
form.outs.data = 0
form.singles.data = 0
form.win.data = 0
form.isGameWon.data = False
form.runsBattedIn.data = 0
form.earnedRuns.data = 0
form.strikeouts.data = 0
form.stolenBases.data = 0
form.homeRuns.data = 0
form.pitchingBaseOnBalls.data = 0
form.caughtStealing.data = 0
form.triples.data = 0
form.runs.data = 0
form.player.data = f'{current_player.get("firstName")} {current_player.get("lastName")}'
form.doubles.data = 0
if request.method == 'POST' and form.validate():
# do the api call
try:
if not request.form['date']:
raise Exception('No date provided')
date = datetime.strptime(request.form['date'], '%Y-%m-%d')
new_game = {
'date': date.strftime('%a %b %d %Y'),
'timestamp': int(date.timestamp()),
'uid': player_id,
'isCaptain': request.form.get('isCaptain', False) == 'y',
'loserScore': int(request.form['loserScore']),
'totalInnings': int(request.form['totalInnings']),
'error': int(request.form['error']),
'pitchingStrikeouts': int(request.form['pitchingStrikeouts']),
'blownSaves': int(request.form['blownSaves']),
'inningsPitched': int(request.form['inningsPitched']),
'loss': int(request.form['loss']),
'winnerScore': int(request.form['winnerScore']),
'selectedOpponent': str(request.form['selectedOpponent']),
'saves': int(request.form['saves']),
'baseOnBalls': int(request.form['baseOnBalls']),
'hitByPitch': int(request.form['hitByPitch']),
'outs': int(request.form['outs']),
'singles': int(request.form['singles']),
'win': int(request.form['win']),
'isGameWon': request.form.get('isGameWon', False) == 'y',
'runsBattedIn': int(request.form['runsBattedIn']),
'earnedRuns': int(request.form['earnedRuns']),
'strikeouts': int(request.form['strikeouts']),
'stolenBases': int(request.form['stolenBases']),
'homeRuns': int(request.form['homeRuns']),
'pitchingBaseOnBalls': int(request.form['pitchingBaseOnBalls']),
'caughtStealing': int(request.form['caughtStealing']),
'triples': int(request.form['triples']),
'runs': int(request.form['runs']),
'player': str(request.form['player']),
'doubles': int(request.form['doubles']),
}
db.collection(u'games').add(new_game)
except Exception as e:
flash('Adding game failed, try again', 'error')
if str(e) == 'No date provided':
flash(str(e), 'error')
return redirect(url_for('index'))
flash('Game added', 'success')
return redirect(url_for('index'))
else:
return "no data"
return render_template('add_game.html', form=form, player=current_player)
def game(game_id):
game = None
form = GameForm(request.form)
for player_game in stats_builder.games:
if game_id == player_game.get('id'):
game = player_game
break
if game:
form.isCaptain.data = game.get('isCaptain')
form.loserScore.data = game.get('loserScore')
form.totalInnings.data = game.get('totalInnings')
form.error.data = game.get('error')
form.pitchingStrikeouts.data = game.get('pitchingStrikeouts')
form.blownSaves.data = game.get('blownSaves')
form.inningsPitched.data = game.get('inningsPitched')
form.loss.data = game.get('loss')
form.winnerScore.data = game.get('winnerScore')
form.selectedOpponent.data = game.get('selectedOpponent', '')
form.saves.data = game.get('saves')
form.baseOnBalls.data = game.get('baseOnBalls')
form.hitByPitch.data = game.get('hitByPitch')
form.outs.data = game.get('outs')
form.singles.data = game.get('singles')
form.win.data = game.get('win')
form.isGameWon.data = game.get('isGameWon')
form.runsBattedIn.data = game.get('runsBattedIn')
form.earnedRuns.data = game.get('earnedRuns')
form.strikeouts.data = game.get('strikeouts')
form.stolenBases.data = game.get('stolenBases')
form.homeRuns.data = game.get('homeRuns')
form.pitchingBaseOnBalls.data = game.get('pitchingBaseOnBalls')
form.caughtStealing.data = game.get('caughtStealing')
form.triples.data = game.get('triples')
form.runs.data = game.get('runs')
form.player.data = game.get('player', '')
form.doubles.data = game.get('doubles')
if request.method == 'POST' and form.validate():
# do the api call
try:
updated_game = {
'isCaptain': request.form.get('isCaptain', False) == 'y',
'loserScore': int(request.form['loserScore']),
'totalInnings': int(request.form['totalInnings']),
'error': int(request.form['error']),
'pitchingStrikeouts': int(request.form['pitchingStrikeouts']),
'blownSaves': int(request.form['blownSaves']),
'inningsPitched': int(request.form['inningsPitched']),
'loss': int(request.form['loss']),
'winnerScore': int(request.form['winnerScore']),
'selectedOpponent': str(request.form['selectedOpponent']),
'saves': int(request.form['saves']),
'baseOnBalls': int(request.form['baseOnBalls']),
'hitByPitch': int(request.form['hitByPitch']),
'outs': int(request.form['outs']),
'singles': int(request.form['singles']),
'win': int(request.form['win']),
'isGameWon': request.form.get('isGameWon', False) == 'y',
'runsBattedIn': int(request.form['runsBattedIn']),
'earnedRuns': int(request.form['earnedRuns']),
'strikeouts': int(request.form['strikeouts']),
'stolenBases': int(request.form['stolenBases']),
'homeRuns': int(request.form['homeRuns']),
'pitchingBaseOnBalls': int(request.form['pitchingBaseOnBalls']),
'caughtStealing': int(request.form['caughtStealing']),
'triples': int(request.form['triples']),
'runs': int(request.form['runs']),
'player': str(request.form['player']),
'doubles': int(request.form['doubles']),
}
db.collection(u'games').document(u'{}'.format(game_id)).update(updated_game)
except Exception as e:
flash('Game update failed, try again', 'error')
return redirect(url_for('index'))
flash('Game updated', 'success')
return redirect(url_for('index'))
return render_template('game.html', game=game, form=form)
else:
return "no game data"
def cache():
cache = db.collection('cached').document("analytics").get()
return cache.to_dict()
todo_items = {'todo1':True, 'todo222':False,'just simple to do':True}
todos = [TodoItem('This is a mock todo that has not been completed yet',False, datetime.datetime.now())]
init = False
#mock data
ButtonPressed = 0
#mock data
currentUser = None
# Initialize Firestore DB
# cred = credentials.Certificate('key.json')
cred = credentials.Certificate(key_json_file_path)
default_app = initialize_app(cred)
db = firestore.client()
todo_ref = db.collection('todos')
def get_db():
db = getattr(g, '_database', None)
if db is None:
db = g._database = sqlite3.connect(DATABASE)
return db
def query_db(query, args=(), one=False):
cur = get_db().execute(query, args)
rv = cur.fetchall()
cur.close()
return (rv[0] if rv else None) if one else rv
#create a todo in database
def generatewarnings(event_now):
"""
Generates warnings if given event produces any time conflicts.
"""
# Get user id of given event
event_user_id = event_now.to_dict()['user_id']
# Query all events for the user in order of start time
query = db.collection('events')
query = query.where('user_id', '==', event_user_id)
query = query.order_by('start_time', direction=firestore.Query.ASCENDING)
events = query.stream()
# Iterate over each event and find any events before or after this one
event_before = None
event_after = None
prev_event = None
for event in events:
if event.id == event_now.id:
event_before = prev_event
elif event_before is not None:
event_after = event
break
prev_event = event
# Get dictionaries for each event
if event_before:
event_before_dict = event_before.to_dict()
if event_now:
event_now_dict = event_now.to_dict()
if event_after:
event_after_dict = event_after.to_dict()
# Call Google maps directions API to get the times between the events
travel_time_to = timedelta(0)
travel_time_from = timedelta(0)
if event_before is not None:
travel_time_to = timebetweenevents(event_before, event_now)
if event_after is not None:
travel_time_from = timebetweenevents(event_now, event_after)
# Check for time conflicts between before and current events
if event_before is not None:
# Calculate the time between the events
time_between_events = (event_now_dict['start_time'] -
event_before_dict['end_time'])
# Check if the next event starts before the previous ends
if time_between_events < timedelta(0):
warning_message = (
f"The start time for \"{event_now_dict['title']}\" is before "
f"the end time for event \"{event_before_dict['title']}\". "
f"Consider rescheduling these events to account for this.")
db.collection('event_warnings').add({
'from_event_id': event_before.id,
'to_event_id': event_now.id,
'user_id': event_user_id,
'message': warning_message
})
# Check if the travel method permits arrival to the event on time
elif time_between_events < (travel_time_to - timedelta(minutes=1)):
diff_min = int(
(travel_time_to - time_between_events).total_seconds() // 60)
warning_message = (
f"Time to get from event \"{event_before_dict['title']}\""
f" to \"{event_now_dict['title']}\" by "
f"{event_before_dict['travel_method']} is {diff_min} "
f"minutes more than between the end of first event and start "
f"of the second event. Consider rescheduling events or "
f"changing mode of transport.")
db.collection('event_warnings').add({
'from_event_id': event_before.id,
'to_event_id': event_now.id,
'user_id': event_user_id,
'message': warning_message
})
# Check for time conflicts between current and after events
if event_after is not None:
# Calculate the time between the events
time_between_events = (event_after_dict['start_time'] -
event_now_dict['end_time'])
# Check if the next event starts before the previous ends
if time_between_events < timedelta(0):
warning_message = (
f"The start time for \"{event_after_dict['title']}\" is before"
f" the end time for event \"{event_now_dict['title']}\". "
f"Consider rescheduling these events to account for this.")
db.collection('event_warnings').add({
'from_event_id': event_before.id,
'to_event_id': event_now.id,
'user_id': event_user_id,
'message': warning_message
})
# Check if the travel method permits arrival to the event on time
elif time_between_events < (travel_time_from - timedelta(minutes=1)):
diff_min = int(
(travel_time_to - time_between_events).total_seconds() // 60)
warning_message = (
f"Time to get from event \"{event_now_dict['title']}\" "
f"to \"{event_after_dict['title']}\" by "
f"{event_now_dict['travel_method']} is {diff_min} "
f"minutes more than between the end of first event and start "
f"of the second event. Consider rescheduling events or "
f"changing mode of transport.")
db.collection('event_warnings').add({
'from_event_id': event_now.id,
'to_event_id': event_after.id,
'user_id': event_user_id,
'message': warning_message
})
