def get(self, id_: str, path: str) -> Response:
"""
GET object with id = id_ from the database.
:param id_ : Item ID
:param path : Path for Item ( Specified in APIDoc @id)
"""
id_ = str(id_)
auth_response = check_authentication_response()
if isinstance(auth_response, Response):
return auth_response
class_type = get_doc().collections[path]["collection"].class_.title
if checkClassOp(class_type, "GET"):
# Check if class_type supports GET operation
try:
# Try getting the Item based on ID and Class type
response = crud.get(id_,
class_type,
api_name=get_api_name(),
session=get_session())
return set_response_headers(
jsonify(hydrafy(response, path=path)))
except (ClassNotFound, InstanceNotFound) as e:
status_code, message = e.get_HTTP()
return set_response_headers(jsonify(message),
status_code=status_code)
abort(405)
def delete(self, id_: str, path: str) -> Response:
"""Delete object with id=id_ from database."""
id_ = str(id_)
auth_response = check_authentication_response()
if isinstance(auth_response, Response):
return auth_response
class_type = get_doc().collections[path]["collection"].class_.title
if checkClassOp(class_type, "DELETE"):
# Check if class_type supports PUT operation
try:
# Delete the Item with ID == id_
crud.delete(id_, class_type, session=get_session())
response = {
"message":
"Object with ID {} successfully deleted".format(id_)
}
return set_response_headers(jsonify(response))
except (ClassNotFound, InstanceNotFound) as e:
status_code, message = e.get_HTTP()
return set_response_headers(jsonify(message),
status_code=status_code)
abort(405)
def delete(self, path, int_list):
"""
To delete multiple objects
:param path: endpoints
:param int_list: Optional String containing ',' separated ID's
:return:
"""
auth_response = check_authentication_response()
if isinstance(auth_response, Response):
return auth_response
class_type = get_doc().collections[path]["collection"].class_.title
if checkClassOp(class_type, "DELETE"):
# Check if class_type supports PUT operation
try:
# Delete the Item with ID == id_
crud.delete_multiple(int_list,
class_type,
session=get_session())
response = {
"message":
"Object with ID {} successfully deleted".format(
int_list.split(','))
}
return set_response_headers(jsonify(response))
except (ClassNotFound, InstanceNotFound) as e:
status_code, message = e.get_HTTP()
return set_response_headers(jsonify(message),
status_code=status_code)
abort(405)
def put(self, id_: str, path: str) -> Response:
"""Add new object_ optional <id_> parameter using HTTP PUT.
:param id_ - ID of Item to be updated
:param path - Path for Item type( Specified in APIDoc @id) to be updated
"""
id_ = str(id_)
auth_response = check_authentication_response()
if isinstance(auth_response, Response):
return auth_response
class_type = get_doc().collections[path]["collection"].class_.title
if checkClassOp(class_type, "PUT"):
# Check if class_type supports PUT operation
object_ = json.loads(request.data.decode('utf-8'))
obj_type = getType(class_type, "PUT")
# Load new object and type
if validObject(object_) and object_["@type"] == obj_type:
try:
# Add the object with given ID
object_id = crud.insert(object_=object_, id_=id_, session=get_session())
headers_ = [{"Location": "{}{}/{}/{}".format(
get_hydrus_server_url(), get_api_name(), path, object_id)}]
response = {
"message": "Object with ID {} successfully added".format(object_id)}
return set_response_headers(
jsonify(response), headers=headers_, status_code=201)
except (ClassNotFound, InstanceExists, PropertyNotFound) as e:
status_code, message = e.get_HTTP()
return set_response_headers(jsonify(message), status_code=status_code)
else:
return set_response_headers(jsonify({400: "Data is not valid"}), status_code=400)
else:
abort(405)
def post(self, id_: str, path: str) -> Response:
"""Update object of type<path> at ID<id_> with new object_ using HTTP POST.
:param id_ - ID of Item to be updated
:param path - Path for Item type( Specified in APIDoc @id)
"""
id_ = str(id_)
auth_response = check_authentication_response()
if isinstance(auth_response, Response):
return auth_response
class_type = get_doc().collections[path]["collection"].class_.title
if checkClassOp(class_type, "POST"):
# Check if class_type supports POST operation
object_ = json.loads(request.data.decode('utf-8'))
obj_type = getType(class_type, "POST")
# Load new object and type
if validObject(object_):
if object_["@type"] == obj_type:
try:
# Update the right ID if the object is valid and matches
# type of Item
object_id = crud.update(object_=object_,
id_=id_,
type_=object_["@type"],
session=get_session(),
api_name=get_api_name())
headers_ = [{
"Location":
"{}/{}/{}".format(get_hydrus_server_url(),
get_api_name(), path, object_id)
}]
response = {
"message":
"Object with ID {} successfully updated".format(
object_id)
}
return set_response_headers(jsonify(response),
headers=headers_)
except (ClassNotFound, InstanceNotFound, InstanceExists,
PropertyNotFound) as e:
status_code, message = e.get_HTTP()
return set_response_headers(jsonify(message),
status_code=status_code)
return set_response_headers(jsonify({400: "Data is not valid"}),
status_code=400)
abort(405)
def items_delete_response(path: str, int_list="") -> Response:
"""
Handles DELETE operation to insert multiple items.
:param path: Path for Item Collection
:type path: str
:param int_list: Optional String containing ',' separated ID's
:type int_list: List
:return: Appropriate response for the DELETE operation on multiple items.
:rtype: Response
"""
_, parsed_classes = get_collections_and_parsed_classes()
if path in parsed_classes:
class_type = getType(path, "DELETE")
if checkClassOp(class_type, "DELETE"):
# Check if class_type supports PUT operation
try:
# Delete the Item with ID == id_
crud.delete_multiple(int_list, class_type, session=get_session())
method = "DELETE"
path_url = f"{get_hydrus_server_url()}{get_api_name()}/{path}"
last_job_id = crud.get_last_modification_job_id(session=get_session())
id_list = int_list.split(',')
for item in id_list:
resource_url = path_url + item
new_job_id = crud.insert_modification_record(method,
resource_url,
session=get_session())
send_sync_update(socketio=socketio, new_job_id=new_job_id,
last_job_id=last_job_id, method=method,
resource_url=resource_url)
last_job_id = new_job_id
status_description = f"Objects with ID {id_list} successfully deleted"
status = HydraStatus(code=200,
title="Objects successfully deleted",
desc=status_description)
return set_response_headers(jsonify(status.generate()))
except (ClassNotFound, InstanceNotFound) as e:
error = e.get_HTTP()
return error_response(error)
abort(405)
def put(self, id_: str, path: str) -> Response:
"""
Add new object_ optional <id_> parameter using HTTP PUT.
:param id_ - ID of Item to be updated
:param path - Path for Item type( Specified in APIDoc @id) to be updated
"""
id_ = str(id_)
collections, parsed_classes = get_collections_and_parsed_classes()
is_collection = False
if path in parsed_classes:
class_path = path
if path in collections:
item_class = collections[path]["collection"]
class_path = item_class.path
is_collection = True
if checkClassOp(class_path, "PUT"):
return items_put_check_support(id_, class_path, path,
is_collection)
abort(405)
def post(self, id_: str, path: str) -> Response:
"""
Update object of type<path> at ID<id_> with new object_ using HTTP POST.
:param id_ - ID of Item to be updated
:param path - Path for Item type( Specified in APIDoc @id)
"""
id_ = str(id_)
collections, parsed_classes = get_collections_and_parsed_classes()
is_collection = False
if path in parsed_classes:
class_path = path
if path in collections:
item_class = collections[path]["collection"]
class_path = item_class.path
is_collection = True
object_ = json.loads(request.data.decode('utf-8'))
if checkClassOp(class_path, "POST") and check_writeable_props(
class_path, object_):
return items_post_check_support(id_, object_, class_path, path,
is_collection)
abort(405)
def delete(self, id_: str, path: str) -> Response:
"""
Delete object with id=id_ from database.
:param id_ - ID of Item to be deleted
:param path - Path for Item type( Specified in APIDoc @id) to be deleted
"""
id_ = str(id_)
collections, parsed_classes = get_collections_and_parsed_classes()
is_collection = False
if path in parsed_classes:
class_path = path
class_type = parsed_classes[path]['class'].title
if path in collections:
item_class = collections[path]["collection"]
class_type = item_class.name
# Get path of the collection-class
class_path = item_class.path
is_collection = True
if checkClassOp(class_path, "DELETE"):
return items_delete_check_support(id_, class_type, path,
is_collection)
abort(405)
def get(self, id_: str, path: str) -> Response:
"""
GET object with id = id_ from the database.
:param id_ : Item ID
:param path : Path for Item ( Specified in APIDoc @id)
:return : object with id=id_
"""
id_ = str(id_)
collections, parsed_classes = get_collections_and_parsed_classes()
is_collection = False
if path in parsed_classes:
class_path = path
class_type = parsed_classes[path]['class'].title
if path in collections:
item_class = collections[path]["collection"]
class_type = item_class.name
# Get path of the collection-class
class_path = item_class.path
is_collection = True
if checkClassOp(class_path, "GET"):
return items_get_check_support(id_, class_type, class_path, path,
is_collection)
abort(405)