def create_event():
""" Create an event and return the created event for the user """
valid = verify_session()
if not valid:
return json.dumps({'success': False, 'error': 'Invalid session_token'})
success, session_token = extract_token(request)
user = users_dao.get_user_by_session_token(session_token)
if user is not None:
post_body = json.loads(request.data)
event = Event(
title=post_body.get('title'),
description=post_body.get('detail'),
date=datetime.strptime(post_body.get('date'), '%Y-%m-%d').date(),
# startTime=datetime.strptime(post_body.get('startTime'), '%b %d %Y %I:%M%p'),
# endTime=datetime.strptime(post_body.get('endTime'), '%b %d %Y %I:%M%p'),
location=post_body.get('location'),
# reminder=datetime.strptime(post_body.get('reminder'), '%b %d %Y %I:%M%p'),
priority=post_body.get('importance'),
user_id=user.id)
user.events.append(event)
db.session.add(event)
db.session.commit()
return json.dumps({
'success': True,
'data': event.serialize()
},
default=to_serializable), 201
return json.dumps({'success': False, 'error': 'User not found!'}), 404
def update_event(event_id):
""" edit an event and return the updated event information """
valid = verify_session()
if not valid:
return json.dumps({'success': False, 'error': 'Invalid session_token'})
success, session_token = extract_token(request)
user = users_dao.get_user_by_session_token(session_token)
if user is not None:
event = Event.query.filter_by(id=event_id, user_id=user.id).first()
if event is not None:
post_body = json.loads(request.data)
event.title = post_body.get('title', event.title)
event.description = post_body.get('detail', event.description)
event.date = datetime.strptime(post_body.get('date', event.date),
'%Y-%m-%d').date()
# event.startTime = datetime.strptime(post_body.get('startTime', event.startTime), '%b %d %Y %I:%M%p')
# event.endTime = datetime.strptime(post_body.get('endTime', event.endTime), '%b %d %Y %I:%M%p')
event.location = post_body.get('location', event.location)
# event.reminder = datetime.strptime(post_body.get('reminder', event.reminder), '%b %d %Y %I:%M%p')
event.priority = post_body.get('importance', event.priority)
event.user_id = user_id
db.session.commit()
return json.dumps({
'success': True,
'data': event.serialize()
},
default=to_serializable), 200
return json.dumps({'success': False, 'error': 'Event not found!'}), 404
return json.dumps({'success': False, 'error': 'User not found!'}), 404
def me():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
return success_response(user.serialize())
def verify_session():
success, session_token = extract_token(request)
if not success:
return False, session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return False
return True
def secret_message():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
return json.dumps(
{"message": "You have successfully implemented sessions."})
def view_entries():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
entries = Entry.query.filter_by(user_id=user.id)
return success_response([e.serialize() for e in entries])
def search_friends(query):
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
users = User.query.filter(User.email.contains(query))
return success_response([u.friend_serialize(user.id) for u in users])
def secret_message():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({'success': False, 'error': 'Invalid session token'})
return json.dumps({'success': True, 'data': user.serialize()})
def secret_message():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({'error': 'Invalid session token'})
return json.dumps({'messsage': 'Logged in as ' + user.email})
def view_specific_entry(entry_id):
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
entry = Entry.query.filter_by(user_id=user.id, id=entry_id).first()
if entry is None:
return failure_response('Entry does not exist.')
return success_response(entry.serialize())
def delete_user(user_id):
successful, session_token = extract_token(request)
if not successful:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
user = dao.delete_user(user_id)
if user is None:
return failure_response("User not found.")
return success_response(user)
def secret_message():
was_successful, session_token = extract_token(request)
if not was_successful:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return failure_response("Invalid session token")
return success_response(
{"message": "You have successfully implemented session tokens"})
def verify_session_token():
was_successful, session_token = extract_token(request)
if not was_successful:
return False
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return False
return True
def secret_message():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({'error': 'Invalid session token.'})
return json.dumps({
'message': 'You have successfully implemented sessions.',
'username': user.username
})
def get_events():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user.verify_session_token(session_token):
return json.dumps({'error': 'Invalid session token.'})
if not user:
return json.dumps({'error': 'Invalid User'})
events = [event.serialize() for event in user.event]
return json.dumps({'success': True, 'data': events})
def add_to_balance(user_id):
successful, session_token = extract_token(request)
if not successful:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
body = json.loads(request.data)
amount = body.get("amount")
user = dao.add_to_balance(user_id, amount)
if user is None:
return failure_response("User not found.")
return success_response(user)
def delete_friends(friend_id):
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
for friend in user.friends: # TODO jank?
if friend_id == friend.id:
user.friends.remove(friend)
friend.friends.remove(user)
break
db.session.commit()
return success_response(friend.serialize())
def view_entries_at_coordinates():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
body = json.loads(request.data)
latitude = body.get("latitude")
longitude = body.get("longitude")
title = body.get("title")
entries = Entry.query.filter_by(user_id=user.id,
latitude=latitude,
longitude=longitude).all()
return success_response([e.serialize() for e in entries])
def add_friends():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
body = json.loads(request.data)
emails = body.get("friends")
for email in emails:
query = User.query.filter_by(email=email)
if query is not None:
friend = query.first()
user.befriend(friend)
db.session.commit()
return success_response(user.serialize())
def get_events():
""" Return all events of the user as a json object """
valid = verify_session()
if not valid:
return json.dumps({'success': False, 'error': 'Invalid session_token'})
success, session_token = extract_token(request)
user = users_dao.get_user_by_session_token(session_token)
if user is not None:
events = [event.serialize() for event in user.events]
return json.dumps({
'success': True,
'data': events
},
default=to_serializable), 200
return json.dumps({'success': False, 'error': 'User not found.'}), 404
def delete_user_event(event_id):
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user.verify_session_token(session_token):
return json.dumps({'error': 'Invalid session token.'})
if not user:
return json.dumps({'success': False, 'error': 'User not found!'}), 404
event = Event.query.filter_by(id=event_id).first()
if not event:
return json.dumps({'success': False, 'error': 'Event not found!'}), 404
user.event.remove(event)
db.session.commit()
return json.dumps({'success': True, 'data': event.serialize()})
def get_events_by_date(date):
""" Return all events for a given date of the user """
valid = verify_session()
if not valid:
return json.dumps({'success': False, 'error': 'Invalid session_token'})
success, session_token = extract_token(request)
user = users_dao.get_user_by_session_token(session_token)
# user = User.query.filter_by(id=user_id).first()
if user is not None:
search_date = datetime.strptime(date, '%Y-%m-%d')
events = Event.query.filter_by(user_id=user.id, date=search_date)
result = [event.serialize() for event in events]
return json.dumps({
'success': True,
'data': result
},
default=to_serializable), 200
return json.dumps({'success': False, 'error': 'User not found.'}), 404
def delete_event(event_id):
""" delete an event and return the deleted event """
valid = verify_session()
if not valid:
return json.dumps({'success': False, 'error': 'Invalid session_token'})
success, session_token = extract_token(request)
user = users_dao.get_user_by_session_token(session_token)
if user is not None:
event = Event.query.filter_by(id=event_id, user_id=user.id).first()
if event is not None:
db.session.delete(event)
db.session.commit()
return json.dumps({
'success': True,
'data': event.serialize()
},
default=to_serializable), 200
return json.dumps({'success': False, 'error': 'Event not found!'}), 404
return json.dumps({'success': False, 'error': 'User not found!'}), 404
def view_friend_entries():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
body = json.loads(request.data)
latitude = body.get("latitude")
longitude = body.get("longitude")
entries = []
for friend in user.friends:
entries.extend(Entry.query.filter_by(user_id=friend.id).all())
actual_entries = []
for entry in entries:
if within_radius(latitude, longitude, entry.latitude, entry.longitude):
actual_entries.append(entry)
return success_response([e.serialize() for e in actual_entries])
def post_event():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user.verify_session_token(session_token):
return json.dumps({'error': 'Invalid session token.'})
if not user:
return json.dumps({'error': 'Invalid User'})
post_body = json.loads(request.data)
if helpers.has_food(post_body.get('content')):
event_id = post_body.get('id')
event = Event.query.filter_by(id=event_id).first()
user.event.append(event)
db.session.commit()
return json.dumps({'success': True, 'data': event.serialize()})
else:
return json.dumps({
'success': False,
'error': 'No food offered in event!'
}), 406
def create_entry():
success, session_token = extract_token(request)
if not success:
return session_token
user = users_dao.get_user_by_session_token(session_token)
if not user or not user.verify_session_token(session_token):
return json.dumps({"error": "Invalid session token."})
body = json.loads(request.data)
latitude = body.get("latitude")
longitude = body.get("longitude")
title = body.get("title")
description = body.get("description")
address = get_address(latitude, longitude)
date = datetime.datetime.now().replace(microsecond=0)
entry = Entry(user_id=user.id,
title=title,
description=description,
created_at=date,
latitude=latitude,
longitude=longitude,
address=address)
db.session.add(entry)
db.session.commit()
return success_response(entry.serialize())
