def __init__(self, parent=None):
"""Constructor."""
super().__init__(parent)
self.setupUi(self)
self.blocked = False
self.previous_map_tool = None
self.extent_tool = None
for name in SERVICE_MANAGER.available_predefined_bounding_boxes():
extent = SERVICE_MANAGER.predefined_bounding_box(name)
item = QListWidgetItem(extent['title'])
item.setData(Qt.UserRole, name)
item.setData(Qt.UserRole + 1, extent.get('read_only', False))
item.setData(Qt.UserRole + 2, extent.get('title', ''))
item.setData(Qt.UserRole + 3, extent.get('boundingbox', [0, 0, 0, 0])[0])
item.setData(Qt.UserRole + 4, extent.get('boundingbox', [0, 0, 0, 0])[1])
item.setData(Qt.UserRole + 5, extent.get('boundingbox', [0, 0, 0, 0])[2])
item.setData(Qt.UserRole + 6, extent.get('boundingbox', [0, 0, 0, 0])[3])
self.region_list.addItem(item)
self.region_list.currentItemChanged.connect(self._item_changed)
self.button_add.clicked.connect(self._add_item)
self.button_remove.clicked.connect(self._remove_item)
self.edit_label.textEdited.connect(self._update_item)
self.spin_min_long.valueChanged.connect(self._update_item)
self.spin_max_long.valueChanged.connect(self._update_item)
self.spin_min_lat.valueChanged.connect(self._update_item)
self.spin_max_lat.valueChanged.connect(self._update_item)
self.button_draw_on_map.clicked.connect(self.draw_rect_on_map)
def set_service_id(self, service_id):
self.service_id = service_id
config = SERVICE_MANAGER.service_details(self.service_type, self.service_id)
if 'fields' in config['default']:
self.output_fields = config['default']['fields']
self.service_config = SERVICE_MANAGER.service_details(self.service_type, self.service_id)
if not self.service_config['settings'].get('outputtext', False):
if self.radio_basic_output.isChecked():
self.radio_extended_output.setChecked(True)
self.radio_basic_output.setEnabled(False)
else:
self.radio_basic_output.setEnabled(True)
if not self.service_config['settings'].get('outputxml', False):
if self.radio_extended_output.isChecked():
self.radio_basic_output.setChecked(True)
self.radio_extended_output.setEnabled(False)
else:
self.radio_extended_output.setEnabled(True)
if not self.service_config['settings'].get('querycontributorid'):
if self.radio_contributor.isChecked():
self.radio_single_event.setChecked(True)
self.radio_contributor.setEnabled(False)
else:
self.radio_contributor.setEnabled(True)
if self.radio_contributor.isChecked() and self.service_config['settings'].get('querycontributor'):
self.button_refresh_contributors.setEnabled(True)
else:
self.button_refresh_contributors.setEnabled(False)
self._update_contributor_list(SERVICE_MANAGER.get_contributors(self.service_type, self.service_id))
def save_changes(self):
"""
Saves the changes made in the widget
"""
config = self.get_config()
SERVICE_MANAGER.save_service(self.service_type, self.service_id,
config)
def _populated_predefined_areas(self):
"""
Populates the predefined area choices
"""
self.combo_predefined_area.clear()
for name in SERVICE_MANAGER.available_predefined_bounding_boxes():
extent = SERVICE_MANAGER.predefined_bounding_box(name)
self.combo_predefined_area.addItem(extent['title'], name)
def _remove_service(self):
service_type = self.get_current_service_type()
service_id = self.get_current_service_id(service_type)
if QMessageBox.question(self, self.tr('Remove Service'),
self.tr('Are you sure you want to remove "{}"?'.format(service_id))) != QMessageBox.Yes:
return
SERVICE_MANAGER.remove_service(service_type, service_id)
def set_service_id(self, service_id):
self.service_id = service_id
config = SERVICE_MANAGER.service_details(self.service_type,
self.service_id)
if 'fields' in config['default']:
self.output_fields = config['default']['fields']
self.service_config = SERVICE_MANAGER.service_details(
self.service_type, self.service_id)
def _save_configuration(self):
service_type = self.get_current_service_type()
name, ok = QInputDialog.getText(self, self.tr('Save Service Configuration'),
self.tr('Save the current service configuration as'))
if not name or not ok:
return
filter_widget = self.get_service_filter_widget(service_type)
SERVICE_MANAGER.save_service(service_type, name, filter_widget.to_service_definition())
self.set_current_service(service_type, name)
def set_service_id(self, service_id: str):
"""
Sets the associated service ID
"""
self.service_id = service_id
config = SERVICE_MANAGER.service_details(self.service_type,
self.service_id)
if 'fields' in config['default']:
self.output_fields = config['default']['fields']
self.service_config = SERVICE_MANAGER.service_details(
self.service_type, self.service_id)
def refreshOgcWidgets(self):
"""
read the ogc_combo and fill it with the services
"""
self.ogc_list_model.clear()
ogc_selection = self.ogc_combo.currentData()
services = SERVICE_MANAGER.available_services(ogc_selection)
group_items = {}
for service in services:
service_config = SERVICE_MANAGER.service_details(
ogc_selection, service)
group = service_config.get('group')
if not group or group in group_items:
continue
group_item = QStandardItem(group)
group_item.setFlags(Qt.ItemIsEnabled)
self.ogc_list_model.appendRow([group_item])
group_items[group] = group_item
first_item = None
for service in services:
item = QStandardItem(service)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item.setData(service, role=Qt.UserRole)
if not first_item:
first_item = item
service_config = SERVICE_MANAGER.service_details(
ogc_selection, service)
group = service_config.get('group')
if group:
parent = group_items[group]
parent.appendRow([item])
else:
self.ogc_list_model.appendRow([item])
self.ogc_list.expandAll()
first_item_index = self.ogc_list_model.indexFromItem(first_item)
self.ogc_list.selectionModel().select(
first_item_index, QItemSelectionModel.ClearAndSelect)
service_config = SERVICE_MANAGER.service_details(
ogc_selection, self.get_current_service_id(ogc_selection))
self.button_ogc_edit_service.setEnabled(
not service_config['read_only'])
self.button_ogc_rename_service.setEnabled(
not service_config['read_only'])
self.button_ogc_remove_service.setEnabled(
not service_config['read_only'])
def refreshOgcWidgets(self):
"""
read the ogc_combo and fill it with the services
"""
self.ogc_list.clear()
ogc_selection = self.ogc_combo.currentData()
self.ogc_list.addItems(SERVICE_MANAGER.available_services(ogc_selection))
self.ogc_list.setCurrentRow(0)
service_config = SERVICE_MANAGER.service_details(ogc_selection, self.get_current_service_id(ogc_selection))
self.button_ogc_edit_service.setEnabled(not service_config['read_only'])
self.button_ogc_rename_service.setEnabled(not service_config['read_only'])
self.button_ogc_remove_service.setEnabled(not service_config['read_only'])
def _populate_style_combo(combo, service_type: str):
"""
Populates a style combo with matching styles of the specified type
"""
prev_entry = combo.currentText()
combo.clear()
styles = SERVICE_MANAGER.styles_for_service_type(service_type)
for s in styles:
combo.addItem(SERVICE_MANAGER.get_style(s)['label'], s)
prev_index = combo.findData(prev_entry)
if prev_index >= 0:
combo.setCurrentIndex(prev_index)
else:
combo.setCurrentIndex(0)
def _rename_service(self):
service_type = self.get_current_service_type()
service_id = self.get_current_service_id(service_type)
dlg = QgsNewNameDialog(service_id, service_id, [], existing=SERVICE_MANAGER.available_services(service_type))
dlg.setHintString(self.tr('Rename service configuration to'))
dlg.setWindowTitle(self.tr('Rename Service Configuration'))
dlg.setOverwriteEnabled(False)
dlg.setConflictingNameWarning(self.tr('A configuration with this name already exists'))
if not dlg.exec_():
return
new_name = dlg.name()
SERVICE_MANAGER.rename_service(service_type, service_id, new_name)
self.set_current_service(service_type, new_name)
def restore_settings(self, prefix):
s = QgsSettings()
if self.service_id:
service_config = SERVICE_MANAGER.service_details(self.service_type, self.service_id)
else:
service_config = None
self.edit_event_id.setText(s.value('/plugins/qquake/{}_single_event_id'.format(prefix), '', str))
self.edit_contributor_id.setCurrentText(s.value('/plugins/qquake/{}_contributor_id'.format(prefix), '', str))
if s.value('/plugins/qquake/{}_single_event_checked'.format(prefix), True, bool):
self.radio_single_event.setChecked(True)
if s.value('/plugins/qquake/{}_multi_event_checked'.format(prefix), True, bool):
self.radio_multiple_events.setChecked(True)
if s.value('/plugins/qquake/{}_contributor_checked'.format(prefix), True, bool):
if self.radio_contributor.isEnabled():
self.radio_contributor.setChecked(True)
else:
self.radio_single_event.setChecked(True)
if not service_config or service_config['settings'].get('outputtext', False):
self.radio_basic_output.setChecked(
s.value('/plugins/qquake/{}_single_event_basic_checked'.format(prefix), True, bool))
if not service_config or service_config['settings'].get('outputxml', False):
self.radio_extended_output.setChecked(
s.value('/plugins/qquake/{}_single_event_extended_checked'.format(prefix), False, bool))
def restore_settings(self, prefix: str, suffix: str):
"""
Restores widget state from settings
"""
s = QgsSettings()
if self.service_id:
service_config = SERVICE_MANAGER.service_details(
self.service_type, self.service_id)
else:
service_config = None
if not service_config or service_config['settings'].get(
'outputtext', False):
if self.allow_basic_output:
self.radio_basic_output.setChecked(
s.value(
'/plugins/qquake/{}_{}_event_basic_checked'.format(
prefix, suffix), True, bool))
else:
self.radio_extended_output.setChecked(True)
if not service_config or service_config['settings'].get(
'outputxml', False):
self.radio_extended_output.setChecked(
s.value(
'/plugins/qquake/{}_{}_event_extended_checked'.format(
prefix, suffix), False, bool))
def _ogc_service_changed(self, _, __):
"""
Triggered when the current OGC service changes
"""
if not self.ogc_list.selectionModel().selectedIndexes():
return
current_service = self.ogc_list.selectionModel().selectedIndexes(
)[0].data(Qt.UserRole)
if not current_service:
return
self.ogc_service_widget.set_service(
service_type=self.ogc_combo.currentData(),
service_id=current_service)
self.ogc_service_info_widget.set_service(
service_type=self.ogc_combo.currentData(),
service_id=current_service)
service_config = SERVICE_MANAGER.service_details(
self.ogc_combo.currentData(), current_service)
self.button_ogc_edit_service.setEnabled(
not service_config['read_only'])
self.button_ogc_rename_service.setEnabled(
not service_config['read_only'])
self.button_ogc_remove_service.setEnabled(
not service_config['read_only'])
def _refresh_services(self):
# fill the FDSN listWidget with the dictionary keys
self.fdsn_event_list.clear()
self.fdsn_event_list.addItems(SERVICE_MANAGER.available_services(SERVICE_MANAGER.FDSNEVENT))
self.fdsn_event_list.setCurrentRow(0)
# fill the FDSN listWidget with the dictionary keys
self.fdsn_macro_list.clear()
self.fdsn_macro_list.addItems(SERVICE_MANAGER.available_services(SERVICE_MANAGER.MACROSEISMIC))
self.fdsn_macro_list.setCurrentRow(0)
# fill the FDSN listWidget with the dictionary keys
self.fdsn_station_list.clear()
self.fdsn_station_list.addItems(SERVICE_MANAGER.available_services(SERVICE_MANAGER.FDSNSTATION))
self.fdsn_station_list.setCurrentRow(0)
self.refreshOgcWidgets()
def mdpset_to_layer(
self, parser: Union[BasicTextParser, QuakeMlParser]
) -> QgsVectorLayer: # pylint:disable=too-many-branches
"""
Returns a new vector layer containing the reply contents
"""
vl = self._create_empty_mdp_layer()
features = []
for f in parser.create_mdp_features(self.output_fields,
self.preferred_mdp_only):
features.append(f)
ok, _ = vl.dataProvider().addFeatures(features)
assert ok
mdp_style_url = StyleUtils.style_url(
self.styles[SERVICE_MANAGER.MACROSEISMIC]
) if SERVICE_MANAGER.MACROSEISMIC in self.styles else None
if self.url:
default_style_url = mdp_style_url or StyleUtils.default_style_for_macro_url(
)
err = StyleUtils.fetch_and_apply_style(vl, default_style_url)
if err:
self.message.emit(err, Qgis.Warning)
elif self.service_config.get('mdpstyleurl'):
err = StyleUtils.fetch_and_apply_style(
vl, mdp_style_url or self.service_config.get('mdpstyleurl'))
if err:
self.message.emit(err, Qgis.Warning)
elif isinstance(self.service_config.get('default', {}).get('style', {}), dict) and \
self.service_config['default']['style'].get('mdp'):
style_url = None
style = self.service_config['default']['style']['mdp']
if mdp_style_url:
style_url = mdp_style_url
else:
style_ref = style.get('style')
if style_ref:
style_url = SERVICE_MANAGER.get_style(style_ref)['url']
if style_url:
if isinstance(self.result, BasicTextParser):
style_attr = style.get('classified_attribute_text')
else:
style_attr = self.result.remap_attribute_name(
SERVICE_MANAGER.MACROSEISMIC,
style.get('classified_attribute_xml'))
err = StyleUtils.fetch_and_apply_style(vl, style_url,
style_attr)
if err:
self.message.emit(err, Qgis.Warning)
return vl
def _reply_finished(self, reply):
self.button_refresh_contributors.setEnabled(True)
content = reply.readAll()
if not content:
return
doc = QDomDocument()
doc.setContent(content)
contributor_elements = doc.elementsByTagName('Contributor')
contributors = []
for e in range(contributor_elements.length()):
contributor_element = contributor_elements.at(e).toElement()
contributors.append(contributor_element.text())
SERVICE_MANAGER.set_contributors(self.service_type, self.service_id, contributors)
self._update_contributor_list(contributors)
def set_service_id(self, service_id: str): # pylint:disable=too-many-branches
"""
Sets the associated service ID
"""
self.service_id = service_id
service_config = SERVICE_MANAGER.service_details(
self.service_type, self.service_id)
if 'fields' in service_config['default']:
self.output_fields = service_config['default']['fields']
if not service_config['settings'].get('querycircular', False):
if self.radio_circular_area.isChecked():
self.radio_rectangular_area.setChecked(True)
self.radio_circular_area.setEnabled(False)
else:
self.radio_circular_area.setEnabled(True)
if not service_config['settings'].get('queryeventtype', False):
if self.event_type_check.isChecked():
self.event_type_check.setChecked(False)
self.event_type_check.setEnabled(False)
else:
self.event_type_check.setEnabled(True)
if not service_config['settings'].get('queryupdatedafter', False):
if self.events_updated_after_check.isChecked():
self.events_updated_after_check.setChecked(False)
self.events_updated_after_check.setEnabled(False)
else:
self.events_updated_after_check.setEnabled(True)
self.radius_unit_combobox.clear()
self.radius_unit_combobox.addItem(self.tr('Degrees'),
QgsUnitTypes.DistanceDegrees)
if service_config['settings'].get('querycircularradiuskm', False):
self.radius_unit_combobox.insertItem(
0, self.tr('Kilometers'), QgsUnitTypes.DistanceKilometers)
self.radius_unit_combobox.setCurrentIndex(0)
if not service_config['settings'].get('outputtext', False):
if self.radio_basic_output.isChecked():
self.radio_extended_output.setChecked(True)
self.radio_basic_output.setEnabled(False)
else:
self.radio_basic_output.setEnabled(True)
if not service_config['settings'].get('outputxml', False):
if self.radio_extended_output.isChecked():
self.radio_basic_output.setChecked(True)
self.radio_extended_output.setEnabled(False)
else:
self.radio_extended_output.setEnabled(True)
def _import_configuration(self):
file, _ = QFileDialog.getOpenFileName(self, self.tr('Import Service'), QDir.homePath(), 'JSON Files (*.json)')
if not file:
return
res, err = SERVICE_MANAGER.import_service(file)
if res:
self.message_bar.pushMessage(
self.tr("Service imported"), Qgis.Success, 5)
else:
self.message_bar.pushMessage(
err, Qgis.Critical, 5)
def save_areas(self):
previous = list(SERVICE_MANAGER.available_predefined_bounding_boxes())
for p in previous:
if SERVICE_MANAGER.predefined_bounding_box(p).get('read_only'):
continue
SERVICE_MANAGER.remove_predefined_bounding_box(p)
for i in range(self.region_list.count()):
item = self.region_list.item(i)
if item.data(Qt.UserRole + 1):
# read only
continue
title = item.data(Qt.UserRole + 2)
bounding_box = [
item.data(Qt.UserRole + 3),
item.data(Qt.UserRole + 4),
item.data(Qt.UserRole + 5),
item.data(Qt.UserRole + 6)
]
SERVICE_MANAGER.add_predefined_bounding_box(
title, {
'title': title,
'boundingbox': bounding_box
})
def set_service(self, service_id: str, service_type: str):
"""
Sets the service details
"""
self.service_type = service_type
self.service_id = service_id
self.service_config = SERVICE_MANAGER.service_details(
service_type, service_id)
layers = self.service_config['default']['layers']
cql_available = self.service_config.get('settings',
{}).get('queryCQL', False)
if not cql_available:
self.cql = None
self.simple_cql = []
self.cql_filter_label.setText('')
self.button_set_filter.setEnabled(cql_available)
nodes = []
for layer in layers:
if layer.get('styles'):
parent_node = ModelNode([layer['layername']])
checked_styles = layer.get('checked_styles', None)
for style in layer['styles']:
checked = True if checked_styles is None else style in checked_styles
parent_node.addChild(ModelNode(['checked', style],
checked))
else:
if self.service_type == SERVICE_MANAGER.WFS:
style = layer.get('style', {}).get('wfs',
{}).get('style', None)
elif self.service_type == SERVICE_MANAGER.WCS:
style = layer.get('style', {}).get('wcs',
{}).get('style', None)
parent_node = ModelNode(['checked', layer['layername']], True,
{'style': style})
nodes.append(parent_node)
self.layer_model = SimpleNodeModel(
nodes, headers=[self.tr('Selected'),
self.tr('Style Name')])
self.layers_tree_view.setModel(self.layer_model)
self.layers_tree_view.expandAll()
for r in range(self.layer_model.rowCount(QModelIndex())):
if self.layer_model.flags(
self.layer_model.index(
r, 0, QModelIndex())) & Qt.ItemIsUserCheckable:
continue
self.layers_tree_view.setFirstColumnSpanned(r, QModelIndex(), True)
def _use_predefined_area(self):
"""
Retrieves the selected predefined area details and updates the widget state accordingly
"""
if not self.radio_predefined_area.isChecked():
return
selected_extent_id = self.combo_predefined_area.currentData()
if selected_extent_id not in SERVICE_MANAGER.available_predefined_bounding_boxes(
):
return
extent = SERVICE_MANAGER.predefined_bounding_box(
selected_extent_id)['boundingbox']
self.lat_min_spinbox.setValue(extent[1])
self.lat_max_spinbox.setValue(extent[3])
self.long_min_spinbox.setValue(extent[0])
self.long_max_spinbox.setValue(extent[2])
self.lat_max_checkbox.setChecked(True)
self.long_max_checkbox.setChecked(True)
self.lat_min_checkbox.setChecked(True)
self.long_min_checkbox.setChecked(True)
def _refresh_contributors(self):
self.edit_contributor_id.clear()
url = SERVICE_MANAGER.get_contributor_endpoint(self.service_type, self.service_id)
if not url:
return
self.button_refresh_contributors.setEnabled(False)
request = QNetworkRequest(QUrl(url))
request.setAttribute(QNetworkRequest.FollowRedirectsAttribute, True)
reply = QgsNetworkAccessManager.instance().get(request)
reply.finished.connect(lambda r=reply: self._reply_finished(r))
def stations_to_layer(self, fdsn: Optional[Fdsn]) -> QgsVectorLayer: # pylint:disable=too-many-branches
"""
Returns a new vector layer containing the reply contents
"""
vl = self._create_empty_stations_layer()
features = []
if self.output_type == Fetcher.BASIC:
for f in self.result.create_station_features():
features.append(f)
else:
features.extend(fdsn.to_station_features(self.output_fields))
ok, _ = vl.dataProvider().addFeatures(features)
assert ok
station_style_url = StyleUtils.style_url(
self.styles[SERVICE_MANAGER.FDSNSTATION]
) if SERVICE_MANAGER.FDSNSTATION in self.styles else None
if station_style_url or self.service_config.get('styleurl'):
err = StyleUtils.fetch_and_apply_style(
vl, station_style_url or self.service_config.get('styleurl'))
if err:
self.message.emit(err, Qgis.Warning)
elif isinstance(self.service_config.get('default', {}).get('style', {}), dict) and \
self.service_config['default']['style'].get('stations'):
style = self.service_config['default']['style']['stations']
style_url = None
if station_style_url:
style_url = station_style_url
else:
style_ref = style.get('style')
if style_ref:
style_url = SERVICE_MANAGER.get_style(style_ref)['url']
if style_url:
if isinstance(self.result, BasicTextParser):
style_attr = style.get('classified_attribute_text')
else:
style_attr = FDSNStationXMLParser.remap_attribute_name(
style.get('classified_attribute_xml'))
err = StyleUtils.fetch_and_apply_style(vl, style_url,
style_attr)
if err:
self.message.emit(err, Qgis.Warning)
return vl
def _create_configuration(self):
service_type = self.get_current_service_type()
dlg = QgsNewNameDialog('', '', [], existing=SERVICE_MANAGER.available_services(service_type))
dlg.setHintString(self.tr('Create a new service configuration named'))
dlg.setWindowTitle(self.tr('New Service Configuration'))
dlg.setOverwriteEnabled(False)
dlg.setConflictingNameWarning(self.tr('A configuration with this name already exists'))
if not dlg.exec_():
return
name = dlg.name()
config_dialog = ServiceConfigurationDialog(self.iface, service_type, name, self)
if config_dialog.exec_():
self.set_current_service(service_type, name)
def _ogc_service_changed(self):
if not self.ogc_list.currentItem():
return
self.ogc_service_widget.set_service(service_type=self.ogc_combo.currentData(),
service_id=self.ogc_list.currentItem().text())
self.ogc_service_info_widget.set_service(service_type=self.ogc_combo.currentData(),
service_id=self.ogc_list.currentItem().text())
service_config = SERVICE_MANAGER.service_details(self.ogc_combo.currentData(),
self.ogc_list.currentItem().text())
self.button_ogc_edit_service.setEnabled(not service_config['read_only'])
self.button_ogc_rename_service.setEnabled(not service_config['read_only'])
self.button_ogc_remove_service.setEnabled(not service_config['read_only'])
def set_service_id(self, service_id: str):
self.service_id = service_id
self.output_table_options_widget.set_service_id(service_id)
self.service_config = SERVICE_MANAGER.service_details(
self.service_type, self.service_id)
if not self.service_config['settings'].get('querycontributorid'):
if self.radio_contributor.isChecked():
self.radio_single_event.setChecked(True)
self.radio_contributor.setEnabled(False)
else:
self.radio_contributor.setEnabled(True)
if self.radio_contributor.isChecked(
) and self.service_config['settings'].get('querycontributor'):
self.button_refresh_contributors.setEnabled(True)
else:
self.button_refresh_contributors.setEnabled(False)
self._update_contributor_list(
SERVICE_MANAGER.get_contributors(self.service_type,
self.service_id))
def to_service_definition(self):
base_config = deepcopy(
SERVICE_MANAGER.service_details(self.service_type,
self.service_id))
defaults = base_config.get('default', {})
for layer in defaults.get('layers', []):
selected_styles = []
for style in layer.get('styles', []):
if self.is_style_selected(layer.get('layername'), style):
selected_styles.append(style)
layer['checked_styles'] = selected_styles
base_config['default'] = defaults
return base_config
def _export_service(self):
service_type = self.get_current_service_type()
service_id = self.get_current_service_id(service_type)
file, _ = QFileDialog.getSaveFileName(self, self.tr('Export Service'),
QDir.homePath() + '/{}.json'.format(service_id), 'JSON Files (*.json)')
if not file:
return
file = QgsFileUtils.ensureFileNameHasExtension(file, ['json'])
if SERVICE_MANAGER.export_service(service_type, service_id, file):
self.message_bar.pushMessage(
self.tr("Service exported"), Qgis.Success, 5)
else:
self.message_bar.pushMessage(
self.tr("An error occurred while exporting service"), Qgis.Critical, 5)
