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')