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)