def update_friendly(self):
"""Updates the QuickQuery friendly label (label_qq_friendly)."""
try:
p = self.gather_values()
except QuickOsmException as e:
self.dialog.display_quickosm_exception(e)
return
except Exception as e:
self.dialog.display_critical_exception(e)
return
# Make the query, in order to create the friendly message
query_factory = QueryFactory(query_type=p['query_type'],
key=p['key'],
value=p['value'],
area=p['place'],
around_distance=p['distance'],
osm_objects=p['osm_objects'],
timeout=p['timeout'])
try:
msg = query_factory.friendly_message()
except QuickOsmException as e:
self.dialog.label_qq_friendly.setStyleSheet(
'QLabel { color : red; }')
self.dialog.label_qq_friendly.setText(str(e))
except Exception as e:
self.dialog.display_critical_exception(e)
self.dialog.label_qq_friendly.setText('')
else:
self.dialog.label_qq_friendly.setStyleSheet('')
self.dialog.label_qq_friendly.setText(msg)
def build_query(self) -> Dict[str, str]:
"""Build the query requested."""
query_factory = QueryFactory(
query_type=self.QUERY_TYPE,
key=self.key,
value=self.value,
area=self.area,
around_distance=self.distance,
timeout=self.timeout)
raw_query = query_factory.make(QueryLanguage.OQL)
self.feedback.pushInfo(query_factory.friendly_message())
query_preparation = QueryPreparation(
raw_query,
area=self.area,
extent=self.extent,
overpass=self.server
)
raw_query = query_preparation.prepare_query()
url = query_preparation.prepare_url()
outputs = {
self.OUTPUT_URL: url,
self.OUTPUT_OQL_QUERY: raw_query,
}
return outputs
def process_quick_query(dialog: QDialog = None,
description: str = None,
type_multi_request: list = None,
query_type: QueryType = None,
key: Union[str, List[str]] = None,
value: Union[str, List[str]] = None,
bbox: QgsRectangle = None,
area: str = None,
distance: int = None,
osm_objects: List[OsmType] = None,
metadata: str = 'body',
timeout: int = 25,
output_directory: str = None,
output_format: Format = None,
prefix_file: str = None,
layer_name: str = None,
white_list_values: dict = None,
output_geometry_types: list = None,
config_outputs: dict = None) -> int:
"""
Generate a query and send it to process_query.
"""
if dialog.feedback_process.isCanceled():
return None
# Building the query
query_factory = QueryFactory(type_multi_request=type_multi_request,
query_type=query_type,
key=key,
value=value,
area=area,
around_distance=distance,
osm_objects=osm_objects,
timeout=timeout,
print_mode=metadata)
query = query_factory.make(QueryLanguage.OQL)
if description is None:
description = query_factory.friendly_message()
LOGGER.info(description)
LOGGER.info('Query: {}'.format(layer_name))
# Call process_query with the new query
return process_query(
dialog=dialog,
query=query,
description=description,
key=key,
value=value,
type_multi_request=type_multi_request,
area=area,
bbox=bbox,
output_dir=output_directory,
output_format=output_format,
prefix_file=prefix_file,
output_geometry_types=output_geometry_types,
layer_name=layer_name,
white_list_values=white_list_values,
config_outputs=config_outputs,
)
def save_query(self):
"""Save a query in a preset."""
properties = self.gather_values()
# Make the query
query_factory = QueryFactory(
type_multi_request=properties['type_multi_request'],
query_type=properties['query_type'],
key=properties['key'],
value=properties['value'],
area=properties['place'],
around_distance=properties['distance'],
osm_objects=properties['osm_objects'],
timeout=properties['timeout'],
print_mode=properties['metadata']
)
query = query_factory.make(QueryLanguage.OQL)
description = query_factory.friendly_message()
q_manage = QueryManagement(
query=query,
name=properties['layer_name'],
description=description,
advanced=False,
type_multi_request=properties['type_multi_request'],
keys=properties['key'],
values=properties['value'],
area=properties['place'],
bbox=properties['bbox'],
output_geometry_types=properties['outputs'],
output_directory=properties['output_directory'],
output_format=properties['output_format']
)
if self.existing_preset:
preset_folder = query_preset()
presets = filter(
lambda folder: os.path.isdir(join(preset_folder, folder)), os.listdir(preset_folder))
chosen_preset = QInputDialog.getItem(
self.dialog, tr('Add in an existing preset'),
tr('Please select the preset in which the query will be added:'),
presets, editable=False
)
if chosen_preset[1]:
q_manage.add_query_in_preset(chosen_preset[0])
else:
q_manage.add_preset(properties['layer_name'])
self.dialog.external_panels[Panels.MapPreset].update_personal_preset_view()
item = self.dialog.menu_widget.item(self.dialog.preset_menu_index)
self.dialog.menu_widget.setCurrentItem(item)
def process_quick_query(
dialog=None,
query_type=None,
key=None,
value=None,
bbox=None,
area=None,
distance=None,
osm_objects=None,
timeout=25,
output_directory=None,
prefix_file=None,
output_geometry_types=None):
"""
Generate a query and send it to process_query.
"""
# Building the query
query_factory = QueryFactory(
query_type=query_type,
key=key,
value=value,
area=area,
around_distance=distance,
osm_objects=osm_objects,
timeout=timeout
)
query = query_factory.make()
LOGGER.info(query_factory.friendly_message())
# Generate layer name as following (if defined)
if not key:
key = tr('allKeys')
distance_string = None
if distance:
distance_string = '{}'.format(distance)
expected_name = [key, value, area, distance_string]
layer_name = '_'.join([f for f in expected_name if f])
LOGGER.info('Query: {}'.format(layer_name))
# Call process_query with the new query
return process_query(
dialog=dialog,
query=query,
area=area,
bbox=bbox,
output_dir=output_directory,
prefix_file=prefix_file,
output_geometry_types=output_geometry_types,
layer_name=layer_name)
