def register(event, context):
try:
logging.debug('register')
user_request = UserModel.from_request(json.loads(event['body']))
logging.debug('user model:')
logging.debug(user_request)
validation.validate_email(user_request.email)
validate_user_does_not_exist(user_request.email)
logging.debug('user does not exist, proceeding with creation')
user = ud.create(user_request)
res = build_response_with_body(
200, {
'id': user.id,
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email,
'token': auth_utils.generate_auth_token(user.id).decode()
})
return res
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
logging.debug(e)
logging.debug(str(e))
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def login(event, context):
try:
login_request = LoginRequestModel.from_request(
json.loads(event['body']))
if login_request.email == '*****@*****.**' and login_request.password == 'password':
return build_response_without_body(204)
if login_request.email == '*****@*****.**' and login_request.password == 'n3tify_test_account':
return build_response_without_body(204)
return errors.build_response_from_api_error(
errors.ApiError(errors.invalid_user_name_or_password))
except errors.ApiError as e:
print(e)
if e.api_error.issue == 'NOT_FOUND':
return errors.build_response_from_api_error(
errors.ApiError(errors.invalid_user_name_or_password))
else:
return errors.build_response_from_api_error(e)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def login(event, context):
try:
login_request = LoginRequestModel.from_request(
json.loads(event['body']))
user = ud.get_by_email(login_request.email)
# this throws an exception if the passwords don't match
hash_utils.check_password(login_request.password, user.password)
return build_response_with_body(
200, {
'id': user.id,
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email,
'token': auth_utils.generate_auth_token(user.id).decode()
})
except errors.ApiError as e:
print('boo')
print(e)
if e.api_error.issue == 'NOT_FOUND':
print("wtffff")
return errors.build_response_from_api_error(
errors.ApiError(errors.invalid_user_name_or_password))
else:
return errors.build_response_from_api_error(e)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def get_quizzes(event, context):
try:
items = quiz_dao.get_all()
quizzes = [item.to_dict() for item in items if items]
return build_response_with_body(200, quizzes)
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def delete_question(event, context):
try:
token = validate_authorization_header_is_present(event['headers'])
auth_utils.decode_auth_token(token)
question_dao.delete(event['pathParameters']['question_id'])
return build_response_without_body(204)
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(errors.ApiError(errors.internal_server_error, e))
def update_user(event, context):
try:
user_request = UserModel.from_update_request(json.loads(event['body']))
logging.debug(user_request.to_dict())
user = user_dao.update(user_request)
logging.debug(user)
logging.debug(user.to_dict())
return build_response_with_body(200, user.to_dict())
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def delete_user(event, context):
try:
user_dao.delete(event['pathParameters']['user_id'])
return build_response_without_body(204)
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except KeyError as e:
return errors.build_response_from_api_error(
errors.Error('MISSING_REQUIRED_PARAMETER', str(e), 400))
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def get_by_flashcard_deck_id(event, context):
try:
token = validate_authorization_header_is_present(event['headers'])
auth_utils.decode_auth_token(token)
flashcard_deck = flashcard_deck_dao.get_by_id(
event['pathParameters']['flashcard_deck_id'])
return build_response_with_body(200, flashcard_deck.to_dict())
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def create_question(event, context):
print('creating question')
try:
token = validate_authorization_header_is_present(event['headers'])
auth_utils.decode_auth_token(token)
question_request = QuestionModel.from_request(json.loads(event['body']))
validate_quiz_exists(question_request.quiz_id)
return build_response_with_body(201, question_dao.create(question_request).to_dict())
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(errors.ApiError(errors.internal_server_error, e))
def delete_quiz(event, context):
try:
token = validate_authorization_header_is_present(event['headers'])
auth_utils.decode_auth_token(token)
quiz_dao.delete(event['pathParameters']['quiz_id'])
return build_response_without_body(204)
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except KeyError as e:
return errors.build_response_from_api_error(
errors.Error('MISSING_REQUIRED_PARAMETER', str(e), 400))
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def create_flashcard(event, context):
try:
token = validate_authorization_header_is_present(event['headers'])
auth_utils.decode_auth_token(token)
flashcard_request = FlashcardModel.from_request(
json.loads(event['body']))
validate_flashcard_deck_exists(flashcard_request.flashcard_deck_id)
return build_response_with_body(
201,
flashcard_dao.create(flashcard_request).to_dict())
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def create_message(event, context):
try:
message_request = MessageModel.from_request(json.loads(event['body']))
logging.debug(message_request.to_dict())
message = message_dao.create(message_request)
logging.debug(message)
logging.debug(message.to_dict())
return build_response_with_body(201, message.to_dict())
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def update_question(event, context):
try:
token = validate_authorization_header_is_present(event['headers'])
auth_utils.decode_auth_token(token)
question_model = QuestionModel.from_update_request(json.loads(event['body']))
quiz = question_dao.update(question_model)
logging.debug(quiz)
logging.debug(quiz.to_dict())
return build_response_with_body(200, quiz.to_dict())
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(errors.ApiError(errors.internal_server_error, e))
def get_by_user_id(event, context):
try:
logging.debug('event headers: ', event['headers'])
token = validate_authorization_header_is_present(event['headers'])
auth_utils.decode_auth_token(token)
items = quiz_dao.get_by_user_id(event['pathParameters']['user_id'])
quizzes = [item.to_dict() for item in items if items]
return build_response_with_body(200, quizzes)
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def get_quiz_by_id(event, context):
try:
token = validate_authorization_header_is_present(event['headers'])
auth_utils.decode_auth_token(token)
quiz = quiz_dao.get_by_id(event['pathParameters']['quiz_id'])
print('********* getting quiz')
logging.debug(quiz)
logging.debug(quiz.to_dict())
return build_response_with_body(200, quiz.to_dict())
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def update_flashcard(event, context):
try:
token = validate_authorization_header_is_present(event['headers'])
auth_utils.decode_auth_token(token)
flashcard_request = FlashcardModel.from_update_request(
json.loads(event['body']))
flashcard = flashcard_dao.update(flashcard_request)
logging.debug(flashcard)
logging.debug(flashcard.to_dict())
return build_response_with_body(200, flashcard.to_dict())
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
def create_quiz(event, context):
try:
token = validate_authorization_header_is_present(event['headers'])
auth_utils.decode_auth_token(token)
quiz_request = QuizModel.from_request(json.loads(event['body']))
logging.debug(quiz_request.user_id)
validate_user_exists_by_id(quiz_request.user_id)
quiz = quiz_dao.create(quiz_request)
logging.debug(quiz)
logging.debug(quiz.to_dict())
return build_response_with_body(201, quiz.to_dict())
except errors.ApiError as ae:
return errors.build_response_from_api_error(ae)
except Exception as e:
return errors.build_response_from_api_error(
errors.ApiError(errors.internal_server_error, e))
