def handler(event, context):
try:
logger.info(event)
data = json.loads(event['body'])
user_id = event['pathParameters']['user_id']
if 'email' not in data:
return response_builder(400,
{'error_message': 'emailのパラメータが足りません'})
if users.exists_user(user_id=user_id):
return response_builder(409, {'error_message': '既にそのユーザは存在しています'})
users.create(
user_id=user_id,
email=data['email'],
)
except json.decoder.JSONDecodeError:
return response_builder(400, {'error_message': 'JSONが不正です'})
except ClientError as e:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
return response_builder(201)
def handler(event, context):
try:
logger.info(event)
authlete = AuthleteSdk(api_key=os.environ['AUTHLETE_API_KEY'],
api_secret=os.environ['AUTHLETE_API_SECRET'])
congito_user_pool = CognitoUserPool(
user_pool_id=os.environ['COGNITO_USER_POOL_ID'])
access_token = get_access_token_from_header(headers=event['headers'])
response_content = authlete.get_user_info(access_token=access_token)
sub = congito_user_pool.get_user_sub_value(
username=response_content['sub'])
except ValidationError as e:
return response_builder(e.status_code, {'error_message': e.message})
except AuthleteApiError as e:
if e.status_code != 401:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
return response_builder(e.status_code, {'error_message': e.message})
except ClientError as e:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
return response_builder(200, {'sub': sub, 'name': response_content['sub']})
def handler(event, context):
try:
logger.info(event)
if verify_supported_media_type(event['headers']) is False:
return response_builder(
415, {
'error_message':
"This API only support 'content-type: application/x-www-form-urlencoded' media type"
})
token = parse_qs(event['body']).get('token', None)
if token is None:
return response_builder(
400, {'error_message': 'Missing token patameter'})
authlete = AuthleteSdk(api_key=os.environ['AUTHLETE_API_KEY'],
api_secret=os.environ['AUTHLETE_API_SECRET'])
result = authlete.verify_access_token(token=token[0])
except AuthleteApiError as e:
if e.status_code != 400:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
return response_builder(e.status_code, {'error_message': e.message})
return response_builder(200, result)
def mysongs_list(user_id):
if not UserModel.find_by_id(user_id):
raise Exception('User Not found!!')
songs = [song() for song in SongModel.find_by_user(user_id)]
if not songs:
return response_builder(status_code=404, body="Empty!!")
print(type(songs))
return response_builder(status_code=200, body=songs)
def handler(event, context):
try:
logger.info(event)
result = users.get_all()
except ClientError as e:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
return response_builder(200, result['Items'])
def handler(event, context):
try:
logger.info(event)
user_id = event['pathParameters']['user_id']
users.delete(user_id=user_id)
except ClientError as e:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
return response_builder(204)
def handler(event, context):
try:
logger.info(event)
authlete = AuthleteSdk(api_key=os.environ['AUTHLETE_API_KEY'],
api_secret=os.environ['AUTHLETE_API_SECRET'])
configuration = authlete.get_openid_configuration()
except AuthleteApiError as e:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
return response_builder(200, configuration)
def check_task_status(task_id):
try:
from models.task import get_status
task = get_status(task_id)
print("TASK", task)
if task:
if task.status == "SUCCESS":
return response_builder(status_code=201,
body='Your Song is Ready to Play')
else:
return response_builder(status_code=500,
body='Internal Server Error')
return response_builder(status_code=200, body='On-Progress')
except:
return response_builder(status_code=400, body='Bad Request')
def handler(event, context):
try:
logger.info(event)
user_id = event['pathParameters']['user_id']
if not users.exists_user(user_id=user_id):
return response_builder(404, {'error_message': 'そのユーザは存在しません'})
result = users.get(user_id=user_id)
except ClientError as e:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
return response_builder(200, result['Item'])
def add_song(req, task_id='existed_101'):
# : Validate url
url = url_helper(req['url'])
if url is None:
return {'msg': "Invalid URL. Please check again!"}, 400
if SongModel.check_duplication(req['posted_by'], req['url']):
return response_builder(status_code=400, body="Song Exists")
try:
# Save song info into DB
new_song = SongModel(task_id, req['title'], req['posted_by'],
req['genre_id'], url)
new_song.save_to_db()
return new_song(), 201
except:
return "Error on SongModel Instance", 500
def handler(event, context):
# 初期化処理
token = {}
authlete = None
try:
if verify_supported_media_type(event['headers']) is False:
return response_builder(
415, {
'error_message':
"This API only support 'content-type: application/x-www-form-urlencoded' media type"
})
authlete = AuthleteSdk(api_key=os.environ['AUTHLETE_API_KEY'],
api_secret=os.environ['AUTHLETE_API_SECRET'])
except Exception as e:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
# トークン取得処理
try:
grant_type = authlete.get_grant_type(body=event['body'])
data = authlete.get_clientid_and_clientsecret(headers=event['headers'],
body=event['body'])
if grant_type == 'authorization_code':
if data.get('client_secret') is None:
token = authlete.get_access_token_from_code(
body=event['body'], client_id=data['client_id'])
else:
token = authlete.get_access_token_from_code(
body=event['body'],
client_id=data['client_id'],
client_secret=data['client_secret'])
elif grant_type == 'refresh_token':
if data.get('client_secret') is None:
token = authlete.get_access_token_from_refresh_token(
body=event['body'], client_id=data['client_id'])
else:
token = authlete.get_access_token_from_refresh_token(
body=event['body'],
client_id=data['client_id'],
client_secret=data['client_secret'])
else:
return response_builder(400,
{'error_message': 'invalid grant_type'})
except ValidationError as e:
logger.error(e)
return response_builder(e.status_code, {'error_message': e.message})
except AuthleteApiError as e:
logger.error(e)
if e.status_code != 500:
return response_builder(e.status_code,
{'error_message': e.message})
return response_builder(500,
{'error_message': 'Internal Server Error'})
try:
congito_user_pool = CognitoUserPool(
user_pool_id=os.environ['COGNITO_USER_POOL_ID'])
access_token = token.get('access_token')
response_content = authlete.get_user_info(access_token=access_token)
attributes = congito_user_pool.get_user_attributes(
username=response_content['sub'])
phone_number_verified = 'false'
for attribute in attributes:
if attribute['Name'] == 'phone_number_verified':
phone_number_verified = attribute['Value']
if phone_number_verified == 'true':
return response_builder(200, token)
else:
return response_builder(
403, {'error_message': 'phone_number must be verified'})
except Exception as e:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
def handler(event, context):
try:
logger.info(event)
if verify_supported_media_type(event['headers']) is False:
return response_builder(
415, {
'error_message':
"This API only support 'content-type: application/x-www-form-urlencoded' media type"
})
# jwtの検証
jwt_token = get_access_token_from_header(event['headers'])
if not verify_jwt_token(jwt_token):
return response_builder(401,
{"error_message": "invalid jwt token"})
# パラメーター設定
claims = jwt.get_unverified_claims(jwt_token)
params = urllib.parse.parse_qs(event.get('body', ''))
params['subject'] = [claims['cognito:username']]
params['sub'] = [claims['sub']]
params['scope'] = params.get('scope', ['']) # scopeが無い場合は空配列で初期化
params['scope'] = [params['scope'][0]] # scopeが複数来たら最初だけ使う
# scopeの検証
if not verify_scope_parameter(params['scope'][0]):
return response_builder(
400, {
"error_message":
"invalid scope parameter. scope parameter must be 'openid read' or 'openid read write'"
})
# authrazition API
new_params = urllib.parse.urlencode(params, doseq=True)
if urllib.parse.parse_qs(new_params).get(
'code_challenge_method') is None:
return response_builder(
400, {
'error_message':
"The authorization request does not contain 'code_challenge_method' parameter."
})
authlete = AuthleteSdk(api_key=os.environ['AUTHLETE_API_KEY'],
api_secret=os.environ['AUTHLETE_API_SECRET'])
authrazition_response = authlete.authorization_request(new_params)
AUTHORIZATION_ERROR_CODES = [
AUTHLETE_AUTHORIZATION_ERROR_CLIENT_ID_IS_NOT_FOUND,
AUTHLETE_AUTHORIZATION_ERROR_CODE_CHALLENGE_IS_INVALID,
AUTHLETE_AUTHORIZATION_ERROR_CODE_CHALLENGE_METHOD_IS_NOT_SUPPORTED,
AUTHLETE_AUTHORIZATION_ERROR_DOES_NOT_CONTAIN_CLIENT_ID,
AUTHLETE_AUTHORIZATION_ERROR_DOES_NOT_CONTAIN_CODE_CHALLENGE_PARAMETER,
AUTHLETE_AUTHORIZATION_ERROR_DOES_NOT_CONTAIN_REDIRECT_URI,
AUTHLETE_AUTHORIZATION_ERROR_DOES_NOT_CONTAIN_RESPONSE_TYPE,
AUTHLETE_AUTHORIZATION_ERROR_REDIRECT_URI_IS_NOT_REGISTERED,
AUTHLETE_AUTHORIZATION_ERROR_RESPONSE_TYPE_IS_INVALID,
AUTHLETE_AUTHORIZATION_SUCCESS_CODE
]
if authrazition_response['resultCode'] in AUTHORIZATION_ERROR_CODES:
return response_builder(
400, {
'error_message':
strip_authlete_code(authrazition_response['resultMessage'])
})
# authorization issue API
authrazition_issue_response = authlete.authorization_issue_request({
"ticket":
authrazition_response['ticket'],
"subject":
claims['cognito:username'],
"sub":
claims['sub']
})
if authrazition_issue_response[
'resultCode'] == AUTHLETE_AUTHORIZATION_ISSUE_SUBJECT_DOES_NOT_CONTAIN:
return response_builder(
400, {
'error_message':
strip_authlete_code(authrazition_response['resultMessage'])
})
if authrazition_issue_response[
'resultCode'] != AUTHLETE_AUTHORIZATION_SUCCESS_CODE:
return response_builder(500,
{'error_message': 'Internal Server Error'})
except AuthleteApiError as e:
logger.error(e)
return response_builder(500,
{'error_message': 'Internal Server Error'})
except ValidationError as e:
return response_builder(e.status_code, {'error_message': e.message})
return response_builder(
200, {'redirect_uri': authrazition_issue_response['responseContent']})