.

publish/src/app.rs

@@ -76,8 +76,8 @@ pub(crate) enum SearchResultClickAction {
 struct SearchState {
     window_id: window::Id,
     action: SearchResultClickAction,
+    entity_selection: Option<LabeledIri>,
     query: String,
-    type_: LabeledIri,
     results: Vec<SearchDocument>,
 }
 
@@ -313,46 +313,46 @@ impl Publisher {
                 self.modified = true;
             }
             Message::OpenQueryWindow(action) => {
-                if let Some(search_state) = &mut self.search_state {
+                let selected_entity_class = match action {
-                    search_state.action = action;
+                    SearchResultClickAction::Predicate(_) => Some(rdf::PROPERTY),
-                } else {
+                    SearchResultClickAction::Object(key) => {
-                    if let Some(entity) = self.ontology.searchable_classes(&*language::ENGLISH_OR_UNTAGGED).into_iter().next() {
+                        self.document
-                        let (id, window_task) = window::open(Settings::default());
+                            .dataset()
-                        self.search_state = Some(SearchState {
+                            .quads
-                            window_id: id,
+                            .get(key)
-                            action,
+                            .and_then(|quad| if quad.predicate == rdf::TYPE {
-                            query: String::new(),
+                                Some(rdfs::CLASS)
-                            type_: entity,
+                            } else { None })
-                            results: Vec::new(),
+                    },
-                        });
+                    SearchResultClickAction::URLInput => None,
-                        task = window_task.map(|_| Message::None)
+                };
-                    };
+
+                let (id, window_task) = window::open(Settings::default());
+                self.search_state = Some(SearchState {
+                    window_id: id,
+                    action,
+                    entity_selection: None,
+                    query: String::new(),
+                    results: Vec::new(),
+                });
+                task = window_task.map(|_| Message::None);
+
+                if let Some(selected_entity_class) = selected_entity_class {
+                    let selection = self.ontology.info(&selected_entity_class.into_owned(), &*language::ENGLISH_OR_UNTAGGED);
+                    task = task.chain(Task::done(Message::QueryTypeUpdated(selection)));
                 }
             }
             Message::QueryTypeUpdated(type_) => {
                 if let Some(search_state) = &mut self.search_state {
-                    search_state.type_ = type_;
+                    search_state.entity_selection = Some(type_);
                     task = Task::done(Message::QueryUpdated(search_state.query.clone()));
                 }
             }
             Message::QueryUpdated(new_query) => {
                 if let Some(search_state) = &mut self.search_state {
-                    let selected_entity_class = &search_state.type_.iri;
+                    let catalog_id = search_state.entity_selection
-                    let catalog_id = match search_state.action {
+                        .clone()
-                        SearchResultClickAction::Predicate(_) => self.ontology.catalog_id(&rdf::PROPERTY.into_owned()),
+                        .and_then(|info| self.ontology.catalog_id(&info.iri));
-                        SearchResultClickAction::Object(key) => {
-                            self.document
-                                .dataset()
-                                .quads
-                                .get(key)
-                                .and_then(|quad| if quad.predicate == rdf::TYPE {
-                                    self.ontology.catalog_id(&rdfs::CLASS.into_owned())
-                                } else {
-                                    self.ontology.catalog_id(selected_entity_class)
-                                })
-                        },
-                        SearchResultClickAction::URLInput => self.ontology.catalog_id(selected_entity_class),
-                    };
 
                     let index = self.index.clone();
                     let query = new_query.clone();
@@ -677,12 +677,9 @@ impl Publisher {
                 .into_iter()
                 .collect::<Vec<_>>();
 
-            let type_selector = pick_list(Some(&search_state.type_), entities, ToString::to_string)
+            let type_selector = pick_list(search_state.entity_selection.as_ref(), entities, ToString::to_string)
                 .on_select(|selection| Message::QueryTypeUpdated(selection));
 
-            let fields = self.ontology.fields_for_class(&search_state.type_.iri, &*language::ENGLISH_OR_UNTAGGED)
-                .expect("Unable to load fields for class");
-
             let mut columns = vec![
                 table::column(text("CURIE"), |document: &SearchDocument| {
                     let iri = document.get_first(Schema::iri_field())
@@ -696,6 +693,13 @@ impl Publisher {
                 })
             ];
 
+            let fields = if let Some(selection) = search_state.entity_selection.as_ref() {
+                self.ontology.fields_for_class(&selection.iri, &*language::ENGLISH_OR_UNTAGGED)
+                    .expect("Unable to load fields for class")
+            } else {
+                vec![]
+            };
+
             for field in fields.into_iter() {
                 let field_name = field.name.clone();
                 columns.push(