def post_get_vinyl():
if request.method == "POST":
if not request.data:
return create_return(status_400(), 400)
vinyl_info = vinyl_information(request.get_json())
if not vinyl_info:
return create_return(status_400(), 400)
vinyl_info["crate"] = None
return create_return(
json.dumps(
new_object(vinyl_info, vinyl, datastore_client,
request.url_root)), 201)
if request.method == "GET":
query = datastore_client.query(kind=vinyl)
collection_size = len(list(query.fetch()))
q_offset = int(request.args.get('offset', 0))
vinyl_iterator = query.fetch(limit=paginate_limit, offset=q_offset)
pages = vinyl_iterator.pages
results = list(next(pages))
for result in results:
result["id"] = str(result.key.id)
result["self"] = object_self(result.key.id, crates,
request.url_root)
if result["crate"] is not None:
crate_key = datastore_client.key(crates,
int(result["crate"]["id"]))
crate = datastore_client.get(crate_key)
crate["id"] = crate.key.id
crate["self"] = object_self(crate.key.id, crates,
request.url_root)
crate.pop("vinyl", None)
result["crate"] = crate
return_info = {"vinyl": results, "collection_size": collection_size}
if vinyl_iterator.next_page_token:
next_offset = q_offset + paginate_limit
next_url = request.base_url + "?offset=" + str(next_offset)
return_info["next"] = next_url
return create_return(json.dumps(return_info), 200)
def post_crates():
if request.method == "POST":
# Verify user
verified = verify(request.headers)
if verified == -1:
return create_return(status_401(), 401)
if not request.data:
return create_return(status_400(), 400)
crate_info = crate_information(request.get_json())
if not crate_info:
return create_return(status_400(), 400)
crate_info["owner"] = verified
crate_info["vinyl"] = []
return create_return(
json.dumps(
new_object(crate_info, crates, datastore_client,
request.url_root)), 201)
if request.method == "GET":
# Verify user but don't return error
verified = verify(request.headers)
# Get crates belonging to this user
query = datastore_client.query(kind=crates)
query.add_filter("owner", "=", str(verified))
collection_size = len(list(query.fetch()))
q_offset = int(request.args.get('offset', 0))
crate_iterator = query.fetch(limit=paginate_limit, offset=q_offset)
pages = crate_iterator.pages
results = list(next(pages))
for result in results:
# Format Vinyl for Crate
vinyl_in_crate(result, datastore_client, request.url_root)
return_info = {"crates": results, "collection_size": collection_size}
if crate_iterator.next_page_token:
next_offset = q_offset + paginate_limit
next_url = request.base_url + "?offset=" + str(next_offset)
return_info["next"] = next_url
return create_return(json.dumps(return_info), 200)
def get_users():
query = datastore_client.query(kind=users)
results = list(query.fetch())
for result in results:
result["id"] = result.pop("sub")
return create_return(
json.dumps({
"users": results,
"collection_size": len(results)
}), 200)
def withdraw_vinyl(crate_id, vinyl_id):
# Verify user
verified = verify(request.headers)
if verified == -1:
return create_return(status_401(), 401)
# Get crate and vinyl
# Get the vinyl
vinyl_key = datastore_client.key(vinyl, int(vinyl_id))
vinyl_record = datastore_client.get(key=vinyl_key)
crate_key = datastore_client.key(crates, int(crate_id))
crate = datastore_client.get(key=crate_key)
if crate is None or vinyl_record is None:
return create_return(status_404_store(), 404)
# Verify user is owner of crate
if crate["owner"] != str(verified):
return create_return(status_403(), 403)
record_found = False
# Remove relationship
for i in range(len(crate["vinyl"])):
if crate["vinyl"][i]["id"] == str(vinyl_id):
crate["vinyl"].pop(i)
crate.update(crate)
datastore_client.put(crate)
record_found = True
break
if not record_found:
return create_return(status_400_withdraw(), 400)
vinyl_record["crate"] = None
vinyl_record.update(vinyl_record)
datastore_client.put(vinyl_record)
return create_return("", 204)
def store_vinyl(crate_id, vinyl_id):
# Verify user
verified = verify(request.headers)
if verified == -1:
return create_return(status_401(), 401)
# Get crate and vinyl
# Get the vinyl
vinyl_key = datastore_client.key(vinyl, int(vinyl_id))
vinyl_record = datastore_client.get(key=vinyl_key)
crate_key = datastore_client.key(crates, int(crate_id))
crate = datastore_client.get(key=crate_key)
if crate is None or vinyl_record is None:
return create_return(status_404_store(), 404)
# Verify user is owner of crate
if crate["owner"] != str(verified):
return create_return(status_403(), 403)
# Verify vinyl does not have crate
if vinyl_record["crate"] is not None:
return create_return(status_400_store(), 400)
# Verify capacity constraints
if len(crate["vinyl"]) + 1 > crate["capacity"]:
return create_return(status_400_store(), 400)
# Add vinyl to crate
crate["vinyl"].append({"id": str(vinyl_record.key.id)})
crate.update(crate)
datastore_client.put(crate)
# Add crate to vinyl
vinyl_record["crate"] = {"id": str(crate.key.id)}
vinyl_record.update(vinyl_record)
datastore_client.put(vinyl_record)
# Return 204
return create_return("", 204)
def method_not_allowed(e):
return create_return(status_405(), 405)
def request_checks():
mimetype_dict = dict(request.accept_mimetypes)
if json_mimetype not in mimetype_dict and all_mimetype not in mimetype_dict:
return create_return(status_406(), 406)
def get_patch_put_delete_vinyl_vinylid(vinyl_id):
# Get the vinyl
vinyl_key = datastore_client.key(vinyl, int(vinyl_id))
vinyl_record = datastore_client.get(key=vinyl_key)
if vinyl_record is None:
return create_return(status_404(vinyl), 404)
crate = None
# If record in crate get crate information
if vinyl_record["crate"] is not None:
crate_key = datastore_client.key(crates,
int(vinyl_record["crate"]["id"]))
crate = datastore_client.get(crate_key)
crate["self"] = object_self(crate.key.id, crates, request.url_root)
crate["id"] = str(crate.key.id)
# vinyl_record["crate"] = crate
if request.method == "PATCH":
# Verify the user if the vinyl is in a crate
if vinyl_record["crate"] is not None:
verified = verify(request.headers)
if verified == -1:
return create_return(status_401(), 401)
if crate["owner"] != str(verified):
return create_return(status_403(), 403)
if not request.data:
return create_return(status_400(), 400)
vinyl_attributes = vinyl_information_indiv(request.get_json())
if not vinyl_attributes:
return create_return(status_400(), 400)
vinyl_record.update(vinyl_attributes)
datastore_client.put(vinyl_record)
if request.method == "PUT":
if vinyl_record["crate"] is not None:
verified = verify(request.headers)
if verified == -1:
return create_return(status_401(), 401)
if crate["owner"] != str(verified):
return create_return(status_403(), 403)
if not request.data:
return create_return(status_400(), 400)
vinyl_attributes = vinyl_information(request.get_json())
if not vinyl_attributes:
return create_return(status_400(), 400)
vinyl_record.update(vinyl_attributes)
datastore_client.put(vinyl_record)
vinyl_record["id"] = vinyl_record.key.id
vinyl_record["self"] = object_self(vinyl_record.key.id, vinyl,
request.url_root)
if crate is not None:
crate.pop("vinyl", None)
vinyl_record["crate"] = crate
# For records in vinyl
# Return 303
res = make_response(vinyl_record)
res.status_code = 303
res.headers.set("Location", vinyl_record["self"])
return res
if request.method == "DELETE":
# Delete vinyl
if vinyl_record["crate"] is not None:
verified = verify(request.headers)
if verified == -1:
return create_return(status_401(), 401)
if crate["owner"] != str(verified):
return create_return(status_403(), 403)
for i in range(len(crate["vinyl"])):
if crate["vinyl"][i]["id"] == str(vinyl_id):
crate["vinyl"].pop(i)
crate.update(crate)
datastore_client.put(crate)
break
datastore_client.delete(vinyl_key)
return create_return("", 204)
# Fall through for GET and PATCH
vinyl_record["id"] = str(vinyl_record.key.id)
vinyl_record["self"] = object_self(vinyl_record.key.id, vinyl,
request.url_root)
if crate is not None:
crate.pop("vinyl", None)
vinyl_record["crate"] = crate
return create_return(json.dumps(vinyl_record), 200)
def get_delete_patch_put_crate_crateid(crate_id):
# Verify user
verified = verify(request.headers)
if verified == -1:
return create_return(status_401(), 401)
# Get crate
crate_key = datastore_client.key(crates, int(crate_id))
crate = datastore_client.get(key=crate_key)
if crate is None:
return create_return(status_404("crate"), 404)
# Verify ownership
if crate["owner"] != str(verified):
return create_return(status_403(), 403)
if request.method == "DELETE":
# Delete crate
for record in crate["vinyl"]:
# Get vinyl and remove the crate
vinyl_key = datastore_client.key(vinyl, int(record["id"]))
vinyl_record = datastore_client.get(key=vinyl_key)
vinyl_record["crate"] = None
vinyl_record.update(vinyl_record)
datastore_client.put(vinyl_record)
datastore_client.delete(crate_key)
return create_return("", 204)
if request.method == "PATCH":
if not request.data:
return create_return(status_400(), 400)
crate_attributes = crate_information_indiv(request.get_json())
if not crate_attributes:
return create_return(status_400(), 400)
crate.update(crate_attributes)
datastore_client.put(crate)
if request.method == "PUT":
if not request.data:
return create_return(status_400(), 400)
crate_attributes = crate_information(request.get_json())
if not crate_attributes:
return create_return(status_400(), 400)
crate.update(crate_attributes)
datastore_client.put(crate)
vinyl_in_crate(crate, datastore_client, request.url_root)
# Return 303
res = make_response(crate)
res.status_code = 303
res.headers.set("Location", crate["self"])
return res
# Fall through for requests that return 200 response (GET and PATCH)
vinyl_in_crate(crate, datastore_client, request.url_root)
return create_return(json.dumps(crate), 200)