def get(self):
"""HTTP GET handler.
"""
def _set_criteria():
"""Sets search criteria.
"""
for param in {
_PARAM_DOCUMENT_TYPE,
_PARAM_DOCUMENT_VERSION,
_PARAM_EXPERIMENT,
_PARAM_INSTITUTE,
_PARAM_MODEL,
_PARAM_PROJECT,
_PARAM_SUB_PROJECT
}:
if self.get_argument(param, None) in {None, "*"}:
setattr(self, param, None)
else:
setattr(self, param, self.get_argument(param))
def _set_data():
"""Pulls data from db.
"""
# TODO- context manager
db.session.start(config.db)
self.summaries = get_document_summaries(
self.project,
self.document_type,
self.document_version,
sub_project=self.sub_project,
institute=self.institute,
model=self.model,
experiment=self.experiment
)
self.total = get_document_type_count(self.project, self.document_type)
def _set_output():
"""Sets output data to be returned to client.
"""
self.output = {
'count': len(self.summaries),
'project': self.project,
'results': self.summaries,
'total': self.total
}
# Process request.
process_request(self, [
_set_criteria,
_set_data,
_set_output
])
def get(self):
"""HTTP GET handler.
"""
def _validate_criteria():
"""Validates url request params.
"""
if len(self.drs_path.split(_DRS_SEPERATOR)) == 1:
raise ValueError("A DRS path must contain at least one element")
if len(self.drs_path.split(_DRS_SEPERATOR)) > _MAX_DRS_KEYS:
msg = "A DRS path must consist of a maximum {0} keys"
raise ValueError(msg.format(_MAX_DRS_KEYS))
def _set_drs_keys():
"""Sets the DRS keys to be used to search db.
"""
self.drs_keys = [i for i in self.drs_path.split(_DRS_SEPERATOR)
if len(i) and i.upper() != self.project.upper()]
def _set_data():
"""Pulls data from db.
"""
db.session.start(config.db)
self.docs = db.dao.get_document_by_drs_keys(
self.project,
self.drs_keys[0] if len(self.drs_keys) > 0 else None,
self.drs_keys[1] if len(self.drs_keys) > 1 else None,
self.drs_keys[2] if len(self.drs_keys) > 2 else None,
self.drs_keys[3] if len(self.drs_keys) > 3 else None,
self.drs_keys[4] if len(self.drs_keys) > 4 else None,
self.drs_keys[5] if len(self.drs_keys) > 5 else None,
self.drs_keys[6] if len(self.drs_keys) > 6 else None,
self.drs_keys[7] if len(self.drs_keys) > 7 else None
)
# Process request.
process_request(self, [
lambda: parse_params(self, _PARAMS),
_validate_criteria,
_set_drs_keys,
_set_data,
lambda: set_output(self, self.docs)
])
def get(self):
"""HTTP GET handler.
"""
def _set_output():
"""Sets response to be returned to client.
"""
self.output = {
"message": "ES-DOC web service is operational @ {}".format(dt.datetime.now()),
"version": esdoc_api.__version__
}
# Process request.
process_request(self, _set_output)
def put(self):
"""HTTP PUT handler.
"""
def _validate_request_body():
"""Validates request body.
"""
# Decode document.
doc = pyesdoc.decode(self.request.body, 'json')
if not doc:
raise exceptions.DocumentDecodingException()
# Minimally validate document.
if not pyesdoc.is_valid(doc):
raise exceptions.DocumentInvalidException()
# Validate document version.
if doc.meta.version <= 0:
raise exceptions.DocumentInvalidException("Version must be > 0")
# Validate document publishing state.
if pyesdoc.archive.exists(doc.meta.id, doc.meta.version):
raise exceptions.DocumentPublishedException()
# Validation passed therefore cache decoded & extended payload.
self.doc = pyesdoc.extend(doc)
def _ingest():
"""Ingest document.
"""
db.session.start(config.db)
try:
db.ingest.execute(self.doc)
finally:
db.session.end()
# Process request.
process_request(self, [
_validate_request_body,
_ingest
])
def get(self):
"""HTTP GET handler.
"""
def _set_data():
"""Pulls data from db.
"""
db.session.start(config.db)
self.docs = db.dao.get_document(self.id, self.version, self.project)
# Process request.
process_request(self, [
lambda: parse_params(self, _PARAMS),
_set_data,
lambda: set_output(self, self.docs)
])
def get(self):
"""HTTP GET handler.
"""
def _set_data():
"""Pulls data from db.
"""
# TODO- context manager
db.session.start(config.db)
self.document_types = db.dao.get_document_types()
self.experiments = db.dao.get_experiments()
self.institutes = db.dao.get_institutes()
self.models = db.dao.get_models()
self.projects = db.dao.get_projects()
self.sub_projects = db.dao.get_sub_projects()
def _set_output():
"""Sets output data to be returned to client.
"""
self.output = {
'project' : self.projects,
'documentType' : ["{}:{}".format(i[0], i[1]) for i in self.document_types],
'documentVersion' : constants.DOCUMENT_VERSION,
'institute' : ["{}:{}".format(i[0], i[1]) for i in self.institutes],
'model' : ["{}:{}".format(i[0], i[1]) for i in self.models],
'experiment' : ["{}:{}".format(i[0], i[1]) for i in self.experiments],
'subProject' : ["{}:{}".format(i[0], i[1]) for i in self.sub_projects],
'cv': {
'documentTypes' : constants.DOCUMENT_TYPES,
}
}
# Process request.
process_request(self, [
_set_data,
_set_output
])
def get(self):
"""HTTP GET handler.
"""
def _set_criteria():
"""Sets search criteria.
"""
for param in {
_PARAM_DOCUMENT_ID,
_PARAM_DOCUMENT_VERSION,
_PARAM_ENCODING
}:
setattr(self, param, self.get_argument(param).lower())
def _set_data():
"""Pulls data from db.
"""
self.doc = pyesdoc.archive.read(self.document_id,
self.document_version,
False)
def _set_output():
"""Sets output data to be returned to client.
"""
if self.doc is None:
self.set_status(404)
else:
self.output_encoding = self.encoding
self.output = pyesdoc.encode(self.doc, self.encoding)
# Process request.
process_request(self, [
_set_criteria,
_set_data,
_set_output
])
def get(self):
"""HTTP GET handler.
"""
def _validate_criteria():
"""Validates url request params.
"""
# Set search manager.
self.handler = utils.external_id.get(self.project, self.external_type)
if not self.handler:
raise ValueError("External ID type is unsupported.")
# Validate external id.
if not self.handler.is_valid(self.external_id):
raise ValueError("Request parameter externalID: is invalid.")
def _set_external_id():
"""Sets parsed external identifier.
"""
self.external_id = self.handler.get_parsed(self.external_id)
def _set_data():
"""Pulls data from db.
"""
db.session.start(config.db)
self.docs = self.handler.do_search(self.project, self.external_id)
# Process request.
process_request(self, [
lambda: parse_params(self, _PARAMS),
_validate_criteria,
_set_external_id,
_set_data,
lambda: set_output(self, self.docs)
])
def delete(self):
"""HTTP DELETE handler.
"""
def _set_criteria():
"""Sets search criteria.
"""
for param in {
_PARAM_DOCUMENT_ID,
_PARAM_DOCUMENT_VERSION
}:
setattr(self, param, self.get_argument(param).lower())
def _delete_from_archive():
"""Deletes document from archive.
"""
pyesdoc.archive.delete(self.document_id,
self.document_version)
def _delete_from_db(self):
"""Deletes document from database.
"""
db.session.start(config.db)
try:
db.ingest.undo(self.document_id, self.document_version)
db.session.commit()
finally:
db.session.end()
# Process request.
process_request(self, [
_set_criteria,
_delete_from_archive,
_delete_from_db
])
