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 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 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 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 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 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 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 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 _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 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 restore_settings(self, prefix):
if self.service_id:
service_config = SERVICE_MANAGER.service_details(self.service_type, self.service_id)
else:
service_config = None
s = QgsSettings()
self.edit_network_code.setText(s.value('/plugins/qquake/{}_network_code'.format(prefix), '', str))
self.edit_station_code.setText(s.value('/plugins/qquake/{}_station_code'.format(prefix), '', str))
self.edit_location_code.setText(s.value('/plugins/qquake/{}_location_code'.format(prefix), '', str))
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 set_service_id(self, 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('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 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 set_service(self, service_id, service_type):
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']
nodes = []
for l in layers:
if l.get('styles'):
parent_node = ModelNode([l['layername']])
checked_styles = l.get('checked_styles', None)
for style in l['styles']:
checked = True if checked_styles is None else style in checked_styles
parent_node.addChild(ModelNode(['checked', style],
checked))
else:
style = l.get('style', {}).get('wfs', {}).get('style', None)
parent_node = ModelNode(['checked', l['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 set_service(self, service_id: str, service_type: str): # pylint: disable=too-many-statements
"""
Sets the associated service
"""
self.service_type = service_type
self.service_id = service_id
self.service_config = SERVICE_MANAGER.service_details(
service_type, service_id)
html = f"""<p><b>Title</b><br>
{self.service_config['title']}</p>"""
if self.service_config.get(
'servicedescriptionurl') or self.service_config.get(
'servicedescription'):
html += f"""<p><b>Service description</b><br>
<a href="{self.service_config['servicedescriptionurl']}">{self.service_config.get('servicedescription') or self.service_config['servicedescriptionurl']}</a></p>"""
html += """<p><b>Service managed by</b><br>
<a href="{dataproviderurl}">{dataprovider}</a></p>
""".format(**self.service_config)
if self.service_config.get('help'):
html += """
<p><b>Help</b><br>
<a href="{help}">{help}</a></p>
""".format(**self.service_config)
if self.service_config.get(
'datadescription') or self.service_config.get(
'datadescriptionurl'):
html += f"""<p><b>Data description</b><br>
<a href="{self.service_config['datadescriptionurl']}">{self.service_config.get('datadescription') or self.service_config['datadescriptionurl']}</a></p>
"""
if self.service_config.get(
'datalicenseurl') or self.service_config.get('datalicense'):
html += f"""<p><b>Data license</b><br>
<a href="{self.service_config['datalicenseurl']}">{self.service_config.get('datalicense') or self.service_config.get('datalicenseurl')}</a></p>
"""
if self.service_config.get('publications'):
html += """<p><b>Publications</b></p><ul>"""
for p in self.service_config['publications']:
html += f"""<li>{QgsStringUtils.insertLinks(p)[0]}</li>"""
html += "</ul>"
capabilities = []
if service_type in (SERVICE_MANAGER.MACROSEISMIC,
SERVICE_MANAGER.FDSNSTATION,
SERVICE_MANAGER.FDSNEVENT):
if self.service_config['settings'].get('querylimitmaxentries'):
capabilities.append(
'Allowed maximum number of returned entries: {}'.format(
self.service_config['settings'].get(
'querylimitmaxentries')))
if self.service_config.get('datestart'):
capabilities.append('Earliest date: {}'.format(
self.service_config['datestart']))
if self.service_config.get('dateend'):
capabilities.append('Latest date: {}'.format(
self.service_config['dateend']))
def add_capability_string(title, source, key):
capabilities.append('{}: {}'.format(
title, 'YES' if source.get(key) else 'NO'))
add_capability_string('Support requests using event identifier',
self.service_config['settings'],
'queryeventid')
add_capability_string('Support requests using origin identifier',
self.service_config['settings'],
'queryoriginid')
add_capability_string(
'Support requests using magnitude identifier',
self.service_config['settings'], 'querymagnitudeid')
add_capability_string(
'Support requests using forcal mechanism identifier',
self.service_config['settings'], 'queryfocalmechanismid')
add_capability_string(
'Support requests of data published after a certain date',
self.service_config['settings'], 'queryupdatedafter')
add_capability_string(
'Support requests using source catalog identifier',
self.service_config['settings'], 'querycatalog')
add_capability_string(
'Support requests using source contributor identifier',
self.service_config['settings'], 'querycontributorid')
add_capability_string('Support requests by event type',
self.service_config['settings'],
'queryeventtype')
add_capability_string('Support requests by magnitude type',
self.service_config['settings'],
'querymagnitudetype')
add_capability_string('Support retrieval of all origin estimates',
self.service_config['settings'],
'queryincludeallorigins')
add_capability_string(
'Support retrieval of all magnitude estimates',
self.service_config['settings'], 'queryincludeallmagnitudes')
add_capability_string('Support retrieval of arrival times',
self.service_config['settings'],
'queryincludearrivals')
add_capability_string(
'Support retrieval of all station magnitude estimates',
self.service_config['settings'],
'queryincludeallstationsmagnitudes')
add_capability_string('Support query limit',
self.service_config['settings'],
'querylimit')
add_capability_string('Support filter using circular search',
self.service_config['settings'],
'querycircular')
add_capability_string('Support search radius in kilometers',
self.service_config['settings'],
'querycircularradiuskm')
add_capability_string('Support filter by hypocentral depth',
self.service_config['settings'],
'querydepth')
add_capability_string('Support text output',
self.service_config['settings'],
'outputtext')
add_capability_string('Support QuakeML output',
self.service_config['settings'], 'outputxml')
add_capability_string('Support GeoJSON output',
self.service_config['settings'],
'outputgeojson')
add_capability_string('Support JSON output',
self.service_config['settings'],
'outputjson')
add_capability_string('Support KML output',
self.service_config['settings'], 'outputkml')
add_capability_string('Support XLSX output',
self.service_config['settings'],
'outputxlsx')
if self.service_config.get('httpcodenodata'):
capabilities.append('HTTP error code: {}'.format(
self.service_config['settings'].get('httpcodenodata')))
if capabilities:
html += """<p><b>Capabilities</b>"""
html += ''.join(['<li>{}</li>'.format(c) for c in capabilities])
html += """</p>"""
self.info_browser.setHtml(html)
def to_service_definition(self) -> dict:
"""
Converts the widget state to a service definition
"""
base_config = deepcopy(
SERVICE_MANAGER.service_details(self.service_type,
self.service_id))
defaults = base_config.get('default', {})
for k, v in {
'datestart':
self.start_date().toString(Qt.ISODate)
if self.start_date() else None,
'dateend':
self.end_date().toString(Qt.ISODate)
if self.end_date() else None,
'boundingboxpredefined':
self.combo_predefined_area.currentData()
if self.radio_predefined_area.isChecked() else None,
'minimumlatitude':
self.min_latitude()
if self.radio_rectangular_area.isChecked() else None,
'maximumlatitude':
self.max_latitude()
if self.radio_rectangular_area.isChecked() else None,
'minimumlongitude':
self.min_longitude()
if self.radio_rectangular_area.isChecked() else None,
'maximumlongitude':
self.max_longitude()
if self.radio_rectangular_area.isChecked() else None,
'circlelatitude':
self.circle_latitude()
if self.radio_circular_area.isChecked() else None,
'circlelongitude':
self.circle_longitude()
if self.radio_circular_area.isChecked() else None,
'minimumcircleradius':
self.circle_min_radius()
if self.radio_circular_area.isChecked() else None,
'maximumcircleradius':
self.circle_max_radius()
if self.radio_circular_area.isChecked() else None,
'minimummagnitude':
self.min_magnitude(),
'maximummagnitude':
self.max_magnitude(),
'macromaxintensitygreater':
self.earthquake_max_intensity_greater(),
'macromdpsgreaterthan':
self.earthquake_number_mdps_greater(),
'eventtype':
self.event_type(),
'updatedafter':
self.updated_after().toString(Qt.ISODate)
if self.updated_after() else None,
}.items():
if v:
defaults[k] = v
elif k in defaults:
del defaults[k]
base_config['default'] = defaults
return base_config
def restore_settings(self, prefix: str): # pylint: disable=too-many-locals,too-many-branches,too-many-statements
"""
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
last_event_start_date = s.value(
'/plugins/qquake/{}_last_event_start_date'.format(prefix))
if last_event_start_date is not None:
self.fdsn_event_start_date.setDateTime(last_event_start_date)
last_event_end_date = s.value(
'/plugins/qquake/{}_last_event_end_date'.format(prefix))
if last_event_end_date is not None:
self.fdsn_event_end_date.setDateTime(last_event_end_date)
last_event_min_magnitude = s.value(
'/plugins/qquake/{}_last_event_min_magnitude'.format(prefix))
if last_event_min_magnitude is not None:
self.fdsn_event_min_magnitude.setValue(
float(last_event_min_magnitude))
last_event_max_magnitude = s.value(
'/plugins/qquake/{}_last_event_max_magnitude'.format(prefix))
if last_event_max_magnitude is not None:
self.fdsn_event_max_magnitude.setValue(
float(last_event_max_magnitude))
self.limit_extent_checkbox.setChecked(
s.value(
'/plugins/qquake/{}_last_event_extent_enabled2'.format(prefix),
False, bool))
self.radio_predefined_area.setChecked(
s.value(
'/plugins/qquake/{}_last_event_extent_named'.format(prefix),
False, bool))
last_area = s.value(
'/plugins/qquake/{}_last_event_extent_name'.format(prefix), '',
str)
if last_area:
self.combo_predefined_area.setCurrentIndex(
self.combo_predefined_area.findData(last_area))
self.radio_rectangular_area.setChecked(
s.value(
'/plugins/qquake/{}_last_event_extent_rect2'.format(prefix),
False, bool))
if not service_config or service_config['settings'].get(
'querycircular', False):
self.radio_circular_area.setChecked(
s.value(
'/plugins/qquake/{}_last_event_extent_circle2'.format(
prefix), False, bool))
self.lat_min_checkbox.setChecked(
s.value(
'/plugins/qquake/{}_last_event_min_lat_checked2'.format(
prefix), False, bool))
self.lat_max_checkbox.setChecked(
s.value(
'/plugins/qquake/{}_last_event_max_lat_checked2'.format(
prefix), False, bool))
self.long_min_checkbox.setChecked(
s.value(
'/plugins/qquake/{}_last_event_min_long_checked2'.format(
prefix), False, bool))
self.long_max_checkbox.setChecked(
s.value(
'/plugins/qquake/{}_last_event_max_long_checked2'.format(
prefix), False, bool))
self.radius_min_checkbox.setChecked(
s.value(
'/plugins/qquake/{}_last_event_circle_radius_min_checked2'.
format(prefix), False, bool))
self.radius_max_checkbox.setChecked(
s.value(
'/plugins/qquake/{}_last_event_circle_radius_max_checked2'.
format(prefix), False, bool))
self.radius_unit_combobox.setCurrentIndex(
max(
0,
self.radius_unit_combobox.findData(
s.value(
'/plugins/qquake/{}_last_event_circle_unit'.format(
prefix), int(QgsUnitTypes.DistanceKilometers),
int))))
last_event_min_lat = s.value(
'/plugins/qquake/{}_last_event_min_lat'.format(prefix))
if last_event_min_lat is not None:
self.lat_min_spinbox.setValue(float(last_event_min_lat))
last_event_max_lat = s.value(
'/plugins/qquake/{}_last_event_max_lat'.format(prefix))
if last_event_max_lat is not None:
self.lat_max_spinbox.setValue(float(last_event_max_lat))
last_event_min_long = s.value(
'/plugins/qquake/{}_last_event_min_long'.format(prefix))
if last_event_min_long is not None:
self.long_min_spinbox.setValue(float(last_event_min_long))
last_event_max_long = s.value(
'/plugins/qquake/{}_last_event_max_long'.format(prefix))
if last_event_max_long is not None:
self.long_max_spinbox.setValue(float(last_event_max_long))
last_event_circle_lat = s.value(
'/plugins/qquake/{}_last_event_circle_lat'.format(prefix))
if last_event_circle_lat is not None:
self.circular_lat_spinbox.setValue(float(last_event_circle_lat))
last_event_circle_long = s.value(
'/plugins/qquake/{}_last_event_circle_long'.format(prefix))
if last_event_circle_long is not None:
self.circular_long_spinbox.setValue(float(last_event_circle_long))
last_event_min_radius = s.value(
'/plugins/qquake/{}_last_event_circle_min_radius'.format(prefix))
if last_event_min_radius is not None:
self.radius_min_spinbox.setValue(float(last_event_min_radius))
last_event_max_radius = s.value(
'/plugins/qquake/{}_last_event_circle_max_radius'.format(prefix))
if last_event_max_radius is not None:
self.radius_max_spinbox.setValue(float(last_event_max_radius))
self.min_time_check.setChecked(
s.value(
'/plugins/qquake/{}_last_event_min_time_checked2'.format(
prefix), False, bool))
self.max_time_check.setChecked(
s.value(
'/plugins/qquake/{}_last_event_max_time_checked2'.format(
prefix), False, bool))
self.min_mag_check.setChecked(
s.value(
'/plugins/qquake/{}_last_event_min_mag_checked2'.format(
prefix), False, bool))
self.max_mag_check.setChecked(
s.value(
'/plugins/qquake/{}_last_event_max_mag_checked2'.format(
prefix), False, bool))
self.earthquake_max_intensity_greater_check.setChecked(
s.value(
'/plugins/qquake/{}_last_event_max_intensity_greater_checked2'.
format(prefix), False, bool))
v = s.value(
'/plugins/qquake/{}_last_event_max_intensity_greater'.format(
prefix))
if v is not None:
self.earthquake_max_intensity_greater_combo.setCurrentIndex(
self.earthquake_max_intensity_greater_combo.findData(float(v)))
self.earthquake_number_mdps_greater_check.setChecked(
s.value(
'/plugins/qquake/{}_last_event_mdps_greater_checked2'.format(
prefix), False, bool))
v = s.value(
'/plugins/qquake/{}_last_event_mdps_greater'.format(prefix))
if v is not None:
self.earthquake_number_mdps_greater_spin.setValue(float(v))
if not service_config or service_config['settings'].get(
'outputtext', False):
self.radio_basic_output.setChecked(
s.value(
'/plugins/qquake/{}_last_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/{}_last_event_extended_checked'.format(
prefix), False, bool))
self.event_type_check.setChecked(
s.value(
'/plugins/qquake/{}_last_event_type_checked'.format(prefix),
False, bool))
last_event_type = s.value(
'/plugins/qquake/{}_last_event_type'.format(prefix), '', str)
if last_event_type is not None:
self.event_type_combo.setCurrentIndex(
self.event_type_combo.findData(last_event_type))
self.events_updated_after_check.setChecked(
s.value(
'/plugins/qquake/{}_events_updated_after_checked'.format(
prefix), False, bool))
last_updated_after_date = s.value(
'/plugins/qquake/{}_events_updated_after_date'.format(prefix))
if last_updated_after_date is not None:
self.events_updated_after.setDateTime(last_updated_after_date)
def _update_service_widgets(
self, # pylint: disable=too-many-locals,too-many-branches
service_type,
service_id,
filter_widget,
filter_by_id_widget,
fetch_by_url_widget,
info_widget,
remove_service_button,
edit_service_button,
rename_service_button,
tab_widget):
"""
Updates all widgets to reflect the current service details
"""
service_config = SERVICE_MANAGER.service_details(
service_type, service_id)
date_start = QDateTime.fromString(service_config['datestart'],
Qt.ISODate)
default_date_start = QDateTime.fromString(
service_config['default']['datestart'],
Qt.ISODate) if service_config['default'].get('datestart') else None
# if the dateend is not set in the config.json set the date to NOW
date_end = QDateTime.fromString(
service_config['dateend'],
Qt.ISODate) if 'dateend' in service_config and service_config[
'dateend'] else None
default_date_end = QDateTime.fromString(
service_config['default']['dateend'],
Qt.ISODate) if service_config['default'].get('dateend') else None
filter_widget.set_date_range_limits(date_start, date_end)
filter_widget.set_current_date_range(default_date_start,
default_date_end)
if service_config['default'].get('boundingboxpredefined'):
filter_widget.set_predefined_bounding_box(
service_config['default'].get('boundingboxpredefined'))
if service_config['default'].get('minimumlatitude'):
filter_widget.set_min_latitude(
service_config['default'].get('minimumlatitude'))
if service_config['default'].get('maximumlatitude'):
filter_widget.set_max_latitude(
service_config['default'].get('maximumlatitude'))
if service_config['default'].get('minimumlongitude'):
filter_widget.set_min_longitude(
service_config['default'].get('minimumlongitude'))
if service_config['default'].get('maximumlongitude'):
filter_widget.set_max_longitude(
service_config['default'].get('maximumlongitude'))
if service_config['default'].get('circlelatitude'):
filter_widget.set_circle_latitude(
service_config['default'].get('circlelatitude'))
if service_config['default'].get('circlelongitude'):
filter_widget.set_circle_longitude(
service_config['default'].get('circlelongitude'))
if service_config['default'].get('minimumcircleradius'):
filter_widget.set_min_circle_radius(
service_config['default'].get('minimumcircleradius'))
if service_config['default'].get('maximumcircleradius'):
filter_widget.set_max_circle_radius(
service_config['default'].get('maximumcircleradius'))
if service_config['default'].get('minimummagnitude'):
filter_widget.set_min_magnitude(
service_config['default'].get('minimummagnitude'))
if service_config['default'].get('maximummagnitude'):
filter_widget.set_max_magnitude(
service_config['default'].get('maximummagnitude'))
if service_config['default'].get('macromaxintensitygreater'):
filter_widget.set_max_intensity_greater(
service_config['default'].get('macromaxintensitygreater'))
if service_config['default'].get('macromdpsgreaterthan'):
filter_widget.set_mdps_greater_than(
service_config['default'].get('macromdpsgreaterthan'))
if service_config['default'].get('eventtype'):
filter_widget.set_event_type(
service_config['default'].get('eventtype'))
updated_after = QDateTime.fromString(
service_config['default']['updatedafter'], Qt.ISODate
) if service_config['default'].get('updatedafter') else None
if updated_after:
filter_widget.set_updated_after(updated_after)
filter_widget.set_extent_limit(
service_config.get('boundingbox', [-180, -90, 180, 90]))
if service_type in [
SERVICE_MANAGER.FDSNEVENT, SERVICE_MANAGER.MACROSEISMIC
]:
tab_widget.widget(1).setEnabled(service_config['settings'].get(
'queryeventid', False))
info_widget.set_service(service_type=service_type,
service_id=service_id)
filter_widget.set_service_id(service_id)
filter_by_id_widget.set_service_id(service_id)
if fetch_by_url_widget is not None:
fetch_by_url_widget.set_service_id(service_id)
remove_service_button.setEnabled(not service_config['read_only'])
edit_service_button.setEnabled(not service_config['read_only'])
rename_service_button.setEnabled(not service_config['read_only'])
def get_fetcher(self, service_type: Optional[str] = None):
"""
Returns a quake fetcher corresponding to the current dialog settings
"""
if service_type is None:
service_type = self.get_current_service_type()
service = self.get_current_service_id(service_type)
if not service:
return None
filter_widget = self.get_service_filter_widget(service_type)
service_config = SERVICE_MANAGER.service_details(service_type, service)
if isinstance(filter_widget, FilterParameterWidget):
fetcher = Fetcher(
service_type=service_type,
event_service=service,
event_start_date=filter_widget.start_date(),
event_end_date=filter_widget.end_date(),
event_min_magnitude=filter_widget.min_magnitude(),
event_max_magnitude=filter_widget.max_magnitude(),
limit_extent_rect=filter_widget.extent_rect(),
min_latitude=filter_widget.min_latitude(),
max_latitude=filter_widget.max_latitude(),
min_longitude=filter_widget.min_longitude(),
max_longitude=filter_widget.max_longitude(),
limit_extent_circle=filter_widget.limit_extent_circle(),
circle_latitude=filter_widget.circle_latitude(),
circle_longitude=filter_widget.circle_longitude(),
circle_min_radius=filter_widget.circle_min_radius(),
circle_max_radius=filter_widget.circle_max_radius(),
circle_radius_unit=filter_widget.circle_radius_unit(),
earthquake_number_mdps_greater=filter_widget.
earthquake_number_mdps_greater(),
earthquake_max_intensity_greater=filter_widget.
earthquake_max_intensity_greater(),
output_fields=filter_widget.output_fields,
output_type=filter_widget.output_type(),
convert_negative_depths=filter_widget.convert_negative_depths(
),
depth_unit=filter_widget.depth_unit(),
event_type=filter_widget.event_type(),
updated_after=filter_widget.updated_after())
elif isinstance(filter_widget, FilterByIdWidget):
if not service_config['settings'].get('queryeventid'):
fetcher = None
else:
fetcher = Fetcher(
service_type=service_type,
event_service=service,
event_ids=filter_widget.ids(),
contributor_id=filter_widget.contributor_id(),
output_fields=filter_widget.output_fields,
output_type=filter_widget.output_type(),
convert_negative_depths=filter_widget.
convert_negative_depths(),
depth_unit=filter_widget.depth_unit())
elif isinstance(filter_widget, FetchByUrlWidget):
fetcher = Fetcher(service_type=service_type,
event_service=service,
url=filter_widget.url(),
output_fields=filter_widget.output_fields,
output_type=filter_widget.output_type(),
convert_negative_depths=filter_widget.
convert_negative_depths(),
depth_unit=filter_widget.depth_unit())
elif isinstance(filter_widget, FilterStationByIdWidget):
fetcher = Fetcher(service_type=service_type,
event_service=service,
network_codes=filter_widget.network_codes(),
station_codes=filter_widget.station_codes(),
locations=filter_widget.locations(),
output_fields=filter_widget.output_fields,
output_type=filter_widget.output_type(),
convert_negative_depths=filter_widget.
convert_negative_depths(),
depth_unit=filter_widget.depth_unit())
return fetcher
def __init__(
self,
iface, # pylint: disable=unused-argument,too-many-branches,too-many-statements
service_type: str,
service_id: str,
parent: Optional[QWidget] = None):
"""Constructor."""
super().__init__(parent)
self.setupUi(self)
self.qml_style_name_combo_events.addItem('')
self.qml_style_name_combo_mdp.addItem('')
self.qml_style_name_combo_stations.addItem('')
self.label_qml_events.setVisible(
service_type in (SERVICE_MANAGER.FDSNEVENT,
SERVICE_MANAGER.MACROSEISMIC))
self.qml_style_url_edit_events.setVisible(
service_type in (SERVICE_MANAGER.FDSNEVENT,
SERVICE_MANAGER.MACROSEISMIC))
self.label_preset_style_events.setVisible(
service_type in (SERVICE_MANAGER.FDSNEVENT,
SERVICE_MANAGER.MACROSEISMIC))
self.qml_style_name_combo_events.setVisible(
service_type in (SERVICE_MANAGER.FDSNEVENT,
SERVICE_MANAGER.MACROSEISMIC))
self.label_mdp_url.setVisible(
service_type == SERVICE_MANAGER.MACROSEISMIC)
self.qml_style_url_edit_mdp.setVisible(
service_type == SERVICE_MANAGER.MACROSEISMIC)
self.qml_style_name_combo_mdp.setVisible(
service_type == SERVICE_MANAGER.MACROSEISMIC)
self.mdp_preset_label.setVisible(
service_type == SERVICE_MANAGER.MACROSEISMIC)
self.label_stations_url.setVisible(
service_type == SERVICE_MANAGER.FDSNSTATION)
self.qml_style_url_edit_stations.setVisible(
service_type == SERVICE_MANAGER.FDSNSTATION)
self.label_preset_name_stations.setVisible(
service_type == SERVICE_MANAGER.FDSNSTATION)
self.qml_style_name_combo_stations.setVisible(
service_type == SERVICE_MANAGER.FDSNSTATION)
for name in SERVICE_MANAGER.styles_for_service_type(
SERVICE_MANAGER.FDSNEVENT):
self.qml_style_name_combo_events.addItem(
SERVICE_MANAGER.get_style(name)['label'], name)
for name in SERVICE_MANAGER.styles_for_service_type(
SERVICE_MANAGER.MACROSEISMIC):
self.qml_style_name_combo_mdp.addItem(
SERVICE_MANAGER.get_style(name)['label'], name)
for name in SERVICE_MANAGER.styles_for_service_type(
SERVICE_MANAGER.FDSNSTATION):
self.qml_style_name_combo_stations.addItem(
SERVICE_MANAGER.get_style(name)['label'], name)
self.service_type = service_type
self.service_id = service_id
self.start_date_edit.setDisplayFormat("yyyy-MM-dd HH:mm:ss")
self.end_date_edit.setDisplayFormat("yyyy-MM-dd HH:mm:ss")
if service_id in SERVICE_MANAGER.available_services(service_type):
config = SERVICE_MANAGER.service_details(service_type, service_id)
else:
# this is the default configuration for a newly created service!
config = {'settings': {'outputxml': True, 'httpcodenodata': True}}
self.set_state_from_config(config)
self.title_edit.textChanged.connect(self._changed)
self.web_service_url_edit.textChanged.connect(self._changed)
self.combo_http_code_nodata.addItem('204', '204')
for _, w in self.WIDGET_MAP.items():
widget = getattr(self, w)
if isinstance(widget, QCheckBox):
widget.toggled.connect(self._changed)
elif isinstance(widget, QSpinBox):
widget.valueChanged.connect(self._changed)
self.check_http_code_nodata.toggled.connect(self._changed)
self.combo_http_code_nodata.currentIndexChanged.connect(self._changed)
if self.service_type in (SERVICE_MANAGER.WMS, SERVICE_MANAGER.WFS,
SERVICE_MANAGER.WCS):
for w in [self.group_capabilities, self.group_bounding_box]:
w.setEnabled(False)
w.hide()
else:
self.group_ogc_layers.setEnabled(False)
self.group_ogc_layers.hide()
self.group_label.hide()
self.group_edit.hide()
if self.service_type == SERVICE_MANAGER.FDSNSTATION:
for w in [
self.check_filter_by_eventid,
self.check_filter_by_originid,
self.check_filter_by_magnitudeid,
self.check_filter_by_focalmechanismid,
self.check_filter_by_catalog,
self.check_filter_by_contributor,
self.check_filter_by_contributorid,
self.check_filter_by_event_type,
self.check_filter_by_magnitude_type,
self.check_can_include_all_origins,
self.check_can_include_all_magnitudes,
self.check_can_include_all_origins_multiple,
self.check_can_include_all_magnitudes_multiple,
self.check_can_include_arrivals,
self.check_can_include_all_stations_magnitudes,
self.check_has_limit_of_entries,
self.spin_has_limit_of_entries,
self.check_can_filter_by_depth
]:
w.setEnabled(False)
self.button_load_service.clicked.connect(self._load_service)
self._changed()
def __init__(
self,
iface, # pylint: disable=unused-argument,too-many-branches
service_type: str,
service_id: str,
parent: Optional[QWidget] = None):
"""Constructor."""
super().__init__(parent)
self.setupUi(self)
self.qml_style_name_combo.addItem('')
self.qml_style_name_combo_mdp.addItem('')
for name, props in SERVICE_MANAGER.PRESET_STYLES.items():
if props['type'] in ('events', 'stations'):
self.qml_style_name_combo.addItem(name)
elif props['type'] == 'macroseismic':
self.qml_style_name_combo_mdp.addItem(name)
self.service_type = service_type
self.service_id = service_id
self.start_date_edit.setDisplayFormat("yyyy-MM-dd HH:mm:ss")
self.end_date_edit.setDisplayFormat("yyyy-MM-dd HH:mm:ss")
if service_id in SERVICE_MANAGER.available_services(service_type):
config = SERVICE_MANAGER.service_details(service_type, service_id)
else:
config = {}
self.set_state_from_config(config)
self.title_edit.textChanged.connect(self._changed)
self.web_service_url_edit.textChanged.connect(self._changed)
self.combo_http_code_nodata.addItem('204', '204')
for _, w in self.WIDGET_MAP.items():
widget = getattr(self, w)
if isinstance(widget, QCheckBox):
widget.toggled.connect(self._changed)
elif isinstance(widget, QSpinBox):
widget.valueChanged.connect(self._changed)
self.check_http_code_nodata.toggled.connect(self._changed)
self.combo_http_code_nodata.currentIndexChanged.connect(self._changed)
if self.service_type in (SERVICE_MANAGER.WMS, SERVICE_MANAGER.WFS):
for w in [self.group_capabilities, self.group_bounding_box]:
w.setEnabled(False)
w.hide()
else:
self.group_ogc_layers.setEnabled(False)
self.group_ogc_layers.hide()
self.group_label.hide()
self.group_edit.hide()
if self.service_type == SERVICE_MANAGER.FDSNSTATION:
for w in [
self.check_filter_by_eventid,
self.check_filter_by_originid,
self.check_filter_by_magnitudeid,
self.check_filter_by_focalmechanismid,
self.check_filter_by_catalog,
self.check_filter_by_contributor,
self.check_filter_by_contributorid,
self.check_filter_by_event_type,
self.check_filter_by_magnitude_type,
self.check_can_include_all_origins,
self.check_can_include_all_magnitudes,
self.check_can_include_arrivals,
self.check_can_include_all_stations_magnitudes,
self.check_has_limit_of_entries,
self.spin_has_limit_of_entries,
self.check_can_filter_by_depth
]:
w.setEnabled(False)
self._changed()
def get_config(self) -> dict: # pylint: disable=too-many-branches
"""
Returns the configuration of the service defined in the widget
"""
if self.service_id in SERVICE_MANAGER.available_services(
self.service_type):
config = deepcopy(
SERVICE_MANAGER.service_details(self.service_type,
self.service_id))
else:
config = {'default': {}, 'settings': {}}
config['title'] = self.title_edit.text()
config['group'] = self.group_edit.text()
config['servicedescription'] = self.service_description_edit.text()
config[
'servicedescriptionurl'] = self.service_description_url_edit.text(
)
config['datadescription'] = self.data_description_edit.text()
config['datadescriptionurl'] = self.data_description_url_edit.text()
config[
'publications'] = [] if not self.publications_text_edit.toPlainText(
) else self.publications_text_edit.toPlainText().split('\n')
config['manualurl'] = self.webservice_manual_url_edit.text()
config['datalicense'] = self.data_license_edit.text()
config['datalicenseurl'] = self.data_license_url_edit.text()
config['dataprovider'] = self.data_provider_edit.text()
config['dataproviderurl'] = self.data_provider_url_edit.text()
config['endpointurl'] = self.web_service_url_edit.text()
config['styleurl'] = self.qml_style_url_edit.text()
config['default']['style'] = self.qml_style_name_combo.currentText()
config['mdpstyleurl'] = self.qml_style_url_edit_mdp.text()
config['default'][
'mdp_style'] = self.qml_style_name_combo_mdp.currentText()
if self.start_date_edit.dateTime().isValid():
config['datestart'] = self.start_date_edit.dateTime().toString(
Qt.ISODate)
else:
config['datestart'] = ''
if self.end_date_edit.dateTime().isValid():
config['dateend'] = self.end_date_edit.dateTime().toString(
Qt.ISODate)
else:
config['dateend'] = ''
if self.group_bounding_box.isEnabled():
bounding_box = [
self.min_long_spin.value(),
self.min_lat_spin.value(),
self.max_long_spin.value(),
self.max_lat_spin.value()
]
config['boundingbox'] = bounding_box
if self.group_capabilities.isEnabled():
settings = {}
for key, w in self.WIDGET_MAP.items():
widget = getattr(self, w)
if not widget.isEnabled():
continue
if isinstance(widget, QCheckBox):
settings[key] = widget.isChecked()
elif isinstance(widget, QSpinBox):
settings[key] = widget.value()
if self.check_http_code_nodata.isChecked():
settings[
'httpcodenodata'] = self.combo_http_code_nodata.currentData(
)
config['settings'] = settings
if self.group_ogc_layers.isEnabled():
config['default']['layers'] = json.loads(
self.ogc_layers_edit.text())
return config
def __init__(
self, # pylint: disable=too-many-locals,too-many-statements
service_type,
event_service,
event_start_date=None,
event_end_date=None,
event_min_magnitude=None,
event_max_magnitude=None,
limit_extent_rect=False,
min_latitude=None,
max_latitude=None,
min_longitude=None,
max_longitude=None,
limit_extent_circle=False,
circle_latitude=None,
circle_longitude=None,
circle_min_radius=None,
circle_max_radius=None,
circle_radius_unit=QgsUnitTypes.DistanceDegrees,
earthquake_number_mdps_greater=None,
earthquake_max_intensity_greater=None,
event_ids=None,
contributor_id=None,
network_codes=None,
station_codes=None,
locations=None,
parent=None,
output_fields=None,
output_type=EXTENDED,
convert_negative_depths=False,
depth_unit=QgsUnitTypes.DistanceMeters,
event_type: Optional[str] = None,
updated_after: Optional[QDateTime] = None,
url=None):
super().__init__(parent=parent)
self.service_type = service_type
self.event_service = event_service
self.event_start_date = event_start_date
self.event_end_date = event_end_date
self.event_min_magnitude = event_min_magnitude
self.event_max_magnitude = event_max_magnitude
self.event_type = event_type
self.limit_extent_rect = limit_extent_rect
self.min_latitude = min_latitude
self.max_latitude = max_latitude
self.min_longitude = min_longitude
self.max_longitude = max_longitude
self.limit_extent_circle = limit_extent_circle
self.circle_latitude = circle_latitude
self.circle_longitude = circle_longitude
self.circle_min_radius = circle_min_radius
self.circle_max_radius = circle_max_radius
self.circle_radius_unit = circle_radius_unit
self.earthquake_number_mdps_greater = earthquake_number_mdps_greater
self.earthquake_max_intensity_greater = earthquake_max_intensity_greater
self.event_ids = event_ids
self.contributor_id = contributor_id
self.network_codes = network_codes
self.station_codes = station_codes
self.locations = locations
self.pending_event_ids = event_ids
self.macro_pending_event_ids = event_ids
self.output_type = output_type
self.convert_negative_depths = convert_negative_depths
self.depth_unit = depth_unit
self.updated_after = updated_after
self.url = url
self.service_config = SERVICE_MANAGER.service_details(
self.service_type, self.event_service)
s = QgsSettings()
self.preferred_origins_only = s.value('/plugins/qquake/output_preferred_origins', True, bool) or not \
self.service_config['settings'].get('queryincludeallorigins', False)
self.preferred_magnitudes_only = s.value('/plugins/qquake/output_preferred_magnitude', True, bool) or not \
self.service_config['settings'].get('queryincludeallmagnitudes', False)
self.preferred_mdp_only = s.value(
'/plugins/qquake/output_preferred_mdp', True, bool)
self.output_fields = output_fields[:] if output_fields else []
if self.output_type == self.EXTENDED:
if not self.preferred_origins_only and "!IsPrefOrigin" not in self.output_fields:
self.output_fields.append("!IsPrefOrigin")
if not self.preferred_magnitudes_only and "!IsPrefMag" not in self.output_fields:
self.output_fields.append("!IsPrefMag")
if not self.preferred_mdp_only and "!IsPrefMdpset" not in self.output_fields:
self.output_fields.append("!IsPrefMdpset")
self.result = QuakeMlParser(
convert_negative_depths=self.convert_negative_depths,
depth_unit=self.depth_unit)
else:
self.result = BasicTextParser(
convert_negative_depths=self.convert_negative_depths,
depth_unit=self.depth_unit)
self.missing_origins = set()
self.is_missing_origin_request = False
self.require_mdp_basic_text_request = self.output_type == self.BASIC and self.service_type == SERVICE_MANAGER.MACROSEISMIC
self.is_mdp_basic_text_request = False
self.is_first_request = True
def __init__(
self, # pylint: disable=too-many-locals,too-many-branches,too-many-statements
service_type: str,
service_id: str,
initial_fields: List[str],
parent=None):
"""Constructor."""
super().__init__(parent)
self.setupUi(self)
self.service_type = service_type
self.service_id = service_id
service_config = SERVICE_MANAGER.service_details(
service_type, service_id)
self.setWindowTitle(self.tr('Output Table Options'))
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
QgsGui.enableAutoGeometryRestore(self)
self.default_fields = None
s = QgsSettings()
short_field_names = s.value('/plugins/qquake/output_short_field_names',
True, bool)
if short_field_names:
self.radio_short_fields.setChecked(True)
else:
self.radio_long_fields.setChecked(True)
self.radio_short_fields.toggled.connect(self.change_field_names)
nodes = []
for _, settings in SERVICE_MANAGER.get_field_config(
self.service_type)['field_groups'].items():
if self.service_type != SERVICE_MANAGER.FDSNSTATION and settings[
'label'] == 'station':
continue
if self.service_type == SERVICE_MANAGER.FDSNSTATION and settings[
'label'] not in ('station', 'general', 'network'):
continue
parent_node = ModelNode([settings['label']])
for f in settings['fields']:
if f.get('skip'):
continue
if f['source'] is not None:
if f['source'].startswith('eventParameters'):
path = f['source'][len('eventParameters>event>'):]
elif f['source'].startswith('macroseismicParameters'):
path = f['source'][len('macroseismicParameters>'):]
else:
path = f['source'][len('FDSNStationXML>'):]
else:
path = ''
if initial_fields:
checked = f['source'] in initial_fields
else:
checked = s.value(
'/plugins/qquake/output_field_{}'.format(
path.replace('>', '_')), True, bool)
parent_node.addChild(
ModelNode([
'checked', f['field_short' if short_field_names else
'field_long'], path
],
checked,
user_data=f))
nodes.append(parent_node)
self.field_model = SimpleNodeModel(
nodes,
headers=[
self.tr('Include'),
self.tr('Field Name'),
self.tr('StationML Source') if service_type
== SERVICE_MANAGER.FDSNSTATION else self.tr('QuakeML Source')
])
self.fields_tree_view.setModel(self.field_model)
self.fields_tree_view.expandAll()
for r in range(self.field_model.rowCount(QModelIndex())):
self.fields_tree_view.setFirstColumnSpanned(r, QModelIndex(), True)
self.output_preferred_origins_only_check.setVisible(
self.service_type in (SERVICE_MANAGER.MACROSEISMIC,
SERVICE_MANAGER.FDSNEVENT))
self.output_preferred_origins_only_check.setEnabled(
service_config['settings'].get('queryincludeallorigins', False))
self.output_preferred_magnitudes_only_check.setVisible(
self.service_type in (SERVICE_MANAGER.MACROSEISMIC,
SERVICE_MANAGER.FDSNEVENT))
self.output_preferred_magnitudes_only_check.setEnabled(
service_config['settings'].get('queryincludeallmagnitudes', False))
self.check_include_event_params_in_mdp.setVisible(
self.service_type == SERVICE_MANAGER.MACROSEISMIC)
self.check_include_event_params_in_mdp.setEnabled(
self.service_type == SERVICE_MANAGER.MACROSEISMIC)
self.output_preferred_mdp_only_check.setVisible(
self.service_type == SERVICE_MANAGER.MACROSEISMIC)
self.output_features_group_box.setVisible(
self.service_type in (SERVICE_MANAGER.MACROSEISMIC,
SERVICE_MANAGER.FDSNEVENT))
preferred_origins_only_checked = s.value(
'/plugins/qquake/output_preferred_origins', True, bool)
self.output_preferred_origins_only_check.setChecked(
preferred_origins_only_checked)
preferred_magnitudes_only_checked = s.value(
'/plugins/qquake/output_preferred_magnitude', True, bool)
self.output_preferred_magnitudes_only_check.setChecked(
preferred_magnitudes_only_checked)
preferred_mdp_only_checked = s.value(
'/plugins/qquake/output_preferred_mdp', True, bool)
self.output_preferred_mdp_only_check.setChecked(
preferred_mdp_only_checked)
include_quake_details_in_mdp = s.value(
'/plugins/qquake/include_quake_details_in_mdp', True, bool)
self.check_include_event_params_in_mdp.setChecked(
include_quake_details_in_mdp)
self.reset_fields_button.clicked.connect(self.reset_fields)
self.check_all_button.clicked.connect(lambda: self._check_all(True))
self.uncheck_all_button.clicked.connect(lambda: self._check_all(False))
self.reset_fields_button.setVisible(False)
if 'fields' in SERVICE_MANAGER.service_details(service_type,
service_id)['default']:
self.set_default_fields(
SERVICE_MANAGER.service_details(
service_type, service_id)['default']['fields'])
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('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(self.allow_basic_output)
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)
self.block_style_changes = True
s = QgsSettings()
prev_event_style = s.value(
'/plugins/qquake/last_event_style_{}_{}'.format(
self.service_type, self.service_id), '', str)
prev_mdp_style = s.value(
'/plugins/qquake/last_mdp_style_{}_{}'.format(
self.service_type, self.service_id), '', str)
prev_station_style = s.value(
'/plugins/qquake/last_station_style_{}_{}'.format(
self.service_type, self.service_id), '', str)
default_style_index = self.combo_style_macro.findText(prev_mdp_style)
if prev_mdp_style and default_style_index >= 0:
self.combo_style_macro.setCurrentIndex(default_style_index)
elif isinstance(service_config['default'].get('style'),
dict) and 'mdp' in service_config['default']['style']:
default_style_index = self.combo_style_macro.findText(
service_config['default']['style']['mdp'].get('style', ''))
if default_style_index >= 0:
self.combo_style_macro.setCurrentIndex(default_style_index)
default_style_index = self.combo_style_epicentres.findText(
prev_event_style)
if prev_event_style and default_style_index >= 0:
self.combo_style_epicentres.setCurrentIndex(default_style_index)
elif isinstance(
service_config['default']['style'],
dict) and 'events' in service_config['default']['style']:
default_style_index = self.combo_style_epicentres.findText(
service_config['default']['style']['events'].get('style', ''))
if default_style_index >= 0:
self.combo_style_epicentres.setCurrentIndex(
default_style_index)
default_style_index = self.combo_style_stations.findText(
prev_station_style)
if prev_station_style and default_style_index >= 0:
self.combo_style_stations.setCurrentIndex(default_style_index)
elif isinstance(
service_config['default']['style'],
dict) and 'stations' in service_config['default']['style']:
default_style_index = self.combo_style_stations.findText(
service_config['default']['style']['stations'].get(
'style', ''))
if default_style_index >= 0:
self.combo_style_stations.setCurrentIndex(default_style_index)
self.block_style_changes = False
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)