def _process_street_single(request):
"""Procesa una request GET para consultar datos de calles.
En caso de ocurrir un error de parseo, se retorna una respuesta HTTP 400.
Args:
request (flask.Request): Request GET de flask.
Raises:
data.DataConnectionException: En caso de ocurrir un error de
conexión con la capa de manejo de datos.
Returns:
flask.Response: respuesta HTTP
"""
try:
qs_params = params.PARAMS_STREETS.parse_get_params(request.args)
except params.ParameterParsingException as e:
return formatter.create_param_error_response_single(e.errors, e.fmt)
query, fmt = _build_street_query_format(qs_params)
if fmt[N.FORMAT] == 'shp':
query['fields'] += (N.GEOM, )
es = get_elasticsearch()
search = data.StreetsSearch(query)
data.ElasticsearchSearch.run_searches(es, [search])
query_result = QueryResult.from_entity_list(search.result.hits,
search.result.total,
search.result.offset)
return formatter.create_ok_response(N.STREETS, query_result, fmt)
def run_street_queries(es, params_list, queries, formats):
"""Punto de entrada del módulo 'street.py'. Toma una lista de consultas de
calles y las ejecuta, devolviendo los resultados QueryResult.
Args:
es (Elasticsearch): Conexión a Elasticsearch.
params_list (list): Lista de ParametersParseResult.
queries (list): Lista de búsquedas, generadas a partir de
'params_list'.
formats (list): Lista de parámetros de formato de cada búsqueda, en
forma de diccionario.
Returns:
list: Lista de QueryResult, una por cada búsqueda.
"""
searches = []
for query, fmt in zip(queries, formats):
processed_query = query.copy()
if N.FULL_NAME in fmt[N.FIELDS]:
# La nomenclatura incluye el nombre de la provincia y del depto.,
# agregar esos campos a la query para luego poder extraer sus
# nombres.
processed_query['fields'] += (N.STATE, N.DEPT)
searches.append(data.StreetsSearch(processed_query))
data.ElasticsearchSearch.run_searches(es, searches)
for search, fmt in zip(searches, formats):
if N.FULL_NAME in fmt[N.FIELDS]:
# Agregar nomenclatura a cada hit del resultado.
for hit in search.result.hits:
full_name = '{}, {}, {}'.format(hit[N.NAME],
hit[N.DEPT][N.NAME],
hit[N.STATE][N.NAME])
hit[N.FULL_NAME] = full_name
return [
QueryResult.from_entity_list(search.result.hits,
params.received_values(),
search.result.total, search.result.offset)
for search, params in zip(searches, params_list)
]
def _build_street_search(self, street, add_number=False):
"""Método de utilidad para crear búsquedas de tipo StreetsSearch.
Args:
street (str): Nombre de la calle a buscar.
add_number (bool): Si es verdadero, agrega a la búsqueda un
filtrado por altura, utilizando el atributo
'_numerical_door_number'.
"""
query = self._query.copy()
query['name'] = street
if add_number and self._numerical_door_number:
query['number'] = self._numerical_door_number
query['size'] = constants.MAX_RESULT_LEN
query['offset'] = 0
return data.StreetsSearch(query)
def planner_steps(self):
"""Crea un iterador de ElasticsearchSearch, representando los pasos
requeridos para completar la búsqueda de los datos la dirección.
Pasos requeridos:
1) Búsqueda de la calle principal.
Yields:
ElasticsearchSearch: Búsqueda que debe ser ejecutada por el
invocador de 'next()'.
"""
query = self._query.copy()
query['name'] = self._address_data.street_names[0]
if self._numerical_door_number:
query['number'] = self._numerical_door_number
self._elasticsearch_result = yield data.StreetsSearch(query)
def _process_street_bulk(request):
"""Procesa una request POST para consultar datos de calles.
En caso de ocurrir un error de parseo, se retorna una respuesta HTTP 400.
Args:
request (flask.Request): Request POST de flask.
Raises:
data.DataConnectionException: En caso de ocurrir un error de
conexión con la capa de manejo de datos.
Returns:
flask.Response: respuesta HTTP
"""
try:
body_params = params.PARAMS_STREETS.parse_post_params(
request.args, request.json, N.STREETS)
except params.ParameterParsingException as e:
return formatter.create_param_error_response_bulk(e.errors)
queries = []
formats = []
for parsed_params in body_params:
query, fmt = _build_street_query_format(parsed_params)
queries.append(query)
formats.append(fmt)
es = get_elasticsearch()
searches = [data.StreetsSearch(query) for query in queries]
data.ElasticsearchSearch.run_searches(es, searches)
query_results = [
QueryResult.from_entity_list(search.result.hits, search.result.total,
search.result.offset)
for search in searches
]
return formatter.create_ok_response_bulk(N.STREETS, query_results, formats)