def _parseParams(self,params):
data = {
'by_doc_ID':False,
'by_resource_ID':True,
'ids_only': False,
'request_IDs': [],
}
if params.has_key('by_doc_ID') and params['by_doc_ID'] in trues:
data['by_doc_ID'] = True
data['by_resource_ID'] = False
if params.has_key('by_resource_ID'):
data['by_resource_ID'] = params['by_resource_ID'] in trues
if params.has_key('ids_only'):
data['ids_only'] = params['ids_only'] in trues
if params.has_key('resumption_token'):
data['resumption_token'] = rt.parse_token('obtain',params['resumption_token'])
log.debug(data['resumption_token'])
if params.has_key('callback'):
data['callback'] = params['callback']
if params.has_key('request_ID'):
data['request_IDs'].append(params['request_ID'])
if params.has_key('request_IDs'):
data['request_IDs'].extend(params['request_IDs'])
return data
def _parseParams(self,params):
if "resumption_token" in params and len(params) > 1:
abort(500,"resumption_token must be the only parameter")
data = {
'by_doc_ID':False,
'by_resource_ID':True,
'ids_only': False,
'request_IDs': [],
}
if params.has_key('by_doc_ID') and params['by_doc_ID'] in trues:
data['by_doc_ID'] = True
data['by_resource_ID'] = False
if params.has_key('by_resource_ID'):
data['by_resource_ID'] = params['by_resource_ID'] in trues
if params.has_key('ids_only'):
data['ids_only'] = params['ids_only'] in trues
if params.has_key('resumption_token'):
data['resumption_token'] = rt.parse_token('obtain',params['resumption_token'])
if params.has_key('callback'):
data['callback'] = params['callback']
if params.has_key('request_ID'):
data['request_IDs'].append(params['request_ID'])
elif params.has_key('request_id'):
data['request_IDs'].append(params['request_id'])
if params.has_key('request_IDs'):
data['request_IDs'].extend(params['request_IDs'])
if data['by_resource_ID']:
data['request_IDs'] = [unquote_plus(id) for id in data['request_IDs']]
return data
def _parseParams(self, params):
data = {
'by_doc_ID': False,
'by_resource_ID': True,
'ids_only': False,
'request_IDs': [],
}
if params.has_key('by_doc_ID') and params['by_doc_ID'] in trues:
data['by_doc_ID'] = True
data['by_resource_ID'] = False
if params.has_key('by_resource_ID'):
data['by_resource_ID'] = params['by_resource_ID'] in trues
if params.has_key('ids_only'):
data['ids_only'] = params['ids_only'] in trues
if params.has_key('resumption_token'):
data['resumption_token'] = rt.parse_token(
'obtain', params['resumption_token'])
log.debug(data['resumption_token'])
if params.has_key('callback'):
data['callback'] = params['callback']
if params.has_key('request_ID'):
data['request_IDs'].append(params['request_ID'])
elif params.has_key('request_id'):
data['request_IDs'].append(params['request_id'])
if params.has_key('request_IDs'):
data['request_IDs'].extend(params['request_IDs'])
if data['by_resource_ID']:
data['request_IDs'] = [
unquote_plus(id) for id in data['request_IDs']
]
log.debug(data)
return data
def list_identifiers(self,h, body ,params, verb = 'GET'):
data = self.get_base_response(verb,body)
if params.has_key('from'):
data['request']['from'] = params['from']
if params.has_key('until'):
data['request']['until'] = params['until']
from_date, until_date = self._test_time_params(params)
data['listidentifiers'] = []
base_response = json.dumps(data).split('[')
self._getServiceDocment(False)
resumption_token = None
if self.enable_flow_control and params.has_key('resumption_token'):
resumption_token = rt.parse_token(self.service_id,params['resumption_token'])
yield base_response[0] +'['
first = True;
count = 0
lastID = None
lastKey = None
for d in h.list_identifiers(from_date,until_date,resumption_token=resumption_token, limit=self.limit):
count += 1
lastID = d['id']
lastKey = d['key']
if not first:
yield ',\n'
first = False
return_value = {"header":{'identifier':d['id'], 'datestamp':helpers.convertToISO8601Zformat(datetime.today()) ,'status':'active'}}
yield json.dumps(return_value)
if self.enable_flow_control and self.limit <= count:
token = rt.get_token(serviceid=self.service_id,startkey=lastKey,endkey=helpers.convertToISO8601Zformat(until_date),startkey_docid=lastID,from_date=helpers.convertToISO8601Zformat(from_date),until_date=helpers.convertToISO8601Zformat(until_date))
resp = base_response[1]
yield resp[:-1] +(',"resumption_token":"%s"' %token) +resp[-1:]
else:
yield base_response[1]
def _parseParams(self, params):
if "resumption_token" in params and len(params) > 1:
abort(500, "resumption_token must be the only parameter")
data = {
'by_doc_ID': False,
'by_resource_ID': True,
'ids_only': False,
'request_IDs': [],
}
if params.has_key('by_doc_ID') and params['by_doc_ID'] in trues:
data['by_doc_ID'] = True
data['by_resource_ID'] = False
if params.has_key('by_resource_ID'):
data['by_resource_ID'] = params['by_resource_ID'] in trues
if params.has_key('ids_only'):
data['ids_only'] = params['ids_only'] in trues
if params.has_key('resumption_token'):
data['resumption_token'] = rt.parse_token(
'obtain', params['resumption_token'])
if params.has_key('callback'):
data['callback'] = params['callback']
if params.has_key('request_ID'):
data['request_IDs'].append(params['request_ID'])
elif params.has_key('request_id'):
data['request_IDs'].append(params['request_id'])
if params.has_key('request_IDs'):
data['request_IDs'].extend(params['request_IDs'])
if data['by_resource_ID']:
data['request_IDs'] = [
unquote_plus(id) for id in data['request_IDs']
]
return data
def _parse_params(self, req_params):
params = {}
start, end = self._get_dates(req_params)
if start is not None:
params[START_DATE] = start
params[END_DATE] = end
if IDENTITY in req_params:
params[IDENTITY] = req_params[IDENTITY].lower()
if ANY_TAGS in req_params:
params[ANY_TAGS] = req_params[ANY_TAGS].lower()
if IDS_ONLY in req_params:
params[IDS_ONLY] = req_params[IDS_ONLY] in [
'T', 't', 'True', 'true', True
]
else:
params[IDS_ONLY] = False
if RESUMPTION_TOKEN in req_params and req_params[
RESUMPTION_TOKEN] is not None:
resp_params = resumption_token.parse_token(
self.service_id, req_params[RESUMPTION_TOKEN])
params[RESUMPTION_TOKEN] = resp_params
if ANY_TAGS in resp_params:
params[ANY_TAGS] = resp_params[ANY_TAGS]
if IDENTITY in resp_params:
params[IDENTITY] = resp_params[IDENTITY]
return params
def _parse_params(self, req_params):
params = {}
param_count = 0
def _set_string_param(paramKey, setifempty=True, defaultWhenEmpty=""):
if req_params.has_key(paramKey):
params[paramKey] = str(req_params[paramKey])
return True
elif setifempty:
params[paramKey] = defaultWhenEmpty
return False
else:
return False
def _set_int_param(paramKey, setifempty=True):
if req_params.has_key(paramKey):
params[paramKey] = int(req_params[paramKey])
return True
elif setifempty:
params[paramKey] = None
return False
else:
return False
def _set_boolean_param(paramKey, setifempty=True):
if req_params.has_key(paramKey):
params[paramKey] = req_params[paramKey].lower() in [
"t", "true", "y", "yes"
]
return True
elif setifempty:
params[paramKey] = False
return False
else:
return False
if _set_string_param(START_DATE): param_count += 1
if _set_string_param(IDENTITY): param_count += 1
if _set_string_param(ANY_TAGS): param_count += 1
_set_string_param(END_DATE)
_set_boolean_param(IDS_ONLY)
_set_string_param(CALLBACK, False)
_set_string_param(RESUMPTION_TOKEN, True, None)
if params[RESUMPTION_TOKEN] is not None:
params[RESUMPTION_TOKEN] = resumption_token.parse_token(
self.service_id, params[RESUMPTION_TOKEN])
if len([
i for i in ["offset", "keys"]
if i in params[RESUMPTION_TOKEN]
]) != 2:
msg = ": Unknown Error"
if "error" in params[RESUMPTION_TOKEN]:
msg = ": %s" % params[RESUMPTION_TOKEN]["error"]
raise BadArgumentError("Bad Resumption Token%s" % msg)
params['param_count'] = param_count
log.debug(json.dumps(params))
return params
def _parse_params(self, req_params):
params = {}
param_count = 0
def _set_string_param(paramKey, setifempty=True, defaultWhenEmpty=""):
if req_params.has_key(paramKey):
params[paramKey] = str(req_params[paramKey])
return True
elif setifempty:
params[paramKey] = defaultWhenEmpty
return False
else:
return False
def _set_int_param(paramKey, setifempty=True):
if req_params.has_key(paramKey):
params[paramKey] = int(req_params[paramKey])
return True
elif setifempty:
params[paramKey] = None
return False
else:
return False
def _set_boolean_param(paramKey, setifempty=True):
if req_params.has_key(paramKey):
params[paramKey] = req_params[paramKey].lower() in ["t", "true", "y", "yes"]
return True
elif setifempty:
params[paramKey] = False
return False
else:
return False
if _set_string_param(START_DATE) : param_count += 1
if _set_string_param(IDENTITY) : param_count += 1
if _set_string_param(ANY_TAGS) : param_count += 1
_set_string_param(END_DATE)
_set_boolean_param(IDS_ONLY)
_set_string_param(CALLBACK, False)
_set_string_param(RESUMPTION_TOKEN, True, None)
if params[RESUMPTION_TOKEN] is not None:
params[RESUMPTION_TOKEN] = resumption_token.parse_token(self.service_id, params[RESUMPTION_TOKEN])
if len([i for i in ["offset", "keys"] if i in params[RESUMPTION_TOKEN]]) != 2:
msg = ": Unknown Error"
if "error" in params[RESUMPTION_TOKEN]:
msg = ": %s" % params[RESUMPTION_TOKEN]["error"]
raise BadArgumentError("Bad Resumption Token%s" % msg)
params['param_count'] = param_count
log.debug(json.dumps(params))
return params
def listGeneral(self, h , body , params, includeDocs,verb = 'GET'):
data = self.get_base_response(verb,body)
try:
from_date, until_date = self._test_time_params(params)
except Exception as ex:
log.error(ex)
data['OK'] = False
data['error'] = 'badArgument'
yield json.dumps(data)
return
data['request']['from'] = from_date
data['request']['until'] = until_date
if from_date > until_date:
data['OK'] = False
data['error'] = 'badArgument'
yield json.dumps(data)
else:
self._getServiceDocment(includeDocs)
resumption_token = None
count = 0
lastID = None
lastKey = None
if self.enable_flow_control and params.has_key('resumption_token'):
resumption_token = rt.parse_token(self.service_id,params['resumption_token'])
if includeDocs:
data['listrecords'] = []
viewResults = h.list_records(from_date,until_date,resumption_token=resumption_token, limit=self.limit)
debug_map = lambda doc: {'record':{"header":{'identifier':doc['id'], 'datestamp':doc['key']+"Z",'status':'active'},'resource_data':doc['doc']}}
else:
data['listidentifiers'] = []
viewResults = h.list_identifiers(from_date,until_date,resumption_token=resumption_token, limit=self.limit)
debug_map = lambda doc:{"header":{'identifier':doc['id'], 'datestamp':doc['key']+"Z",'status':'active'}}
base_response = json.dumps(data).split('[')
yield base_response[0] +'['
first = True
for data in viewResults:
lastID = data['id']
lastKey = data['key']
count += 1
if not first:
yield ',\n'
first = False
yield json.dumps(debug_map(data))
if self.enable_flow_control and self.limit <= count:
token = rt.get_token(serviceid=self.service_id,startkey=lastKey,endkey=helpers.convertToISO8601Zformat(until_date),startkey_docid=lastID,from_date=helpers.convertToISO8601Zformat(from_date),until_date=helpers.convertToISO8601Zformat(until_date))
resp = base_response[1]
yield resp[:-1] +(',"resumption_token":"%s"' %token) +resp[-1:]
elif self.limit > count:
resp = base_response[1]
yield resp[:-1] +(',"resumption_token":"%s"' %'null') +resp[-1:]
else:
yield base_response[1]
def list_records(self, h , body , params, verb = 'GET' ):
data = self.get_base_response(verb,body)
if params.has_key('from'):
data['request']['from'] = params['from']
if params.has_key('until'):
data['request']['until'] = params['until']
from_date, until_date = self._test_time_params(params)
data['listrecords'] = []
self._getServiceDocment(False)
resumption_token = None
count = 0
lastID = None
lastKey = None
if self.enable_flow_control and params.has_key('resumption_token'):
resumption_token = rt.parse_token(self.service_id,params['resumption_token'])
base_response = json.dumps(data).split('[')
yield base_response[0] +'['
def debug_map(doc):
data ={'record':{"header":{'identifier':doc['_id'], 'datestamp':helpers.convertToISO8601Zformat(datetime.today()),'status':'active'},'resource_data':doc}}
return data
if from_date > until_date:
data['OK'] = False
data['error'] = 'badArgument'
else:
first = True
for data in h.list_records(from_date,until_date,resumption_token=resumption_token, limit=self.limit):
lastID = data['id']
lastKey = data['key']
doc = data['doc']
count += 1
if not first:
yield ',\n'
first = False
yield json.dumps(debug_map(doc))
if self.enable_flow_control and self.limit <= count:
token = rt.get_token(serviceid=self.service_id,startkey=lastKey,endkey=helpers.convertToISO8601Zformat(until_date),startkey_docid=lastID,from_date=helpers.convertToISO8601Zformat(from_date),until_date=helpers.convertToISO8601Zformat(until_date))
resp = base_response[1]
yield resp[:-1] +(',"resumption_token":"%s"' %token) +resp[-1:]
else:
yield base_response[1]
def _parse_params(self, req_params):
params = {}
start, end = self._get_dates(req_params)
if start is not None:
params[START_DATE] = start
params[END_DATE] = end
if IDENTITY in req_params:
params[IDENTITY] = req_params[IDENTITY].lower()
if ANY_TAGS in req_params:
params[ANY_TAGS] = req_params[ANY_TAGS].lower()
if IDS_ONLY in req_params:
params[IDS_ONLY] = req_params[IDS_ONLY] in ['T', 't', 'True', 'true', True]
else:
params[IDS_ONLY] = False
if RESUMPTION_TOKEN in req_params and req_params[RESUMPTION_TOKEN] is not None:
resp_params = resumption_token.parse_token(self.service_id, req_params[RESUMPTION_TOKEN])
params[RESUMPTION_TOKEN] = resp_params
if ANY_TAGS in resp_params:
params[ANY_TAGS] = resp_params[ANY_TAGS]
if IDENTITY in resp_params:
params[IDENTITY] = resp_params[IDENTITY]
return params
def _parseParams(self,inputParams):
data = {
'by_doc_ID':False,
'by_resource_ID':True,
'ids_only': False,
'request_IDs': [],
}
if inputParams.has_key('by_doc_ID'):
data['by_doc_ID'] = inputParams['by_doc_ID'] in trues
if data['by_doc_ID']:
data['by_resource_ID'] = False
if inputParams.has_key('by_resource_ID'):
data['by_resource_ID'] = inputParams['by_resource_ID'] in trues
if inputParams.has_key('ids_only'):
data['ids_only'] = inputParams['ids_only'] in trues
if inputParams.has_key('resumption_token'):
data['resumption_token'] = rt.parse_token('obtain',inputParams['resumption_token'])
log.debug(data['resumption_token'])
if inputParams.has_key('request_IDs'):
data['request_IDs'] = inputParams['request_IDs']
if inputParams.has_key('callback'):
data['callback'] = inputParams['callback']
return data
def _parseParams(self, flow_control=False, serviceid=None):
params = {}
req_params = self._getParams()
if (req_params.has_key('verb') == False):
raise BadVerbError()
verb = params["verb"] = req_params['verb']
if verb not in [
"GetRecord", "ListRecords", "ListIdentifiers", "Identify",
"ListMetadataFormats", "ListSets"
]:
raise BadVerbError()
if verb == 'GetRecord' or verb == 'ListRecords' or verb == 'ListIdentifiers':
if req_params.has_key('metadataPrefix') == False:
raise BadArgumentError(
'metadataPrefix is a required parameter.', verb)
params["metadataPrefix"] = metadataPrefix = req_params[
'metadataPrefix']
if metadataPrefix != o_mod.getMetadataPrefix(metadataPrefix):
raise CannotDisseminateFormatError(verb)
if verb == 'GetRecord' or verb == 'ListMetadataFormats':
if req_params.has_key('by_doc_ID') and req_params.has_key(
'by_resource_ID'):
if self._isTrue(req_params['by_doc_ID']) == self._isTrue(
req_params['by_resource_ID']):
raise BadArgumentError(
'by_doc_ID and by_resource_ID have conflicting values.',
verb)
if req_params.has_key('by_doc_ID'):
params['by_doc_ID'] = self._isTrue(req_params['by_doc_ID'])
params['by_resource_ID'] = not params['by_doc_ID']
else:
params['by_doc_ID'] = False
params['by_resource_ID'] = not params['by_doc_ID']
if req_params.has_key('by_resource_ID'):
params['by_resource_ID'] = self._isTrue(
req_params['by_resource_ID'])
params['by_doc_ID'] = not params['by_resource_ID']
if verb == 'ListRecords' or verb == 'ListIdentifiers':
if flow_control and req_params.has_key('resumptionToken'):
from lr.lib import resumption_token
token = req_params['resumptionToken']
log.debug("resumptionToken: %s" % token)
try:
parsed = resumption_token.parse_token(serviceid, token)
if 'error' in parsed:
raise BadResumptionTokenError(
verb, msg=params['resumptionToken']['error'])
params['resumptionToken'] = parsed
if "from_date" in parsed:
req_params["from"] = parsed["from_date"]
if "until_date" in parsed:
req_params["until"] = parsed["until_date"]
except Exception as e:
raise BadResumptionTokenError(verb, msg=e.message)
from_date_gran = None
until_date_gran = None
if req_params.has_key('from'):
try:
log.error("From 0: {0}".format(req_params['from']))
from_date = iso8601.parse_date(req_params['from'])
log.error("From 1: {0}".format(from_date))
params['from'] = h.convertToISO8601UTC(from_date)
log.error("From 2: {0}".format(params['from']))
from_date_gran = h.getISO8601Granularity(
req_params['from'])
except:
log.error("from: uhh ohh!")
raise BadArgumentError('from does not parse to ISO 8601.',
verb)
else:
params['from'] = None
if req_params.has_key('until'):
try:
log.error("Until 0: {0}".format(req_params['until']))
until_date = iso8601.parse_date(req_params['until'])
log.error("Until 1: {0}".format(until_date))
params['until'] = h.convertToISO8601UTC(until_date)
log.error("Until 2: {0}".format(params['until']))
until_date_gran = h.getISO8601Granularity(
req_params['until'])
except:
raise BadArgumentError('until does not parse to ISO 8601.',
verb)
else:
params['until'] = None
if params['from'] != None and params['until'] != None:
if params['from'] > params['until']:
raise BadArgumentError('until cannot preceed from.', verb)
if from_date_gran != until_date_gran:
raise BadArgumentError(
'from and until parameters do not use the same granularity.',
verb)
harvestServiceGranularity = h.getOAIPMHServiceGranularity()
if params[
'from'] != None and from_date_gran > harvestServiceGranularity:
raise BadArgumentError(
'from is more granular than Harvest service permits', verb)
if params[
'until'] != None and until_date_gran > harvestServiceGranularity:
raise BadArgumentError(
'until is more granular than Harvest service permits',
verb)
if (from_date_gran != None and from_date_gran.granule != "day" and from_date_gran.granule != "second") or \
(until_date_gran != None and until_date_gran.granule != "day" and until_date_gran.granule != "second"):
formatSupport = "YYYY-MM-DD"
if harvestServiceGranularity.granule == "second":
formatSupport = "YYYY-MM-DD and YYYY-MM-DDThh:mm:ssZ"
raise BadArgumentError(
'from and until support {0} formats' % (formatSupport, ),
verb)
if verb in ['ListMetadataFormats', 'GetRecord'
] and req_params.has_key('identifier'):
params['identifier'] = req_params['identifier']
elif verb == 'ListMetadataFormats':
params['identifier'] = None
params['by_doc_ID'] = None
params['by_resource_ID'] = None
if verb == 'GetRecord' and req_params.has_key('identifier') == False:
raise BadArgumentError('identifier is a required parameter.', verb)
return params
def _parseParams(self, flow_control=False, serviceid=None):
params = {}
req_params = self._getParams()
if (req_params.has_key('verb') == False) :
raise BadVerbError()
verb = params["verb"] = req_params['verb']
if verb not in ["GetRecord", "ListRecords", "ListIdentifiers", "Identify", "ListMetadataFormats", "ListSets"]:
raise BadVerbError()
if verb == 'GetRecord' or verb == 'ListRecords' or verb == 'ListIdentifiers':
if req_params.has_key('metadataPrefix') == False:
raise BadArgumentError('metadataPrefix is a required parameter.', verb)
params["metadataPrefix"] = metadataPrefix = req_params['metadataPrefix']
if metadataPrefix != o_mod.getMetadataPrefix(metadataPrefix):
raise CannotDisseminateFormatError(verb)
if verb == 'GetRecord' or verb == 'ListMetadataFormats':
if req_params.has_key('by_doc_ID') and req_params.has_key('by_resource_ID'):
if self._isTrue(req_params['by_doc_ID']) == self._isTrue(req_params['by_resource_ID']):
raise BadArgumentError('by_doc_ID and by_resource_ID have conflicting values.', verb)
if req_params.has_key('by_doc_ID'):
params['by_doc_ID'] = self._isTrue(req_params['by_doc_ID'])
params['by_resource_ID'] = not params['by_doc_ID']
else:
params['by_doc_ID'] = False
params['by_resource_ID'] = not params['by_doc_ID']
if req_params.has_key('by_resource_ID'):
params['by_resource_ID'] = self._isTrue(req_params['by_resource_ID'])
params['by_doc_ID'] = not params['by_resource_ID']
if verb == 'ListRecords' or verb == 'ListIdentifiers':
if flow_control and req_params.has_key('resumptionToken'):
from lr.lib import resumption_token
token = req_params['resumptionToken']
log.debug("resumptionToken: %s" % token)
try:
parsed = resumption_token.parse_token(serviceid, token)
if 'error' in parsed:
raise BadResumptionTokenError(verb, msg=params['resumptionToken']['error'])
params['resumptionToken'] = parsed
if "from_date" in parsed:
req_params["from"] = parsed["from_date"]
if "until_date" in parsed:
req_params["until"] = parsed["until_date"]
except Exception as e:
raise BadResumptionTokenError(verb, msg=e.message)
from_date_gran = None
until_date_gran = None
if req_params.has_key('from') :
try:
log.error("From 0: {0}".format(req_params['from']))
from_date = iso8601.parse_date(req_params['from'])
log.error("From 1: {0}".format(from_date))
params['from'] = h.convertToISO8601UTC(from_date)
log.error("From 2: {0}".format(params['from']))
from_date_gran = h.getISO8601Granularity(req_params['from'])
except:
log.error("from: uhh ohh!")
raise BadArgumentError('from does not parse to ISO 8601.', verb)
else:
params['from'] = None
if req_params.has_key('until'):
try:
log.error("Until 0: {0}".format(req_params['until']))
until_date = iso8601.parse_date(req_params['until'])
log.error("Until 1: {0}".format(until_date))
params['until'] = h.convertToISO8601UTC(until_date)
log.error("Until 2: {0}".format(params['until']))
until_date_gran = h.getISO8601Granularity(req_params['until'])
except:
raise BadArgumentError('until does not parse to ISO 8601.', verb)
else:
params['until'] = None
if params['from'] != None and params['until'] != None:
if params['from'] > params['until']:
raise BadArgumentError('until cannot preceed from.', verb)
if from_date_gran != until_date_gran:
raise BadArgumentError('from and until parameters do not use the same granularity.', verb)
harvestServiceGranularity = h.getOAIPMHServiceGranularity()
if params['from'] != None and from_date_gran > harvestServiceGranularity:
raise BadArgumentError('from is more granular than Harvest service permits', verb)
if params['until'] != None and until_date_gran > harvestServiceGranularity:
raise BadArgumentError('until is more granular than Harvest service permits', verb)
if (from_date_gran != None and from_date_gran.granule != "day" and from_date_gran.granule != "second") or \
(until_date_gran != None and until_date_gran.granule != "day" and until_date_gran.granule != "second"):
formatSupport = "YYYY-MM-DD"
if harvestServiceGranularity.granule == "second":
formatSupport = "YYYY-MM-DD and YYYY-MM-DDThh:mm:ssZ"
raise BadArgumentError('from and until support {0} formats' % (formatSupport, ), verb)
if verb in ['ListMetadataFormats', 'GetRecord'] and req_params.has_key('identifier'):
params['identifier'] = req_params['identifier']
elif verb == 'ListMetadataFormats':
params['identifier'] = None
params['by_doc_ID'] = None
params['by_resource_ID'] = None
if verb == 'GetRecord' and req_params.has_key('identifier') == False:
raise BadArgumentError('identifier is a required parameter.', verb)
return params
def listGeneral(self, h, body, params, includeDocs, verb='GET'):
data = self.get_base_response(verb, body)
try:
from_date, until_date = self._test_time_params(params)
except:
data['OK'] = False
data['error'] = 'badArgument'
yield json.dumps(data)
return
data['request']['from'] = from_date
data['request']['until'] = until_date
if from_date > until_date:
data['OK'] = False
data['error'] = 'badArgument'
yield json.dumps(data)
else:
self._getServiceDocment(includeDocs)
resumption_token = None
count = 0
lastID = None
lastKey = None
if self.enable_flow_control and params.has_key('resumption_token'):
resumption_token = rt.parse_token(self.service_id,
params['resumption_token'])
if includeDocs:
data['listrecords'] = []
viewResults = h.list_records(from_date,
until_date,
resumption_token=resumption_token,
limit=self.limit)
debug_map = lambda doc: {
'record': {
"header": {
'identifier': doc['id'],
'datestamp': doc['key'] + "Z",
'status': 'active'
},
'resource_data': doc['doc']
}
}
else:
data['listidentifiers'] = []
viewResults = h.list_identifiers(
from_date,
until_date,
resumption_token=resumption_token,
limit=self.limit)
debug_map = lambda doc: {
"header": {
'identifier': doc['id'],
'datestamp': doc['key'] + "Z",
'status': 'active'
}
}
base_response = json.dumps(data).split('[')
yield base_response[0] + '['
first = True
for data in viewResults:
lastID = data['id']
lastKey = data['key']
count += 1
if not first:
yield ',\n'
first = False
yield json.dumps(debug_map(data))
if self.enable_flow_control and self.limit <= count:
token = rt.get_token(
serviceid=self.service_id,
startkey=lastKey,
endkey=helpers.convertToISO8601Zformat(until_date),
startkey_docid=lastID,
from_date=helpers.convertToISO8601Zformat(from_date),
until_date=helpers.convertToISO8601Zformat(until_date))
resp = base_response[1]
yield resp[:-1] + (',"resumption_token":"%s"' %
token) + resp[-1:]
elif self.limit > count:
resp = base_response[1]
yield resp[:-1] + (',"resumption_token":"%s"' %
'null') + resp[-1:]
else:
yield base_response[1]
