def register_courier():
if request.method == 'OPTIONS':
return send_allowed(['POST'])
else:
data = request.get_json()
email = data['email']
company = data['company']
phone = data['phone']
password = data['password']
password_rep = data['password_rep']
login = data['login']
if None in [email, company, phone, password, login]:
res = make_response(
Document(data={
'status': 'fail',
'message': 'Some arguments are missing :('
}).to_json(), 400)
elif password != password_rep:
res = make_response(
Document(data={
'status': 'fail',
'message': 'Passwords don\'t match :('
}).to_json(), 400)
else:
save_courier(login, email, company, phone, password)
correct_data = {
'status': 'success',
'message': 'Registered successfully, now please log in'
}
res = make_response(Document(data=correct_data).to_json(), 201)
res.headers['Content-Type'] = "application/json"
return res
def test_should_append_embedded_document():
app = flask.Flask(__name__)
with app.test_request_context("/entity/231"):
document = Document(
embedded={
"orders": Embedded(
embedded={"details": Embedded(data={"details": {}})},
links=link.Collection(link.Link("foo", "www.foo.com"), link.Link("boo", "www.boo.com")),
data={"total": 30},
)
},
data={"currentlyProcessing": 14},
)
expected = {
"_links": {"self": {"href": flask.request.path}},
"_embedded": {
"orders": {
"_links": {"foo": {"href": "www.foo.com"}, "boo": {"href": "www.boo.com"}},
"_embedded": {"details": {"details": {}}},
"total": 30,
}
},
"currentlyProcessing": 14,
}
assert expected == document.to_dict()
def add_user():
if request.method == 'OPTIONS':
return allowed_methods(['POST'])
firstname = request.json.get('firstname')
lastname = request.json.get('lastname')
username = request.json.get('username')
password = request.json.get('password')
email = request.json.get('email')
address = request.json.get('address')
pl = 'ąćęłńóśźż'
PL = 'ĄĆĘŁŃÓŚŹŻ'
if not re.compile(f'[A-Z{PL}][a-z{pl}]+').match(firstname):
return create_message_response("Invalid firstname", 400)
if not re.compile(f'[A-Z{PL}][a-z{pl}]+').match(lastname):
return create_message_response("Invalid lastname", 400)
if not re.compile('[a-z]{3,12}').match(username):
return create_message_response("Invalid username", 400)
if not re.compile('.{8,}').match(password.strip()):
return create_message_response("Invalid password", 400)
if not re.compile(
'(?:[A-Za-z0-9!#$%&\'*+/=?^_`{|}~-]+(?:\\.[A-Za-z0-9!#$%&\'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?\\.)+[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[A-Za-z0-9-]*[A-Za-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\\])'
).match(email.strip()):
return create_message_response("Invalid email", 400)
if address is None:
return create_message_response("Empty address", 400)
if user_exists(username):
return create_message_response("Username already exists", 400)
if not save_user(username, firstname, lastname, address, password, email):
return create_message_response("An error occurred", 500)
links = [Link('next', '/auth/login')]
data = {'message': 'Account created'}
document = Document(data=data, links=links)
return document.to_json()
def test_data_in_embedded_can_be_array():
app = flask.Flask(__name__)
with app.test_request_context("/entity/231"):
document = Document(
embedded={
"order": Embedded(
data=[
{"total": 30.00, "currency": "USD", "status": "shipped"},
{"total": 20.00, "currency": "USD", "status": "processing"},
]
)
},
data={"currentlyProcessing": 14},
)
expected = {
"currentlyProcessing": 14,
"_links": {"self": {"href": u"/entity/231"}},
"_embedded": {
"order": [
{"total": 30.00, "currency": "USD", "status": "shipped"},
{"total": 20.00, "currency": "USD", "status": "processing"},
]
},
}
assert expected == document.to_dict()
def change_status(id):
if g.username != COURIER_NAME:
return error("Unauthorized", "Brak dostępu.", 401)
json_data = request.json
if not json_data:
return error("No JSON provided",
"Niepoprawne żądanie, brak zawartości JSON.")
status = json_data.get("status")
if status not in ["label", "in transit", "delivered", "collected"]:
return error("Invalid status type", "Nieprawidłowy status paczki.")
package = "package:" + id
if not db.hexists(package, "status"):
return error("Package not found",
"Nie znaleziono paczki o danym identyfikatorze.")
if status != db.hget(package, "status"):
sender = db.hget(package, "sender")
recipient = db.hget(package, "recipient")
box_id = db.hget(package, "box_id")
db.publish(
f"user:{sender}",
f"Nowy status paczki dla adresata '{recipient}', nadanej do skrytki numer {box_id}!\nOdśwież stronę, aby zobaczyć zmiany."
)
db.hset(package, "status", status)
links = [Link("packages", "/courier/packages")]
document = Document(data={"package": db.hgetall(package)}, links=links)
return document.to_json()
def sign_in():
if request.method == "OPTIONS":
return send_allowed(['GET', 'POST'])
elif request.method == "GET":
return render_template("login.html", user=g.user)
else:
data = request.get_json()
login = data.get('login')
password = data.get('password')
if None in [login, password] or verify_user(login, password) is False:
res = make_response(
Document(
data={
'status': 'fail',
'message': 'Invalid credentials',
'data': data
}).to_json(), 400)
else:
encoded_jwt = get_jwt_payload(login, 'sender')
res = make_response(
Document(
data={
'status': 'success',
'message': 'Logged in sucessfully!',
'token': encoded_jwt.decode()
}).to_json(), 200)
res.set_cookie('token',
encoded_jwt.decode(),
secure=True,
httponly=True,
path="/")
res.headers['Content-Type'] = "application/json"
return res
def sender_get_label(label_uuid):
if request.method == 'OPTIONS':
return allowed_methods(['GET', 'PUT', 'DELETE'])
if g.authorization is None:
return create_message_response("Unauthorized", 401)
if not db.hexists(f"label:{label_uuid}", "size"):
return create_message_response("Label not Found", 404)
username = g.authorization.get('sub')
if not g.authorization.get('role') == 'courier' or db.hget(
f"label:{label_uuid}", "sender").decode() == username:
return create_message_response("Label not found", 404)
receiver = db.hget(f"label:{label_uuid}", "receiver").decode()
size = db.hget(f"label:{label_uuid}", "size").decode()
po_box_id = db.hget(f"label:{label_uuid}", "POBoxId").decode()
sent = db.hget(f"label:{label_uuid}", "sent").decode()
data = {
"labelId": label_uuid,
"username": username,
"receiver": receiver,
"size": size,
"POBoxId": po_box_id,
"sent": sent
}
links = [Link('self', '/labels/' + label_uuid)]
document = Document(data=data, links=links)
return document.to_json()
def package_create():
if g.authorization is None or g.authorization.get('role') != 'courier':
return create_message_response("Unauthorized", 401)
label_id = request.json.get('labelId')
if not db.hexists(f"label:{label_id}", "size"):
return create_message_response("Label not Found", 404)
if not db.hget(f"label:{label_id}", "sent").decode() == 'false':
return create_message_response("Label already sent", 400)
db.hset(f"label:{label_id}", "sent", 'true')
package_id = str(uuid.uuid4())
db.hset(f"package:{package_id}", "packageId", f"{package_id}")
db.hset(f"package:{package_id}", "labelId", f"{label_id}")
db.hset(f"package:{package_id}", "status", "IN_TRANSIT")
data = {
"packageId": package_id,
"labelId": label_id,
"status": "IN_TRANSIT"
}
links = [Link('self', '/packages/{id}', templated=True)]
document = Document(embedded={'data': Embedded(data=data)}, links=links)
return document.to_json()
def add_label():
if g.authorization is None:
return create_message_response("Unauthorized", 401)
sender = g.authorization.get('sub')
size = request.json.get('size')
addressee = request.json.get('addressee')
po_box_id = request.json.get('POBoxId')
if addressee is None:
return create_message_response("Invalid addressee", 400)
if size not in ('XS', 'S', 'M', 'L', 'XL'):
return create_message_response("Invalid size", 400)
if po_box_id is None:
return create_message_response("Invalid PO box id", 400)
label_id = uuid.uuid4()
db.hset(f"label:{label_id}", "sender", f"{sender}")
db.hset(f"label:{label_id}", "addressee", f"{addressee}")
db.hset(f"label:{label_id}", "size", f"{size}")
db.hset(f"label:{label_id}", "POBoxId", f"{po_box_id}")
db.hset(f"label:{label_id}", "sent", "false")
data = {
"id": str(label_id),
"sender": sender,
"addressee": addressee,
"size": size,
"POBoxId": po_box_id,
"sent": "false"
}
links = [Link('self', '/labels/' + str(label_id))]
document = Document(data=data, links=links)
return document.to_json()
def get_labels_by_sender():
if g.authorization is None:
return create_message_response("Unauthorized", 401)
username = g.authorization.get('sub')
keys = db.keys(pattern='label*')
data = []
label_json = {}
for key in keys:
sender = db.hget(key, "sender").decode()
if username == sender or g.authorization.get('role') == 'courier':
label_id = key.decode().split(":")[1]
link = Link('self', '/labels/' + label_id)
addressee = db.hget(key, "addressee").decode()
size = db.hget(key, "size").decode()
po_box_id = db.hget(key, "POBoxId").decode()
sent = db.hget(key, "sent").decode()
label_json = {
"id": label_id,
"sender": sender,
"addressee": addressee,
"size": size,
"poBox": po_box_id,
"sent": sent,
}
data.append(Embedded(data=label_json, links=[link]))
links = [Link('self', '/labels/{id}', templated=True)]
document = Document(embedded={'data': Embedded(data=data)}, links=links)
return document.to_json()
def delete_sender_package(username, id):
if username != g.get("username") or g.get("username") == COURIER_NAME:
return error("Unauthorized", "Brak dostępu.", 401)
is_package_sender = db.sismember(f"user_packages:{username}",
f"package:{id}")
if not db.hget(f"package:{id}", "recipient"):
return error("Package not found", "Nie znaleziono paczki")
if not is_package_sender:
return error("Unauthorized", "Brak dostępu.", 401)
if not db.hget(f"package:{id}", "status") == "label":
return error("Package in transit cannot be deleted",
"Nie można usunąć, paczka jest już w drodze.")
db.srem(f"user_packages:{username}", f"package:{id}")
db.delete(f"package:{id}")
log("Deleted package: " + id + " from sender: " + username)
links = [Link("package:create", "/sender/" + g.username + "/packages")]
document = Document(data={"status": "ok"}, links=links)
return document.to_json()
def login_courier():
if request.method == 'OPTIONS':
return send_allowed(['POST'])
else:
data = request.get_json()
login = data['login']
password = data['password']
if None in [login, password] or "" in [login, password]:
res = make_response(
Document(data={
'status': 'fail',
'message': 'Some arguments are missing :('
}).to_json(), 400)
elif verify_user(login, password, 'courier'):
res_correct = {
'status': 'success',
'message': 'Logged in correctly',
'token': get_jwt_payload(login, 'courier').decode()
}
res = make_response(Document(data=res_correct).to_json(), 200)
else:
res = make_response(
Document(data={
'status': 'fail',
'message': 'Invalid credentials :('
}).to_json(), 400)
res.headers['Content-Type'] = "application/json"
return res
def register():
data = request.json
if not data:
return {"error": "No JSON provided"}, 400
names_and_errors = {
"username": "******",
"firstname": "imienia",
"lastname": "nazwiska",
"email": "adresu email",
"address": "adresu",
"password": "******",
"password2": "potwierdzenia hasła"
}
errors = []
errors_pl = []
fields = {}
for name in names_and_errors:
fields[name] = data.get(name)
if not fields[name]:
errors.append("No " + name + " provided.")
errors_pl.append(f"Nie podano {names_and_errors[name]}.")
if fields["password"] != fields["password2"]:
errors.append("Passwords does not match")
errors_pl.append("Hasła nie są takie same.")
if fields["username"] and not re.fullmatch(r"^[a-z]{3,20}",
fields["username"]):
errors.append("Username must contain only 3-20 lowercase letters")
errors_pl.append(
"Nazwa użytkownika musi składać się z 3-20 małych liter.")
if fields["username"] and db.hexists(f"user:{fields['username']}",
"password"):
errors.append("Username is taken")
errors_pl.append("Nazwa użytkownika jest zajęta.")
if len(errors) > 0:
return error(errors, errors_pl)
db.hset(f"user:{fields['username']}", "firstname", fields["firstname"])
db.hset(f"user:{fields['username']}", "lastname", fields["lastname"])
db.hset(f"user:{fields['username']}", "address", fields["address"])
db.hset(f"user:{fields['username']}", "email", fields["email"])
password = fields["password"].encode()
hashed = hashpw(password, gensalt(5))
db.hset(f"user:{fields['username']}", "password", hashed)
db.sadd("users", fields["username"])
links = [Link("sender:login", "/sender/login")]
document = Document(links=links)
return document.to_json(), 201
def sign_up():
if request.method == "OPTIONS":
return send_allowed(['GET', 'POST'])
elif request.method == "GET":
return render_template("register.html", user=g.user)
else:
data = request.get_json()
firstname = data.get("firstname")
lastname = data.get("lastname")
login = data.get("login")
password = data.get("password")
rep_password = data.get("rep_password")
email = data.get("email")
address = data.get("address")
if None in [firstname, lastname, login, password, email, address]:
res = make_response(
Document(
data={
'status': 'fail',
"message": 'Invalid data -- some fields are empty.'
}).to_json(), 400)
elif password != rep_password:
res = make_response(
Document(data={
'status': 'fail',
"message": "Passwords don't match."
}).to_json(), 400)
elif not check_username_available(login):
res = make_response(
Document(data={
'status': 'fail',
'message': 'Login taken, silly :)'
}).to_json(), 400)
elif save_user(firstname, lastname, email, password, login, address):
res = make_response(
Document(
data={
'status': 'success',
'message':
'Successfully registered. Now please log in.'
}).to_json(), 201)
else:
res = make_response(
Document(
data={
'status': 'fail',
'message':
'Did not register, unknown error happened o_O'
}).to_json(), 400)
res.headers['Content-Type'] = "application/json"
return res
def label_delete(label_uuid):
if g.authorization is None:
return create_message_response("Unauthorized", 401)
username = g.authorization.get('sub')
if not db.hexists(f"label:{label_uuid}", "size"):
return create_message_response("Label not Found", 404)
if not db.hget(f"label:{label_uuid}", "sender").decode() == username:
return create_message_response("Label not found", 404)
db.delete(f"label:{label_uuid}")
link = [Link('all', '/labels')]
document = Document(embedded={'data': Embedded(data={})}, links=link)
return document.to_json()
def root():
if request.method == 'OPTIONS':
return allowed_methods(['GET'])
links = [
Link('auth', '/auth'),
Link('labels', '/sender'),
Link('packages', '/packages')
]
# if g.authorization is None:
# links.append(Link('test', '/test'))
document = Document(data={}, links=links)
return document.to_json()
def before():
token = request.headers.get("Authorization", "").replace("Bearer ", "")
if token is not None:
try:
g.authorization = decode(token, str(JWT_SECRET), algorithms=["HS256"])
except ExpiredSignatureError:
links = [Link("login", "sender/login")]
document = Document(links=links)
return document.to_json(), 440
except Exception as e:
g.authorization = {}
else:
g.authorization = {}
def update_parcel_status(parcel_id):
try:
if g.user is not {} and g.user['role'] == 'courier':
if request.method == 'OPTIONS':
return send_allowed(['PUT'])
else:
parent_link = [Link('parcel:parent', '/courier/parcels')]
data = request.get_json()
sender_login = data['sender']
current_parcel = db.hget(f"user:{sender_login}:parcel",
f"parcel_{parcel_id}")
if current_parcel is not None:
db.hdel(f"user:{sender_login}:parcel",
f"parcel_{parcel_id}")
current_parcel = json.loads(current_parcel.decode())
current_parcel['status'] = data['status']
db.hset(f"user:{sender_login}:parcel",
f"parcel_{parcel_id}", json.dumps(current_parcel))
res = make_response(
Document(data={
'status': 'success',
'message': 'Parcel updated successfully'
},
links=parent_link).to_json(), 200)
else:
res = make_response(
Document(data={
'status': 'fail',
'message': 'Requested package not found.'
},
links=parent_link).to_json(), 400)
else:
res = make_response(
Document(
data={
'status': 'fail',
'message': 'You\'re not allowed to view this page.'
}).to_json(), 401)
except Exception as e:
print(e)
res = make_response(
Document(
data={
'status': 'fail',
'message': 'You\'re not allowed to view this page.'
}).to_json(), 401)
res.headers['Content-Type'] = "application/json"
return res
def version_detail(name):
version = Version.objects.get(version=name)
links = [Link(rel, url) for (rel, url) in version.binaries.items()]
return Document(data={
'version': version.version
},
links=Collection(*links)).to_dict()
def package_get(package_id):
if request.method == 'OPTIONS':
return allowed_methods(['GET', 'PUT'])
if g.authorization is None or g.authorization.get('role') == 'courier':
return create_message_response("Unauthorized", 401)
if not db.hexists(f"package:{package_id}", "labelId"):
return create_message_response("Package not found", 404)
label_id = db.hget(f"package:{package_id}", "labelId").decode()
status = db.hget(f"package:{package_id}", "status").decode()
data = {"packageId": package_id, "labelId": label_id, "status": status}
links = [Link('self', '/packages/' + package_id)]
document = Document(data=data, links=links)
return document.to_json()
def send_allowed(methods):
if 'OPTIONS' not in methods:
methods.append("OPTIONS")
response = make_response(Document().to_json(), 204)
response.headers['Allow'] = ', '.join(methods)
return response
def get(self, database_name, table_name):
try:
connection.select_db(database_name)
cursor = connection.cursor()
cursor.execute(f'select * from {table_name}')
return Document(data={'rows': list(cursor.fetchall())}).to_dict()
except Exception as e:
raise InvalidUsage(str(e), 400)
def courier_packages():
if g.username != COURIER_NAME:
return error("Unauthorized", "Brak dostępu.", 401)
packages = []
for user in db.smembers("users"):
for package_name in db.smembers(f"user_packages:{user}"):
package = db.hgetall(package_name)
package["id"] = package_name.replace("package:", "")
package["sender"] = user
packages.append(package)
links = [
Link("package:update_status", "/courier/packages/{id}", templated=True)
]
document = Document(data={"packages": packages}, links=links)
return document.to_json()
def get_package_list():
try:
if g.user is not {} and g.user['role'] == 'courier':
if request.method == 'OPTIONS':
return send_allowed(['GET'])
else:
parcel_keys = db.keys("user:*:parcel")
decoded_parcels = []
links = []
for parcel_key in parcel_keys:
parcel_key = parcel_key.decode()
parcel_list = db.hgetall(parcel_key)
for parcel in parcel_list:
decoded_parcel = json.loads(
parcel_list[parcel].decode("UTF-8"))
sender = parcel_key.replace('user:'******'') # strip beginning
sender = sender.replace(':parcel', '') # strip end
decoded_parcel['sender'] = sender
decoded_parcels.append(decoded_parcel)
links.append(
Link(f'parcel:{decoded_parcel["id"]}',
f"/courier/package/{decoded_parcel['id']}"))
res = make_response(
Document(data={
'status': 'success',
'parcels': decoded_parcels
},
links=links).to_json(), 200)
else:
res = make_response(
Document(
data={
'status': 'fail',
'message': 'You\'re not allowed to view this page.'
}).to_json(), 401)
except Exception as e:
print(e)
res = make_response(
Document(
data={
'status': 'fail',
'message': 'You\'re not allowed to view this page.'
}).to_json(), 401)
res.headers['Content-Type'] = "application/json"
return res
def delete(self, database_name):
try:
cursor = connection.cursor()
cursor.execute(f'DROP DATABASE {database_name}')
return Document(data={
'message': 'Database deleted successfully'
}).to_dict()
except Exception as e:
raise InvalidUsage(str(e), 400)
def package_update(package_id):
if request.method == 'OPTIONS':
return allowed_methods(['GET', 'PUT'])
if g.authorization is None or g.authorization.get('role') != 'courier':
return create_message_response("Unauthorized", 401)
if not db.hexists(f"package:{package_id}", "labelId"):
return create_message_response("Package not found", 404)
status = request.json.get('status')
if status not in ('IN_TRANSIT', 'DELIVERED', 'PICKED_UP'):
return create_message_response("Invalid status", 400)
db.hset(f"package:{package_id}", "status", status)
label_id = db.hget(f"package:{package_id}", "labelId").decode()
data = {"packageId": package_id, "labelId": label_id, "status": status}
links = [Link('self', '/packages/' + package_id)]
document = Document(data=data, links=links)
return document.to_json()
def login():
json = request.json
if not json:
return {"error": "No JSON provided"}, 400
username = json.get("username")
password = json.get("password")
db_password = db.hget(f"user:{username}", "password")
if not username:
return error("No username provided",
"Nazwa użytkownika nie może być pusta.")
if not password:
return error("No password provided", "Hasło nie może być puste.")
if not db_password:
return error("Invalid username", "Nieprawidłowa nazwa użytkownika.")
if not checkpw(password.encode(), db_password.encode()):
return error("Invalid password", "Nieprawidłowe hasło.")
log("Logged in user " + username)
payload = {
"exp": datetime.utcnow() + timedelta(seconds=JWT_LIFETIME),
"iat": datetime.utcnow(),
"sub": username
}
token = encode(payload, str(JWT_SECRET), algorithm="HS256")
links = [
Link("sender:dashboard", "/sender/dashboard"),
Link("sender:logout", "/sender/logout")
]
document = Document(data={
"status": "logged-in",
"token": token
},
links=links)
return document.to_json()
def get(self):
cursor = connection.cursor()
cursor.execute('show databases')
databases = list(map(lambda x: x[0], cursor.fetchall()))
links = list()
for database in databases:
links.append(link.Link(database, f'/mysql/database/{database}'))
return Document(data={
'databases': databases
},
links=link.Collection(*links)).to_dict()
def delete(self, database_name, table_name):
try:
connection.select_db(database_name)
cursor = connection.cursor()
where = request.args.get('where')
cursor.execute(f'delete from {table_name} where {where}')
return Document(data={
'message': 'Rows deleted successfully'
}).to_dict()
except Exception as e:
raise InvalidUsage(str(e), 400)
def post(self, database_name, table_name):
try:
connection.select_db(database_name)
cursor = connection.cursor()
values = request.args.get('values')
cursor.execute(f"insert into {table_name} VALUES ({values})")
return Document(data={
'message': 'Row inserted successfully'
}).to_dict()
except Exception as e:
raise InvalidUsage(str(e), 400)
def delete(self, database_name, table_name):
try:
connection.select_db(database_name)
cursor = connection.cursor()
cursor.execute(f'drop table {table_name}')
return Document(
data={
'message': f'Table {table_name} dropped successfully'
}).to_dict()
except Exception as e:
raise InvalidUsage(str(e), 400)
def post(self, database_name, table_name):
try:
connection.select_db(database_name)
cursor = connection.cursor()
description = request.args.get('description')
cursor.execute(f'create table {table_name} ({description})')
return Document(data={
'message': 'Table created successfully'
}).to_dict()
except Exception as e:
raise InvalidUsage(str(e), 400)
def test_data_in_embedded_can_be_array_of_documents():
app = flask.Flask(__name__)
with app.test_request_context("/entity/231"):
document = Document(
embedded={
"order": Embedded(
data=[
Embedded(
data={"total": 30.00, "currency": "USD", "status": "shipped"},
links=link.Collection(link.Link("foo", "www.foo30.com"), link.Link("boo", "www.boo30.com")),
),
Embedded(
data={"total": 20.00, "currency": "USD", "status": "processing"},
links=link.Collection(link.Link("foo", "www.foo20.com"), link.Link("boo", "www.boo20.com")),
),
]
)
},
data={"currentlyProcessing": 14},
)
expected = {
"currentlyProcessing": 14,
"_links": {"self": {"href": u"/entity/231"}},
"_embedded": {
"order": [
{
"_links": {"foo": {"href": "www.foo30.com"}, "boo": {"href": "www.boo30.com"}},
"total": 30.00,
"currency": "USD",
"status": "shipped",
},
{
"_links": {"foo": {"href": "www.foo20.com"}, "boo": {"href": "www.boo20.com"}},
"total": 20.00,
"currency": "USD",
"status": "processing",
},
]
},
}
assert expected == document.to_dict()
def test_data_in_embedded_can_be_array():
app = flask.Flask(__name__)
with app.test_request_context('/entity/231'):
document = Document(
embedded={
'order': Embedded(
data=[
{
'total': 30.00,
'currency': 'USD',
'status': 'shipped'
}, {
'total': 20.00,
'currency': 'USD',
'status': 'processing'
}
]
)
},
data={
'currentlyProcessing': 14
}
)
expected = {
'currentlyProcessing': 14,
'_links': {'self': {'href': u'/entity/231'}},
'_embedded': {
'order': [{
'total': 30.00,
'currency': 'USD',
'status': 'shipped'
}, {
'total': 20.00,
'currency': 'USD',
'status': 'processing'
}]
}
}
assert expected == document.to_dict()
def test_should_append_embedded_document():
app = flask.Flask(__name__)
with app.test_request_context('/entity/231'):
document = Document(
embedded={
'orders': Embedded(
embedded={'details': Embedded(
data={'details': {}}
)},
links=link.Collection(
link.Link('foo', 'www.foo.com'),
link.Link('boo', 'www.boo.com')
),
data={'total': 30},
)
},
data={'currentlyProcessing': 14}
)
expected = {
'_links': {
'self': {
'href': flask.request.path
}
},
'_embedded': {
'orders': {
'_links': {
'foo': {'href': 'www.foo.com'},
'boo': {'href': 'www.boo.com'}
},
'_embedded': {
'details': {'details': {}}
},
'total': 30,
}
},
'currentlyProcessing': 14
}
assert expected == document.to_dict()
def test_empty_document_to_json():
app = flask.Flask(__name__)
with app.test_request_context("/foo/23"):
document = Document()
expected = '{"_links": {"self": {"href": "/foo/23"}}}'
assert expected == document.to_json()
