class Check(APIView):
@method_decorator(api_staff_member_required())
def get(self, request):
"""Check if the registry is available to answer OAI-PMH requests
Args:
request: HTTP request
Returns:
- code: 200
content: Success label
- code: 500
content: Internal server error
"""
try:
base_url = request.build_absolute_uri(
reverse("core_oaipmh_provider_app_server_index"))
http_response = send_get_request(base_url)
is_available = http_response.status_code == status.HTTP_200_OK
content = OaiPmhMessage.get_message_labelled(
"Registry available? : {0}.".format(is_available))
return Response(content, status=http_response.status_code)
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class InfoRegistry(APIView):
@method_decorator(api_staff_member_required())
def patch(self, request, registry_id):
""" Update oai-pmh information for a given registry (Data provider)
Args:
request: HTTP request
registry_id: ObjectId
Returns:
- code: 200
content: Success message
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
registry = oai_registry_api.get_by_id(registry_id)
registry = oai_registry_api.update_registry_info(registry)
content = OaiPmhMessage.\
get_message_labelled('Registry {0} information updated with success.'.
format(registry.name))
return Response(content, status=status.HTTP_200_OK)
except exceptions.DoesNotExist as e:
content = OaiPmhMessage.get_message_labelled(e.message)
return Response(content, status=status.HTTP_404_NOT_FOUND)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(e.message)
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class TemplateVersion(AbstractTemplateVersionManagerDetail):
""" Create a TemplateVersion
"""
@method_decorator(api_staff_member_required())
def post(self, request, pk):
""" Create a TemplateVersion
Parameters:
{
"filename": "filename",
"content": "<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'><xs:element name='root'/></xs:schema>"
}
Note:
"dependencies_dict": json.dumps({"schemaLocation1": "id1" ,"schemaLocation2":"id2"})
Args:
request: HTTP request
Returns:
- code: 200
content: Created TemplateVersionManager
- code: 400
content: Validation error
- code: 404
content: Template was not found
- code: 500
content: Internal server error
"""
try:
# Get object
template_version_manager_object = self.get_object(pk)
# Build serializers
template_serializer = CreateTemplateSerializer(data=request.data)
# Validate data
template_serializer.is_valid(True)
# Save data
template_serializer.save(
template_version_manager=template_version_manager_object)
return Response(template_serializer.data,
status=status.HTTP_201_CREATED)
except Http404:
content = {'message': 'Template Version Manager not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except ValidationError as validation_exception:
content = {'message': validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Exception as api_exception:
content = {'message': str(api_exception)}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class AccountRequestDetail(APIView):
"""Get an Account Request"""
def get_object(self, pk):
"""Get Account Request from db
Args:
pk: ObjectId
Returns:
Account Request
"""
try:
return account_request_api.get(pk)
except exceptions.DoesNotExist:
raise Http404
@method_decorator(api_staff_member_required())
def get(self, request, pk):
"""Retrieve a Account Request
Parameters:
{
"pk": "account_request_id"
}
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 200
content: Account Request
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
account_request_object = self.get_object(pk)
# Serialize object
serializer = AccountRequestSerializer(account_request_object)
# Return response
return Response(serializer.data)
except Http404:
content = {"message": "Account request not found."}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {"message": str(api_exception)}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class XslTransformationList(APIView):
"""
List, Create XSL document.
"""
def get(self, request):
""" Return http response with all xsl document.
GET /rest/xslt
Args:
request:
Returns:
"""
try:
# Get object
xsl_object_list = xsl_api.get_all()
# Serialize object
return_value = XslTransformationSerializer(xsl_object_list, many=True)
# Return response
return Response(return_value.data)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def post(self, request):
""" Save an xslt.
POST /rest/xslt
{
"name": "instance_name",
"filename": "url",
"content": "<content />",
}
Args:
request:
Returns:
"""
try:
# Build serializer
xsl_serializer = XslTransformationSerializer(data=request.data)
# Validate xsl
xsl_serializer.is_valid(True)
# save or update the object
xsl_serializer.save()
return Response(xsl_serializer.data, status=status.HTTP_201_CREATED)
except ValidationError as validation_exception:
content = {'message': validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class QueryOntologyActivate(APIView):
"""Activate a Query Ontology"""
def get_object(self, request, pk):
"""Get Query ontology from db
Args:
request: HTTP request
pk: ObjectId
Returns:
Query ontology
"""
try:
return query_ontology_api.get_by_id(pk)
except exceptions.DoesNotExist:
raise Http404
@method_decorator(api_staff_member_required())
def patch(self, request, pk):
"""Activate the given Query Ontology
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 200
content: {}
- code: 403
content: Access control error
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
query_ontology_object = self.get_object(request, pk)
# Activate the given Query Ontology
query_ontology_api.edit_status(query_ontology_object,
QueryOntologyStatus.active.value)
return Response({}, status=status.HTTP_200_OK)
except AccessControlError as ace:
content = {"message": str(ace)}
return Response(content, status=status.HTTP_403_FORBIDDEN)
except Http404:
content = {"message": "Query Ontology not found."}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {"message": str(api_exception)}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class QueryOntologyDownload(APIView):
"""Download content from Query Ontology"""
def get_object(self, request, pk):
"""Get Query ontology from db
Args:
request: HTTP request
pk: ObjectId
Returns:
Query ontology
"""
try:
return query_ontology_api.get_by_id(pk)
except exceptions.DoesNotExist:
raise Http404
@method_decorator(api_staff_member_required())
def get(self, request, pk):
"""Download Query Ontology
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 200
content: OWL file
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
query_ontology_object = self.get_object(request, pk)
return get_file_http_response(
query_ontology_object.content,
query_ontology_object.title,
"text/xml",
"owl",
)
except Http404:
content = {"message": "Query Ontology not found."}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {"message": str(api_exception)}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class GlobalTemplateList(AbstractTemplateList):
""" Create a global template (owner is None)
"""
@method_decorator(api_staff_member_required())
def post(self, request):
""" Create a global template.
Args:
request:
Returns:
"""
return super(GlobalTemplateList, self).post(request)
def get_user(self):
return None
class QueryOntologyActivate(APIView):
""" Activate a Query Ontology
"""
def get_object(self, request, pk):
""" Get Query ontology from db
Args:
request:
pk:
Returns:
"""
try:
return query_ontology_api.get_by_id(pk)
except exceptions.DoesNotExist:
raise Http404
@method_decorator(api_staff_member_required())
def patch(self, request, pk):
""" Activate the given Query Ontology
Args:
request:
pk:
Returns:
"""
try:
# Get object
query_ontology_object = self.get_object(request, pk)
# Activate the given Query Ontology
query_ontology_api.edit_status(query_ontology_object,
QueryOntologyStatus.active.value)
return Response({}, status=status.HTTP_200_OK)
except Http404:
content = {'message': 'Query Ontology not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except AccessControlError as ace:
content = {'message': ace.message}
return Response(content, status=status.HTTP_403_FORBIDDEN)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class TemplateAsMetadataFormat(APIView):
@method_decorator(api_staff_member_required())
def post(self, request):
"""Add a new Template as MetadataFormat
Parameters:
{
"metadata_prefix" : "value",
"template_id":"value"
}
Args:
request: HTTP request
Returns:
- code: 201
content: Success Label
- code: 400
content: Validation error
- code: 500
content: Internal server error
"""
try:
# Build serializer
serializer = serializers.TemplateMetadataFormatSerializer(
data=request.data, context={"request": request})
# Validate data
serializer.is_valid(True)
# Save data
return serializer.save()
except ValidationError as validation_exception:
content = OaiPmhMessage.get_message_labelled(
validation_exception.detail)
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class GlobalTemplateList(AbstractTemplateList):
""" Create a Template (global schema)
"""
@method_decorator(api_staff_member_required())
def post(self, request):
""" Create a Template (global schema)
Parameters:
{
"title": "title",
"filename": "filename",
"content": "<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'><xs:element name='root'/></xs:schema>"
}
Note:
"dependencies"= json.dumps({"schemaLocation1": "id1" ,"schemaLocation2":"id2"})
Args:
request: HTTP request
Returns:
- code: 201
content: Created template
- code: 400
content: Validation error / not unique / XSD error
- code: 500
content: Internal server error
"""
return super(GlobalTemplateList, self).post(request)
def get_user(self):
""" The user is None for a global template
Returns:
None
"""
return None
class QueryOntologyDownload(APIView):
""" Download content from Query Ontology.
"""
def get_object(self, request, pk):
""" Get Query ontology from db
Args:
request:
pk:
Returns:
"""
try:
return query_ontology_api.get_by_id(pk)
except exceptions.DoesNotExist:
raise Http404
@method_decorator(api_staff_member_required())
def get(self, request, pk):
""" Download Query Ontology
Args:
request:
pk:
Returns:
"""
try:
# Get object
query_ontology_object = self.get_object(request, pk)
return get_file_http_response(query_ontology_object.content,
query_ontology_object.title,
'text/xml', 'owl')
except Http404:
content = {'message': 'Query Ontology not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class GlobalTypeList(AbstractTypeList):
""" Create a global type
"""
@method_decorator(api_staff_member_required())
def post(self, request):
""" Create a global type & type version manager
Parameters:
{
"title": "title",
"filename": "filename",
"content": "<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'><xs:simpleType name='root'/></xs:schema>"
}
Note:
"dependencies" = json.dumps({"schemaLocation1": "id1" ,"schemaLocation2":"id2"})
Args:
request: HTTP request
Returns:
- code: 201
content: Type
- code: 400
content: Validation error / bad request
- code: 500
content: Internal server error
"""
return super(GlobalTypeList, self).post(request)
def get_user(self):
""" None for global type
"""
return None
class DeactivateRegistry(APIView):
@method_decorator(api_staff_member_required())
def patch(self, request, registry_id):
"""Deactivate a given registry (Data provider)
Args:
request: HTTP request
registry_id: ObjectId
Returns:
- code: 200
content: Success message
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
registry = oai_registry_api.get_by_id(registry_id)
registry.is_activated = False
oai_registry_api.upsert(registry)
content = OaiPmhMessage.get_message_labelled(
"Registry {0} deactivated with success.".format(registry.name))
return Response(content, status=status.HTTP_200_OK)
except exceptions.DoesNotExist:
content = OaiPmhMessage.get_message_labelled(
"No registry found with the given id.")
return Response(content, status=status.HTTP_404_NOT_FOUND)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class SetsList(APIView):
@method_decorator(api_staff_member_required())
def get(self, request):
"""Get all OaiProviderSet
Args:
request: HTTP request
Returns:
- code: 200
content: List of OaiProviderSet
- code: 500
content: Internal server error
"""
try:
sets = oai_provider_set_api.get_all()
serializer = serializers.OaiProviderSetSerializer(
sets, many=True, context={"request": request}
)
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def post(self, request):
"""Create a OaiProviderSet
Parameters:
{
"set_spec": "value",
"set_name":"value",
"templates_manager": ["id1", "id2"],
"description":"value"
}
Args:
request: HTTP request
Returns:
- code: 201
content: Success Label
- code: 400
content: Validation error
- code: 500
content: Internal server error
"""
try:
# Build serializer
serializer = serializers.OaiProviderSetSerializer(
data=request.data, context={"request": request}
)
# Validate data
serializer.is_valid(True)
# Save data
serializer.save()
content = OaiPmhMessage.get_message_labelled("Set added with success.")
return Response(content, status=status.HTTP_201_CREATED)
except ValidationError as validation_exception:
content = OaiPmhMessage.get_message_labelled(validation_exception.detail)
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class XslTransformationDetail(APIView):
"""" Get, delete, patch an XSL document.
"""
def get_object(self, pk):
""" Retrieve an xsl document
Args:
pk:
Returns:
"""
try:
return xsl_api.get_by_id(pk)
except exceptions.DoesNotExist:
raise Http404
def get(self, request, pk):
""" Get xslt by its id.
GET /rest/xslt/pk
Args:
request:
pk:
Returns:
"""
try:
# Get object
xsl_object = self.get_object(pk)
# Serialize object
return_value = XslTransformationSerializer(xsl_object)
# Return response
return Response(return_value.data)
except Http404:
content = {'message': 'Xsl not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def delete(self, request, pk):
""" Delete xsl document by its id.
DELETE /rest/xslt/pk
Args:
pk:
Returns:
"""
try:
# Get object
xsl_object = self.get_object(pk)
# Remove the instance
xsl_api.delete(xsl_object)
# Return response
return Response(status=status.HTTP_204_NO_CONTENT)
except Http404:
content = {'message': 'Xsl not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def patch(self, request, pk):
""" Update xsl
Args:
request:
pk:
Returns:
"""
try:
# Get object
xsl_object = self.get_object(pk)
# Build serializer
xsl_serializer = XslTransformationSerializer(instance=xsl_object,
data=request.data,
partial=True)
# Validate xsl
xsl_serializer.is_valid(True)
# Save xsl
xsl_serializer.save()
return Response(xsl_serializer.data, status=status.HTTP_200_OK)
except ValidationError as validation_exception:
content = {'message': validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Http404:
content = {'message': 'Xsl not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class ElasticsearchTemplateList(APIView):
"""List elasticsearch template configuration"""
@method_decorator(api_staff_member_required())
def get(self, request):
"""Get all elasticsearch template configuration
Args:
request: HTTP request
Returns:
- code: 200
content: List of elasticsearch template configurations
- code: 500
content: Internal server error
"""
try:
object_list = elasticsearch_template_api.get_all()
# Serialize object
serializer = ElasticsearchTemplateSerializer(object_list, many=True)
# Return response
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as api_exception:
content = {"message": str(api_exception)}
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def post(self, request):
"""Create an elasticsearch template configuration
Parameters:
{
"template": "template_id",
"title_path": "/x/path/title",
"description_paths": ["/x/path/desc_one", "/x/path/desc_two"],
}
Args:
request: HTTP request
Returns:
- code: 201
content: Created elasticsearch template
- code: 400
content: Validation error / not unique / model error
- code: 500
content: Internal server error
"""
try:
# Build serializer
serializer = ElasticsearchTemplateSerializer(data=request.data)
# Validate data
serializer.is_valid(True)
# Save data
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
except ValidationError as validation_exception:
content = {"message": validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except exceptions.ModelError as model_exception:
content = {"message": str(model_exception)}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except exceptions.NotUniqueError as not_unique_error:
content = {"message": str(not_unique_error)}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except exceptions.ApiError as api_exception:
content = {"message": str(api_exception)}
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except Exception as exception:
content = {"message": str(exception)}
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class DataDetailRegistry(DataDetail):
"""Retrieve or update a data"""
@method_decorator(api_staff_member_required())
def delete(self, request, pk):
"""Delete a Data
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 204
content: Deletion succeed
- code: 403
content: Access forbidden
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
if request.user.is_superuser:
# Get object
data_object = self.get_object(request, pk)
# delete object
data_api.delete(data_object, request.user)
else:
content = {
"message": "You must have superuser right to delete data."
}
return Response(content, status=status.HTTP_403_FORBIDDEN)
# Return response
return Response(status=status.HTTP_204_NO_CONTENT)
except Http404:
content = {"message": "Data not found."}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {"message": str(api_exception)}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def patch(self, request, pk):
"""Data cannot be updated
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 403
content: Data cannot be updated
"""
content = {"message": "Data cannot be updated."}
return Response(content, status=status.HTTP_403_FORBIDDEN)
class ExporterXslList(APIView):
"""List all XSL Exporters, or create"""
permission_classes = (IsAuthenticated, )
def get(self, request):
"""Get all XSL Exporters
Args:
request: HTTP request
Returns:
- code: 200
content: List of XSL Exporters
- code: 500
content: Internal server error
"""
try:
# Get object
exporter_list = xsl_api.get_all()
# Serialize object
return_value = ExporterXslSerializer(exporter_list, many=True)
# Return response
return Response(return_value.data)
except Exception as api_exception:
content = {"message": str(api_exception)}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def post(self, request):
"""Save an XSL Exporter
Parameters:
{
"name": "exporter_name",
"templates": ["id", "id"],
"xsl_transformation": "id"
}
Args:
request: HTTP request
Returns:
- code: 201
content: Created XSL Exporter
- code: 400
content: Validation error
- code: 500
content: Internal server error
"""
try:
# Build serializer
xsl_serializer = ExporterXslSerializer(data=request.data)
# Validation
xsl_serializer.is_valid(True)
# save or update the object
xsl_serializer.save()
return Response(xsl_serializer.data,
status=status.HTTP_201_CREATED)
except ValidationError as validation_exception:
content = {"message": validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Exception as api_exception:
content = {"message": str(api_exception)}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class AccountRequestList(APIView):
"""Create or get all Account Request"""
@method_decorator(api_staff_member_required())
def get(self, request):
"""Get all account requests
Args:
request: HTTP request
Returns:
- code: 200
content: List of account requests
- code: 400
content: Validation error
"""
try:
account_request_list = account_request_api.get_all()
# Serialize object
serializer = AccountRequestSerializer(account_request_list,
many=True)
# Return response
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as api_exception:
content = {"message": str(api_exception)}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request):
"""Create a new account request
Parameters:
{
"username": "******",
"first_name": "first_name",
"last_name": "last_name",
"password": "******",
"email": "email"
}
Args:
request: HTTP request
Returns:
- code: 200
content: Account Request
- code: 400
content: Validation error / missing parameters
"""
try:
# Build serializer
serializer = UserSerializer(data=request.data)
# Validate request
serializer.is_valid(True)
# Save request
account_request = serializer.save()
# Account request serializer
account_request_serializer = AccountRequestSerializer(
account_request)
# Return the serialized user request
return Response(account_request_serializer.data,
status=status.HTTP_201_CREATED)
except ValidationError as validation_exception:
content = {"message": validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Exception as api_exception:
content = {"message": str(api_exception)}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class Harvest(APIView):
@method_decorator(api_staff_member_required())
def patch(self, request, registry_id):
"""Harvest a given registry (Data provider)
Args:
request: HTTP request
registry_id: ObjectId
Returns:
- code: 200
content: Success message
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
registry = oai_registry_api.get_by_id(registry_id)
all_errors = oai_registry_api.harvest_registry(registry)
if len(all_errors) > 0:
raise exceptions_oai.OAIAPISerializeLabelledException(
errors=all_errors, status_code=status.HTTP_400_BAD_REQUEST)
else:
content = OaiPmhMessage.get_message_labelled(
"Registry {0} harvested with success.".format(
registry.name))
return Response(content, status=status.HTTP_200_OK)
except exceptions.DoesNotExist as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content, status=status.HTTP_404_NOT_FOUND)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def put(self, request, registry_id):
"""Edit the harvesting configuration of a registry (Data Provider)
Configure metadata_formats and sets to harvest
Parameters:
{
"metadata_formats": ["id1", "id2"..],
"sets": ["id1", "id2"..]
}
Args:
request: HTTP request
registry_id: ObjectId
Returns:
- code: 200
content: Success message
- code: 400
content: Validation error
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Build serializer
serializer = serializers.HarvestSerializer(data=request.data)
# Validate data
serializer.is_valid(True)
# Harvest
metadata_formats = serializer.data.get("metadata_formats")
sets = serializer.data.get("sets")
# Get metadata formats ids and sets ids related to the registry.
registry_metadata_formats = oai_metadata_format_api.get_all_by_registry_id(
registry_id).values_list("id")
registry_sets = oai_set_api.get_all_by_registry_id(
registry_id).values_list("id")
# Set all metadata_formats to false (Do not harvest)
oai_metadata_format_api.update_for_all_harvest_by_list_ids(
registry_metadata_formats, False)
# Set given metadata_formats to True (Harvest)
oai_metadata_format_api.update_for_all_harvest_by_list_ids(
metadata_formats, True)
# Set all sets to false (Do not harvest)
oai_set_api.update_for_all_harvest_by_list_ids(
registry_sets, False)
# Set given sets to True (Harvest)
oai_set_api.update_for_all_harvest_by_list_ids(sets, True)
content = OaiPmhMessage.get_message_labelled(
"Registry harvesting configuration updated with success.")
return Response(content, status=status.HTTP_200_OK)
except ValidationError as validation_exception:
content = OaiPmhMessage.get_message_labelled(
validation_exception.detail)
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except exceptions.DoesNotExist as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content, status=status.HTTP_404_NOT_FOUND)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class XslTransformationDetail(APIView):
"""" Get, delete, patch an XSL document
"""
def get_object(self, pk):
""" Get XSL document from db
Args:
pk: ObjectId
Returns:
XSL document
"""
try:
return xsl_api.get_by_id(pk)
except exceptions.DoesNotExist:
raise Http404
def get(self, request, pk):
""" Retrieve XSLT
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 200
content: XSL document
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
xsl_object = self.get_object(pk)
# Serialize object
return_value = XslTransformationSerializer(xsl_object)
# Return response
return Response(return_value.data)
except Http404:
content = {'message': 'Xsl not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def delete(self, request, pk):
""" Delete an xsl document
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 204
content: Deletion succeed
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
xsl_object = self.get_object(pk)
# Remove the instance
xsl_api.delete(xsl_object)
# Return response
return Response(status=status.HTTP_204_NO_CONTENT)
except Http404:
content = {'message': 'Xsl not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def patch(self, request, pk):
""" Update xsl
Parameters:
{
"name": "instance_name",
"filename": "url",
"content": "<content />",
}
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 200
content: Updated XSL document
- code: 400
content: Validation error
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
xsl_object = self.get_object(pk)
# Build serializer
xsl_serializer = XslTransformationSerializer(instance=xsl_object,
data=request.data,
partial=True)
# Validate xsl
xsl_serializer.is_valid(True)
# Save xsl
xsl_serializer.save()
return Response(xsl_serializer.data, status=status.HTTP_200_OK)
except ValidationError as validation_exception:
content = {'message': validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Http404:
content = {'message': 'Xsl not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class XslTransformationList(APIView):
""" List, create XSL document
"""
def get(self, request):
""" Get all XSL document
Args:
request: HTTP request
Returns:
- code: 200
content: List of XSL document
- code: 500
content: Internal server error
"""
try:
# Get object
xsl_object_list = xsl_api.get_all()
# Serialize object
return_value = XslTransformationSerializer(xsl_object_list,
many=True)
# Return response
return Response(return_value.data)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def post(self, request):
""" Save an XSL document
Parameters:
{
"name": "instance_name",
"filename": "url",
"content": "<content />",
}
Args:
request: HTTP request
Returns:
- code: 201
content: Created XSL document
- code: 400
content: Validation error
- code: 500
content: Internal server error
"""
try:
# Build serializer
xsl_serializer = XslTransformationSerializer(data=request.data)
# Validate xsl
xsl_serializer.is_valid(True)
# save or update the object
xsl_serializer.save()
return Response(xsl_serializer.data,
status=status.HTTP_201_CREATED)
except ValidationError as validation_exception:
content = {'message': validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class TypeVersionManagerBuckets(AbstractTemplateVersionManagerDetail):
""" Set new list of buckets for a type version manager
"""
@method_decorator(api_staff_member_required())
def patch(self, request, pk):
""" Set new list of buckets for a type version manager
Parameters:
[
{
"id":"<bucket_id>"
},
{
"id":"<bucket_id>"
}
]
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 200
content: None
- code: 400
content: Validation error
- code: 403
content: Authentication error
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
type_version_manager = self.get_object(pk)
# Serialize data
serializer = BucketsSerializer(data=request.data, many=True)
# Validate data
serializer.is_valid(True)
# Get list of unique ids
bucket_ids = set(
[bucket['id'] for bucket in serializer.validated_data])
# act
bucket_api.update_type_buckets(type_version_manager, bucket_ids)
return Response(status=status.HTTP_200_OK)
except Http404:
content = {'message': 'Object not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except AccessControlError as access_error:
content = {'message': access_error.message}
return Response(content, status=status.HTTP_403_FORBIDDEN)
except ValidationError as validation_exception:
content = {'message': validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class BucketList(APIView):
""" List all buckets, or create a new one.
"""
def get(self, request):
""" Get all buckets
Url Parameters:
label: label
Examples:
../bucket/
../bucket?label=[label]
Args:
request: HTTP request
Returns:
- code: 200
content: List of buckets
- code: 500
content: Internal server error
"""
try:
# Get objects
object_list = bucket_api.get_all()
# Apply filters
label = self.request.query_params.get('label', None)
if label is not None:
object_list = object_list.filter(label=label)
# Serialize object
serializer = BucketSerializer(object_list, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def post(self, request):
""" Create a bucket
Parameters:
{
"label": "label",
"types": ["<type_version_manager_id>"]
}
Args:
request: HTTP request
Returns:
- code: 201
content: Created bucket
- code: 400
content: Validation error
- code: 500
content: Internal server error
"""
try:
# Build serializer
bucket_serializer = BucketSerializer(data=request.data)
# Validate data
bucket_serializer.is_valid(True)
# Save data
bucket_serializer.save()
# Return the serialized data
return Response(bucket_serializer.data,
status=status.HTTP_201_CREATED)
except ValidationError as validation_exception:
content = {'message': validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class BucketDetail(APIView):
""" Retrieve, update or delete a bucket
"""
def get_object(self, pk):
""" Get bucket from db
Args:
pk: ObjectId
Returns:
Bucket
"""
try:
return bucket_api.get_by_id(pk)
except DoesNotExist:
raise Http404
def get(self, request, pk):
""" Retrieve a bucket
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 200
content: Bucket
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
bucket = self.get_object(pk)
# Serialize object
serializer = BucketSerializer(bucket)
# Return response
return Response(serializer.data)
except Http404:
content = {'message': 'Bucket not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def delete(self, request, pk):
""" Delete a bucket
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 204
content: Deletion succeed
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
bucket = self.get_object(pk)
# delete object
bucket_api.delete(bucket)
# Return response
return Response(status=status.HTTP_204_NO_CONTENT)
except Http404:
content = {'message': 'Bucket not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def patch(self, request, pk):
""" Update bucket
Parameters:
{
"label": "<label>"
}
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 200
content: Updated bucket
- code: 400
content: Validation error
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
bucket = self.get_object(pk)
# Build serializer
bucket_serializer = BucketSerializer(instance=bucket,
data=request.data,
partial=True)
# Validate data
bucket_serializer.is_valid(True)
# Save data
bucket_serializer.save(user=request.user)
return Response(bucket_serializer.data, status=status.HTTP_200_OK)
except ValidationError as validation_exception:
content = {'message': validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Http404:
content = {'message': 'Bucket not found.'}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except Exception as api_exception:
content = {'message': api_exception.message}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class RegistryList(APIView):
@method_decorator(api_staff_member_required())
@method_decorator(
api_permission_required(rights.oai_pmh_content_type,
rights.oai_pmh_access))
def get(self, request):
"""Get all Registries (Data provider)
Args:
request: HTTP request
Returns:
- code: 200
content: List of Registries
- code: 500
content: Internal server error
"""
try:
registry = oai_registry_api.get_all()
serializer = serializers.RegistrySerializer(
registry, many=True, context={"request": request})
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def post(self, request):
"""Create a Registry (Data provider)
Parameters:
{
"url" : "value",
"harvest_rate" : "number",
"harvest" : "True or False"
}
Args:
request: HTTP request
Returns:
- code: 201
content: Created Registry
- code: 400
content: Validation error
- code: 500
content: Internal server error
"""
try:
# Build serializer
serializer = serializers.RegistrySerializer(
data=request.data, context={"request": request})
# Validate data
serializer.is_valid(True)
# Save data
registry = serializer.save()
content = OaiPmhMessage.get_message_labelled(
"Registry {0} added with success.".format(registry.name))
return Response(content, status=status.HTTP_201_CREATED)
except ValidationError as validation_exception:
content = OaiPmhMessage.get_message_labelled(
validation_exception.detail)
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class SetDetail(APIView):
@method_decorator(api_staff_member_required())
def get(self, request, set_id):
"""Get a OaiProviderSet
Args:
request: HTTP request
set_id: ObjectId
Returns:
- code: 200
content: Registry
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
set_ = oai_provider_set_api.get_by_id(set_id)
serializer = serializers.OaiProviderSetSerializer(
set_, context={"request": request}
)
return Response(serializer.data, status=status.HTTP_200_OK)
except exceptions.DoesNotExist:
content = OaiPmhMessage.get_message_labelled(
"No Set found with the given id."
)
return Response(content, status=status.HTTP_404_NOT_FOUND)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def delete(self, request, set_id):
"""Delete a OaiProviderSet
Args:
request: HTTP request
set_id: ObjectId
Returns:
- code: 204
content: Deletion succeed
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
set_ = oai_provider_set_api.get_by_id(set_id)
oai_provider_set_api.delete(set_)
return Response(status=status.HTTP_204_NO_CONTENT)
except exceptions.DoesNotExist:
content = OaiPmhMessage.get_message_labelled(
"No Set found with the given id."
)
return Response(content, status=status.HTTP_404_NOT_FOUND)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def patch(self, request, set_id):
"""Update a OaiProviderSet
Parameters:
{
"set_spec":"value",
"set_name":"value",
"templates_manager": ["id1", "id2"],
"description":"value"
}
Args:
request: HTTP request
Returns:
- code: 200
content: Success message
- code: 400
content: Validation error
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
set_ = oai_provider_set_api.get_by_id(set_id)
# Build serializer
serializer = serializers.OaiProviderSetSerializer(
instance=set_, data=request.data, context={"request": request}
)
# Validate data
serializer.is_valid(True)
# Save data
serializer.save()
content = OaiPmhMessage.get_message_labelled("Set updated with success.")
return Response(content, status=status.HTTP_200_OK)
except ValidationError as validation_exception:
content = OaiPmhMessage.get_message_labelled(validation_exception.detail)
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except exceptions.DoesNotExist:
content = OaiPmhMessage.get_message_labelled(
"No Set found with the given id."
)
return Response(content, status=status.HTTP_404_NOT_FOUND)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class AbstractStatusTemplateVersion(APIView, metaclass=ABCMeta):
"""Set template version status"""
def get_object(self, pk, request):
"""Get template from db
Args:
pk: ObjectId
request:
Returns:
Template
"""
try:
template_object = template_api.get(pk, request=request)
return template_object
except exceptions.DoesNotExist:
raise Http404
@abstractmethod
def status_update(self, template_object):
"""Perform an update of the object status"""
raise NotImplementedError("status_update method is not implemented.")
@method_decorator(api_staff_member_required())
def patch(self, request, pk):
"""Set status
Args:
request: HTTP request
pk: ObjectId
Returns:
- code: 200
content: None
- code: 400
content: Validation error / bad request
- code: 403
content: Authentication error
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
# Get object
template_object = self.get_object(pk, request=request)
# Set current template
self.status_update(template_object)
return Response(status=status.HTTP_200_OK)
except Http404:
content = {"message": "Template not found."}
return Response(content, status=status.HTTP_404_NOT_FOUND)
except AccessControlError as access_error:
content = {"message": str(access_error)}
return Response(content, status=status.HTTP_403_FORBIDDEN)
except ValidationError as validation_exception:
content = {"message": validation_exception.detail}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except ApiError as api_error:
content = {"message": str(api_error)}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except Exception as api_exception:
content = {"message": str(api_exception)}
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class RegistryDetail(APIView):
@method_decorator(api_staff_member_required())
@method_decorator(
api_permission_required(rights.oai_pmh_content_type,
rights.oai_pmh_access))
def get(self, request, registry_id):
"""Retrieve a Registry (Data provider)
Args:
request: HTTP request
registry_id: ObjectId
Returns:
- code: 200
content: Registry
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
registry = oai_registry_api.get_by_id(registry_id)
serializer = serializers.RegistrySerializer(
registry, context={"request": request})
return Response(serializer.data, status=status.HTTP_200_OK)
except exceptions.DoesNotExist:
content = OaiPmhMessage.get_message_labelled(
"No registry found with the given id.")
return Response(content, status=status.HTTP_404_NOT_FOUND)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def delete(self, request, registry_id):
"""Delete a Registry (Data provider)
Args:
request: HTTP request
registry_id: ObjectId
Returns:
- code: 204
content: Deletion succeed
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
registry = oai_registry_api.get_by_id(registry_id)
oai_registry_api.delete(registry)
return Response(status=status.HTTP_204_NO_CONTENT)
except exceptions.DoesNotExist:
content = OaiPmhMessage.get_message_labelled(
"No registry found with the given id.")
return Response(content, status=status.HTTP_404_NOT_FOUND)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@method_decorator(api_staff_member_required())
def patch(self, request, registry_id):
"""Update oai-pmh configuration for a given registry (Data provider)
Parameters:
{
"harvest_rate" : "value",
"harvest" : "True or False"
}
Args:
request: HTTP request
registry_id: ObjectId
Returns:
- code: 200
content: Success message
- code: 400
content: Validation error
- code: 404
content: Object was not found
- code: 500
content: Internal server error
"""
try:
registry = oai_registry_api.get_by_id(registry_id)
# Build serializer
serializer = serializers.UpdateRegistrySerializer(
instance=registry, data=request.data)
# Validate data
serializer.is_valid(True)
# Save data
serializer.save()
content = OaiPmhMessage.get_message_labelled(
"Registry {0} updated with success.".format(registry.name))
return Response(content, status=status.HTTP_200_OK)
except ValidationError as validation_exception:
content = OaiPmhMessage.get_message_labelled(
validation_exception.detail)
return Response(content, status=status.HTTP_400_BAD_REQUEST)
except exceptions.DoesNotExist:
content = OaiPmhMessage.get_message_labelled(
"No registry found with the given id.")
return Response(content, status=status.HTTP_404_NOT_FOUND)
except exceptions_oai.OAIAPIException as e:
return e.response()
except Exception as e:
content = OaiPmhMessage.get_message_labelled(str(e))
return Response(content,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
