geoknow / facete2 Goto Github PK

It must be possible to serialize the application state as a JSON object, from which the state can be later restored.

Although Facete 1 provides code for this purpose, this code needs to be enhanced such that multiple references to the same object can be correctly restored. (The original code is only suitable for tree structures)

To some extent this can be easily added, by setting an 'isLoading' flag in the scope of components making a request.

There are several tricky parts though:
In Facete 1, a loading spinner was shown in the facet tree at each node being loaded, which was actually pretty nice, as it served as kind of a progress indicator.
The question is, how can we have that in the facet tree of Facete2?
Also, it should also be possible to let the user (or system) cancel workflows that take too long.

Currently, the data table only shows data for the map selection.

In the data section, create a tabset with two tabs:

• 'All': Shows data regardless of map selection
• 'Map': Shows data related to items on the map

This problem stems from the FacetTreeService creating the root node, whereas the tagger is part of the FacetService.

For the sake of encapsulation, I am not sure whether the FacetTreeService should access the FacetService's tagger. Maybe rather have a factory for root nodes on the FacetService?

I guess the latter makes sense: the FacetService should provide the service to get a facet for a certain path, with all its tags (and possibly other information).

There are several scenarios for customization of the data. Each of these formats is useful, however the applicable use cases differ:

• A table showing the triples corresponding to a certain node in the facet tree.
  Useful for export of all information directly related to a set of resources. Such table could be directly serialized as CSV and one of the RDF formats.

  [subject, predicate, object]
  <http://rdf.freebase.com/ns/m.07-nxm> rdfs:label "Europa-Park"@en
  <http://rdf.freebase.com/ns/m.07-nxm> rdfs:label "Europa-Park"@de
  

• A table where facets have been linked to columns.
  Works well with the http://fp7-pp.publicdata.eu/sparql dataset, where one can e.g. create a table with columns [project, partner, amount] with the purpose of viewing fundings of project partners. CSV export of such table is straight forward. RDF export would include only the triples relevant for the construction of the table.
  [project, partner, amount]
  [LOD2, UniLei, 1.3mio]

  This approach may lead to denormalized tables:
  [item, rdfs:label, rdfs:type]

  <http://rdf.freebase.com/ns/m.07-nxm> "Europa-Park"@en freebase:AmusementPark
  <http://rdf.freebase.com/ns/m.07-nxm> "Europa-Park"@de fbo:AmusementPark
  <http://rdf.freebase.com/ns/m.07-nxm> "Europa-Park"@en owl:Thing
  <http://rdf.freebase.com/ns/m.07-nxm> "Europa-Park"@de owl:Thing
  

• A list for each property with the corresponding values.
  This corresponds to grouping and nesting the data, and thus JSON and XML could be suitable export formats. CSV export would yield a two column table with a 'key' and a 'values' column (the latter containing a list of values). RDF export would include all relevant triples.

  rdfs:label: "Europa-Park"@en, "Europa-Park"@de
  rdf:type: fbo:AmusementPark, owl:Thing
  

• Multiple tables.
  We could add support for the definition of multiple tables. The user could then export each table as a separate CSV file.

Divs with pointer-events:none have non-clickable scrollbars in chromium.
Fixed via SmartDataAnalytics/Jassa-UI-Angular@0277174

In several cases it may not be possible to remove table columns via the facet tree, for example because the sparql service was changed, which does not provide that facet.

At present, only line selection works

• Only include types which have been searched for (not all types)
• Use only 1 label (pick one randomly if there are more than one) - filter by lang
• Wikilink (filtered by lang)
• Freebase-Uri
• Freebase-Website URL

Similar to #15
Although we can filter by the values of a property (e.g. isLocatedIn), we can at present not enforce the existence of this property.

At the minimum, we need a project depth of three:

ServiceSpace -> ConceptSpace -> DataSpace

• A ServiceSpace is assigned a single SPARQL service. The ServiceSpace is a container for ConceptSpaces. For example, a ServiceSpace could be created for each of DBpedia, Freebase and LinkedGeoData.
• A ConceptSpace holds configurations for faceted search for a set of concepts. Furthermore, it is a container for configurations of what data to associate with the concept. For example, there may be a ConceptSpace for 'Museums in Freebase'.
  These concept's extensions are obtained by evaluation over the ServiceSpace's sparqlService.
• A DataSpace, conceptually, allows one specify workflows for retrieving information (attributes) with the concept's extension as a starting point.
  For instance there may be DataSpaces for 'The labels and geocoordinates of Museums in Freebase'

Extensions could be
UserSpace -> ProjectSpace -> ServiceSpace ...

• Users may have a space in which they can create projects.
• Projects would then be composed of service spaces.
  If we followed, the eclipse structure, there would also be a WorkSpace between UserSpace and ProjectSpace.

Note that we need to distinguish between logical grouping of items (i.e. folders), and technical structures (such that a ConceptSpace requires a (parent?) ServiceSpace). Or a ConceptSpace needs a sparqlService which is provided by a corresponding ServiceSpace?

Proposed summary:

instanceLabel, typeLabel, instancePage, typePage, instanceUri, typeUri, lon, lat

Currently there is no way to search for places, such as Berlin or Stanford.
We could port the old code which uses the free Nominatim service.

Possibly it makes sense to extend this search bar later. For example, searching for 'Airports' on googlemaps will show all airports.

We could automatically enable a facet (or at least show the user a corresponding choice) if the search term matches a class and the place search results have a lower ranking by some scoring function:
A search for 'Airport' or 'Museum' will also yield results on Nominatim. However, the e.g. edit distance will be closer to the class name rather than any of the place names.

This feature now exists.
Triggering an export will also show an entry in the notifications list, with a progress bar of the current state. Once the export is complete (i.e. the data has been retrieved at the server), the client is offered options to download it.

I can't believe something uses fixed heights...

Installation process returns with rc > 0 as tomcat start fails.

service tomcat7 start says "failed", too.

Setting JAVA_OPTS -Xmx1024m makes tomcat starting but service/initscript still believes that start was not successful.

I noticed that selecting a facet in the facet tree causes the facet value list to refresh twice, which certainly has a negative impact on performance. Also, this revealed a hard-to-find-but-now-fixed bug in the Sparql-Cache, which would return the result set of a prior execution of the same query. The second result set was then empty, because it was consumed by the logic following the first invocation.

In essence, all refresh routines of the jassa-ui components need to be checked for how often they are called per action.

Use output

git describe --always --dirty | cut -d '-' -f 3-

This would enable one to create overlays of different concepts.
A color attribute would then be needed as well.
Also, once this works, show a list of active MapLinks.

(MapLink is the property path that relates the faceted-search-concept to the geo-concept).

This depends on Issue #4

Based on the columns that are linked to the table, infer which triples should be exported.

Exhibit shows messages such as '10 Items could not be shown' when there are items that do not meet criteria for their visualization on e.g. a map.
Furthermore, upon clicking this message, exhibit shows the list of resources that cause the problems.

In the simplest form, this is:
"Among the resources matching the faceted search criteria, select those which are not related to the map by neither of the map links"

However, in the fp7 dataset, we are actually also interested in messages such as
"For n projects, there exist some partners without geometries".

For this use case, we would need a schema like:
[main-resource, geometry-resource, geometry-literal]
Whereas the geometry-literal may be null.

Any main-resource with a NULL entry for the literal is then considered incomplete for map display.

The Freebase RDF URLs differ from the HTML pages.

The proper JDBC driver seems to be missing (Ubuntu, tomcat 7.0.30) or misconfigured. Where is this key defined?

I've come to the conclusion, that we need a generic label system, in the sense, that there needs to be a way to obtain a label (or even HTML element / text node) for any (JavaScript) object - where the object could be e.g. an RDF term (rdf.Node), but also a sparql.Path, or whatever.

The backend code provides a pretty powerful API for registering constraint types, but we somehow need to integrate range constraints into the user interface.

There is a lot of added value in being able to make use of the items in the sparql-table, instead of just seeing them.

Actually, this issue belongs to jassa-ui-angular component; facete just references these components.

Support for adding custom SPARQL datasets.
This is a more lightweight thing to implement than persisting the whole workspace state from Issue #1

Occasionally it would be very convenient if a WKT string could be just pasted into the search field, and then Facete would display it on the map.

Furthermore, Facete could show on option to add the geometry as a constraint.

It became apparent, that if there is a list of properties which relate a concept to the geographical resources, it should also be possible to directly create a constraint from it, which limits the set of resources to those that can be shown on the map.