def create_audio():
if request.method == 'POST':
data = []
try:
file_type = request.form.get('audioFileType')
metadata = json.loads(request.form.get('audioFileMetadata'))
if file_type == 'song':
data = Song(**metadata)
elif file_type == 'audiobook':
data = AudioBook(**metadata)
elif file_type == 'podcast':
if len(metadata['participants']) > 10:
metadata['participants'] = []
data = Podcast(**metadata)
db.session.add(data)
db.session.commit()
output = api_response(data.serialize())
return jsonify(output.true_output()), 200
except Exception as error:
logging.error([error])
output = api_response(data)
return jsonify(output.error_output()), 400
else:
return jsonify(success=False), 500
def update_audio(audioFileType, audioFileID):
if request.method == 'PUT':
metadata = []
try:
metadata = json.loads(request.form.get('audioFileMetadata'))
if audioFileType == 'song':
instance = Song.query.filter(Song.id == audioFileID)
instance.update(dict(metadata))
elif audioFileType == 'audiobook':
instance = AudioBook.query.filter(AudioBook.id == audioFileID)
instance.update(dict(metadata))
elif audioFileType == 'podcast':
instance = Podcast.query.filter(Podcast.id == audioFileID)
if len(metadata['participants']) > 10:
metadata['participants'] = []
instance.update(dict(metadata))
db.session.commit()
output = api_response(metadata)
return jsonify(output.true_output()), 200
except Exception as error:
logging.error([error])
output = api_response(metadata)
return jsonify(output.error_output()), 400
else:
return jsonify(success=False), 500
def main(user_id):
response = api_response()
res = query_ownership_train_cars(depot_table_name, user_id)
response.body = res
return response.format()
def main():
response = api_response()
master_data = {}
for table_name in master_table_list:
data_list = fetch_master_data(table_name)
master_data[table_name] = data_list
response.body = master_data
return response.format()
def get_audio(audioFileType, audioFileID):
output = []
if request.method == 'GET':
instance = []
try:
if audioFileType == 'song':
instance = Song.query.filter(Song.id == audioFileID).first()
elif audioFileType == 'audiobook':
instance = AudioBook.query.filter(
AudioBook.id == audioFileID).first()
elif audioFileType == 'podcast':
instance = Podcast.query.filter(
Podcast.id == audioFileID).first()
output = api_response(instance.serialize())
return jsonify(output.true_output()), 200
except Exception as error:
logging.error([error])
output = api_response(instance)
return jsonify(output.error_output()), 400
else:
return jsonify(success=False), 500
def main(body):
response = api_response()
verify_body_data(body)
body["train_id"] = generate_uuid()
items = generate_param_items(body)
param = {
"TableName": train_table_name,
"Item": items,
"Expected": {
"id": {
"Exists": False
}
}
}
dynamodb_client.put_item(**param)
response.body = body
return response.format()
def main(body):
response = api_response()
verify_body_data(body)
key = {"owner_id": body.pop("owner_id"), "train_id": body.pop("train_id")}
param_keys = [key for key in body.keys()]
expression_assignment = map(lambda key: f"#{key} = :{key}", param_keys)
update_expression = 'set ' + ','.join(expression_assignment)
expression_attribute_names = {f"#{v}": v for v in body.keys()}
expression_attributeValues = {f":{k}": v for k, v in body.items()}
param = {
"Key": key,
'UpdateExpression': update_expression,
'ExpressionAttributeNames': expression_attribute_names,
'ExpressionAttributeValues': expression_attributeValues,
}
depot_table.update_item(**param)
return response.format()
def api():
# check parameters
try:
start = int(self.__cfg["api"]["defaults"]["start"])
stop = int(self.__cfg["api"]["defaults"]["stop"])
to_list = self.__cfg["api"]["defaults"]["to_list"]
if 'to_list' in request.args:
to_list = True
if 'start' in request.args:
start = int(request.args["start"])
if 'stop' in request.args:
stop = int(request.args["stop"])
if abs(start - stop) <= 0:
raise ValueError
if abs(abs(start) - abs(stop)) >= int(
self.__cfg["api"]["max_fizzbuzz_amount"]):
raise ValueError
except:
self.__logger.warning(
"api request failed, wrong parameters passed")
api_resp = api_response(
self.__cfg["api"]["statuses"]["fail"],
self.__cfg["api"]["errors"]["wrong_parameter"], "")
return api_resp.get_api_response()
# handle post request for custom api response
if (request.method == 'POST'):
try:
self.__logger.info(
"custom fizzbuzz api is requested with params start:{0} stop:{1} to_list:{2}"
.format(start, stop, to_list))
# parse posted json
custom_fizzbuzz_array = json.loads(
request.data.decode('utf-8'))
# check max size for the custom array
if (len(custom_fizzbuzz_array["custom_fizzbuzz"]) > int(
self.__cfg["api"]["max_custom_fizzbuzz_amount"])):
raise ValueError
# get custom fizzbuzz
data = self.fizzbuzz.fizzbuzz_custom(custom_fizzbuzz_array,
start=start,
stop=stop,
to_list=to_list)
api_resp = api_response(
self.__cfg["api"]["statuses"]["success"], "", data)
except ZeroDivisionError:
self.__logger.warning(
"api request failed with ZeroDivisionError")
api_resp = api_response(
self.__cfg["api"]["statuses"]["fail"],
self.__cfg["api"]["errors"]["divide_by_zero"], "")
except json.decoder.JSONDecodeError:
self.__logger.warning(
"api request failed with JSONDecodeError")
api_resp = api_response(
self.__cfg["api"]["statuses"]["fail"],
self.__cfg["api"]["errors"]["json_decode_error"], "")
except ValueError:
self.__logger.warning("api request failed with ValueError")
api_resp = api_response(
self.__cfg["api"]["statuses"]["fail"],
self.__cfg["api"]["errors"]["wrong_parameter"], "")
except:
self.__logger.warning(
"api request failed with unknown error", exc_info=True)
api_resp = api_response(
self.__cfg["api"]["statuses"]["fail"],
self.__cfg["api"]["errors"]["general_error"], "")
return api_resp.get_api_response()
# handle get request for regular api response
else:
try:
self.__logger.info(
"regular fizzbuzz api is requested with params start:{0} stop:{1} to_list:{2}"
.format(start, stop, to_list))
data = self.fizzbuzz.fizzbuzz(start=start,
stop=stop,
to_list=to_list)
api_resp = api_response(
self.__cfg["api"]["statuses"]["success"], "", data)
except:
self.__logger.warning(
"api request failed with unknown error", exc_info=True)
api_resp = api_response(
self.__cfg["api"]["statuses"]["fail"],
self.__cfg["api"]["errors"]["general_error"], "")
return api_resp.get_api_response()
def get_flags():
flags = Flags(engine)
return api_response({"flags": flags.get_list()})
def post_flag():
flags = Flags(engine)
flag_ids = request.form.getlist("flags[]", None)
app_id = request.form.get("app_id", 0)
return api_response({"apps": flags.add_data(app_id, flag_ids)})
def apps_search():
apps = Apps(engine)
term = request.args.get("term", None)
return api_response({"apps": apps.search_app(term)})
def search_user(user_id):
apps = Apps(engine)
return api_response({"apps": apps.get_user(user_id)})
def search():
apps = Apps(engine)
return api_response({"apps": apps.get_recent()})
