def wrapper(*args, **kwargs):
logging.debug("Getting dataset from id")
try:
dataset_object = DatasetService.get(kwargs['dataset_id'])
except DatasetNotFound:
return error(status=404,
detail="Dataset with id {} doesn't exist".format(
kwargs['dataset_id']))
connector_type = dataset_object.get('connectorType', None)
provider = dataset_object.get('provider', None)
if connector_type != "rest":
return error(
status=422,
detail=
"This operation is only supported for datasets with connectorType 'rest'"
)
if provider != "nexgddp" and provider != "loca":
return error(
status=422,
detail=
"This operation is only supported for datasets with providers ['nexgddp', 'loca']"
)
kwargs['dataset'] = dataset_object
return func(*args, **kwargs)
def wrapper(*args, **kwargs):
logging.debug("Checking microservice user")
logged_user = json.loads(request.args.get("loggedUser", '{}'))
if logged_user.get("id") == "microservice":
logging.debug("is microservice")
return func(*args, **kwargs)
else:
return error(status=403, detail="Not authorized")
def wrapper(*args, **kwargs):
logging.debug('Getting layer')
layer = request.view_args.get('layer', None)
logging.debug(f'layer: {layer}')
try:
layer_object = LayerService.get(layer)
except LayerNotFound as e:
return error(status=404, detail='Layer not found')
logging.debug(f'layer_object: {layer_object}')
kwargs["layer_object"] = layer_object
return func(*args, **kwargs)
def wrapper(*args, **kwargs):
geostore = request.args.get('geostore', None)
if not geostore:
bbox = []
else:
try:
_, bbox = GeostoreService.get(geostore)
except GeostoreNotFound:
return error(status=404, detail='Geostore not found')
kwargs["bbox"] = bbox
return func(*args, **kwargs)
def get_tile(z,
x,
y,
model,
scenario,
year,
style,
indicator,
layer,
compare_year=None,
dset_b=None,
no_data=None):
logging.info(f'Getting tile for {z} {x} {y}')
logging.debug(compare_year)
bbox = TileService.get_bbox(x, y, z)
logging.debug(f"bbox: {bbox}")
bounds = ColoringHelper.get_data_bounds(style)
logging.debug(bounds)
if compare_year:
logging.debug(f"[rout] compare_year: {compare_year}")
if not dset_b:
dset_b = f"{scenario}_{model}_processed"
rasterfile = QueryService.get_tile_diff_query(bbox, year, model,
scenario, indicator,
bounds, compare_year,
dset_b)
else:
rasterfile = QueryService.get_tile_query(bbox, year, model, scenario,
indicator, bounds)
try:
colored_response = ColoringHelper.colorize(rasterfile, style=style)
except CoverageNotFound as e:
return error(status=404, detail=e.message)
logging.debug(f"colored_response: {colored_response}")
# logging.debug(f"colored_response.shape: {colored_response.shape}")
if no_data is not None:
logging.debug("Creating mask")
maskfile = QueryService.get_tile_mask_query(bbox, year, model,
scenario, indicator,
no_data)
ColoringHelper.blend_alpha(colored_response, maskfile)
os.remove(maskfile)
else:
logging.debug("No nodata values")
# Saving file in cache
logging.debug(f'Requested path is: {request.path}')
# Uploading file to storage.
StorageService.upload_file(colored_response, layer, str(z), str(x), str(y),
year, compare_year, dset_b)
tile_response = send_file(io.BytesIO(open(colored_response, 'rb').read()),
attachment_filename='tile.png',
mimetype='image/png')
os.remove(colored_response)
return tile_response, 200
def query(dataset_id, bbox, dataset):
"""NEXGDDP QUERY ENDPOINT"""
logging.info('[ROUTER] Doing Query of dataset ' + dataset_id)
# Get and deserialize
table_name = dataset.get('tableName')
temporal_resolution = table_name.split('_')[-1]
logging.debug(f"temporal_resolution: {temporal_resolution}")
scenario, model = table_name.rsplit('/')
request_json = request.get_json() or {}
sql = request.args.get('sql', None) or request_json.get('sql', None)
if not sql:
return error(status=400, detail='sql must be provided')
# convert
try:
_, json_sql = QueryService.convert(sql)
except SqlFormatError as e:
logging.error(e.message)
return error(status=500, detail=e.message)
except Exception as e:
logging.error('[ROUTER]: ' + str(e))
return error(status=500, detail='Generic Error')
try:
select = get_sql_select(json_sql)
logging.debug("Select")
logging.debug(select)
except Exception as e:
return error(status=400, detail='Invalid Select')
# Fields
try:
fields_xml = QueryService.get_rasdaman_fields(scenario, model)
fields = XMLService.get_fields(fields_xml)
except TableNameNotValid as e:
return error(status=404, detail='Table name not valid')
fields.update({'all': {'type': 'array'}})
# Prior to validating dates, the [max|min](year) case has to be dealt with:
def is_year(clause):
if (clause.get('function') == 'max' or clause.get('function')
== 'min') and clause.get('argument') == 'year':
return True
else:
return False
# All statements in the select must have the prior form
select_year = all(list(map(is_year, select)))
if select_year == True:
result = {}
domain = QueryService.get_domain(scenario, model)
logging.debug(f"domain: {domain}")
for element in select:
result[
element['alias'] if element['alias'] else
f"{element['function']}({element['argument']})"] = domain.get(
element['argument']).get(element['function'])
return jsonify(data=[result]), 200
if not bbox:
return error(
status=400,
detail='No coordinates provided. Include geostore or lat & lon')
# Get years
try:
years = get_years(json_sql, temporal_resolution)
except PeriodNotValid as e:
return error(status=400, detail=e.message)
logging.debug("years: ")
logging.debug(years)
# if len(years) == 0:
# domain = QueryService.get_domain(scenario, model)
# logging.debug(f"domain: {domain}")
# years = list(range(
# int(dateutil.parser.parse(domain['year']['min'], fuzzy_with_tokens=True)[0].year),
# int(dateutil.parser.parse(domain['year']['max'], fuzzy_with_tokens=True)[0].year + 1),
# 10
# )) if temporal_resolution == 'decadal' else ['1971', '2021', '2051']
# logging.debug(f"years: {years}")
# return error(status=400, detail='Period of time must be set')
results = {}
for element in select:
try:
if element['argument'] not in fields:
raise InvalidField(message='Invalid Fields')
elif element['function'] == 'temporal_series' and element[
'argument'] == 'year':
results[
element['alias'] if element['alias'] else 'year'] = years
elif element['function'] == 'temporal_series' and element[
'argument'] == 'all':
query_results = QueryService.get_all_data(
scenario, model, years, bbox)
return jsonify(data=query_results), 200
elif element['function'] == 'temporal_series':
indicator = element['argument']
results[element['alias'] if element['alias'] else
indicator] = QueryService.get_temporal_series(
scenario, model, years, indicator, bbox)
else:
function = element['function']
indicator = element['argument']
results[element['alias'] if element['alias'] else
f"{function}({indicator})"] = QueryService.get_stats(
scenario, model, years, indicator, bbox, function)
except InvalidField as e:
return error(status=400, detail=e.message)
except PeriodNotValid as e:
return error(status=400, detail=e.message)
except GeostoreNeeded as e:
return error(status=400, detail=e.message)
except CoordinatesNeeded as e:
return error(status=400, detail=e.message)
output = [dict(zip(results, col)) for col in zip(*results.values())]
# return jsonify(data=response), 200
return jsonify(data=output), 200
def internal_server_error(e):
return error(status=500, detail='Internal Server Error')
def gone(e):
return error(status=410, detail='Gone')
def method_not_allowed(e):
return error(status=405, detail='Method Not Allowed')
def page_not_found(e):
return error(status=404, detail='Not Found')
def forbidden(e):
return error(status=403, detail='Forbidden')