@enervance/insight-cim-model 0.0.1

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/models/dataset.js

@@ -0,0 +1,262 @@
+/**
+ * Backbone model denoting the remote Fuseki server.
+ */
+define(
+  function( require ) {
+    "use strict";
+
+    var Marionette = require( "marionette" ),
+        Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        sprintf = require( "sprintf" ),
+        Task = require( "app/models/task" );
+
+    /**
+     * This model represents the core representation of the remote Fuseki
+     * server. Individual datasets have their own model.
+     */
+    var Dataset = Backbone.Model.extend( {
+      initialize: function( datasetDescription, baseURL, mgmtURL ) {
+        this.set( datasetDescription );
+        this.set( {
+                    baseURL: baseURL,
+                    mgmtURL: mgmtURL,
+                    counts: {},
+                    countPerformed: false,
+                    counting: false,
+                    statistics: false
+                  } );
+      },
+
+      /* x is the empty object if baseURL is "" 
+       * Ensure it is always a string.
+       */
+      getStr: function(key) {
+        var x = this.get( key );
+        return jQuery.isEmptyObject(x) ? "" : x ;
+      },
+  
+      baseURL: function() {
+        return this.getStr( "baseURL" );
+      },
+
+      mgmtURL: function() {
+        return this.getStr( "mgmtURL" );
+      },
+
+      mgmtActionURL: function() {
+        return this.get( "mgmtURL" ) + this.name();
+      },
+
+      statisticsURL: function() {
+        return sprintf( "%s/$/stats%s", this.baseURL(), this.name() );
+      },
+
+      name: function() {
+        return this.get( "ds.name" );
+      },
+
+      services: function() {
+        return this.get( "ds.services" );
+      },
+
+      countPerformed: function() {
+        return this.get( "countPerformed" );
+      },
+
+      counts: function() {
+        return this.get( "counts" );
+      },
+
+      serviceTypes: function() {
+        return _.map( this.services(), function( s ) {return s["srv.type"];} );
+      },
+
+      /** Return a descriptive data-structure listing all this datasets services */
+      servicesDescription: function() {
+        var description = [];
+        var self = this;
+
+        _.each( this.services(), function( s ) {
+          _.each( s["srv.endpoints"], function( e ) {
+            description.push( {label: s["srv.description"],
+                               url: self.datasetEndpointURL( e )
+                              } );
+          } );
+        } );
+
+        description.sort( function( d0, d1 ) {
+          return (d0.label < d1.label) ? -1 : (d0.label > d1.label ? 1 : 0);
+        } );
+
+        return description;
+      },
+
+      /** Return the first service that has the given type */
+      serviceOfType: function( serviceType ) {
+        return _.find( this.services(), function( s ) {
+          return s["srv.type"] === serviceType;
+        } );
+      },
+
+      /** Return the first endpoint of the first service that has the given type */
+      endpointOfType: function( serviceType ) {
+        var service = this.serviceOfType( serviceType );
+        return service && _.first( service["srv.endpoints"] );
+      },
+
+      /* Return URL for a service of a given type or null, if no such service */
+      endpointURL: function( serviceType ) {
+        var endpoint = this.endpointOfType( serviceType );
+        return endpoint ? this.datasetEndpointURL( endpoint ) : null;
+      },
+
+      /** Return the URL for the given endpoint */
+      datasetEndpointURL: function( endpoint ) {
+        return sprintf( "%s%s/%s", this.baseURL(), this.name(), endpoint );
+      },
+
+      /** Return the sparql query URL for this dataset, if it has one, or null */
+      queryURL: function() {
+        return this.endpointURL( "Query" ) ;
+      },
+
+      /** Return the sparql query URL for this dataset, if it has one, or null */
+      quadsURL: function() {
+        return this.endpointURL( "Quads" ) ;
+      },
+
+      /** Return the sparql update URL for this dataset, if it has one, or null */
+      updateURL: function() {
+        return this.endpointURL( "Update" ) ;
+      },
+
+      /** Return the GSP write URL for this dataset, if it has one, or null */
+      graphStoreProtocolURL: function() {
+        if ( this.endpointURL( "GSP" ) )
+            // Old name
+            return this.endpointURL( "GSP" ) ;
+        return this.endpointURL( "GSP_RW" ) ;
+      },
+
+      /** Return the GSP read URL for this dataset, if it has one, or null */
+      graphStoreProtocolReadURL: function() {
+        return this.endpointURL( "GSP_R" ) ;
+      },
+
+      /** Return the upload URL for this dataset, if it has one, or null */
+      uploadURL: function( graphName ) {
+        if (this.graphStoreProtocolURL() !== null) {
+          return sprintf( "%s%s", this.graphStoreProtocolURL(), (graphName === "default" ? "" : ("?graph=" + graphName) ));
+        }
+        else {
+          return null;
+        }
+      },
+
+      /** Perform the action to delete the dataset. Returns the Ajax deferred object */
+      deleteDataset: function() {
+        return $.ajax( {
+          url: this.mgmtActionURL(),
+          type: 'DELETE'
+        } );
+      },
+
+      /** Perform the action of taking a backup of this dataset */
+      backupDataset: function() {
+        var backupURL = sprintf( "%s/$/backup%s", this.baseURL(), this.name() );
+        var ds = this;
+
+        return $.ajax( {
+          url: backupURL,
+          type: 'POST'
+        } )
+          .done( function( taskDescription ) {
+            new Task( ds, "backup", taskDescription );
+          } );
+      },
+
+      /**
+       * Request the statistics for this dataset, and return the promise object for the callback.
+       * @param keep If truthy, and we have existing statistics, re-use the existing stats
+       * */
+      statistics: function( keep ) {
+        var self = this;
+        var currentStats = this.get( "statistics" );
+
+        if (currentStats && keep) {
+          return $.Deferred().resolveWith( null, currentStats );
+        }
+        else {
+          return $.getJSON( this.statisticsURL() )
+                  .then( function( data ) {
+                    self.set( "statistics", data );
+                    return data;
+                  } );
+        }
+      },
+
+      /** Perform a count query to determine the size of the dataset. Changes the size property when done,
+       * but also returns the JQuery promise object used to monitor the query response */
+      count: function() {
+        var self = this;
+        var query1 = sprintf( "select (count(*) as ?count) {?s ?p ?o}" );
+        var query2 = sprintf( "select ?g (count(*) as ?count) {graph ?g {?s ?p ?o}} group by ?g" );
+
+        self.set( "counting", true );
+
+        var updateCount = function( model, result, graph ) {
+          var n = parseInt( result.count.value );
+          var counts = _.extend( {}, model.get( "counts" ) );
+          counts[graph] = n;
+          model.set( "counts", counts );
+        };
+
+        $.getJSON( self.queryURL(), { query: query1 } )
+         .done( function( data ) {
+           updateCount( self, data.results.bindings[0], "default graph" );
+
+           $.getJSON( self.queryURL(), { query: query2 } )
+            .done( function( data ) {
+              _.each( data.results.bindings, function( binding ) {
+                if (binding.g) {
+                  updateCount( self, binding, binding.g.value );
+                }
+              } );
+            } );
+
+           self.set( {countPerformed: true, counting: false} );
+         } );
+      },
+
+      /**
+       * Fetch the content of the given graph as Turtle. Return the jQuery promise
+       * object for the Ajax call.
+       */
+      fetchGraph: function( graphName ) {
+        return $.ajax( this.graphStoreProtocolReadURL(),
+                       {method: "get",
+                        headers: {Accept : "text/turtle; charset=utf-8"},
+                        dataType: "html",
+                        data: {graph: graphName}
+                       } );
+      },
+
+      /**
+       * Put the given Turtle content back to the server using the given graph name
+       */
+      putGraph: function( turtle, graphName ) {
+        return $.ajax( sprintf( "%s?graph=%s", this.graphStoreProtocolURL(), graphName ),
+                       {method: "put",
+                        dataType: "json",
+                        data: turtle,
+                        contentType: "text/turtle; charset=uft-8"
+                       } );
+      }
+
+    } );
+
+    return Dataset;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/models/fuseki-server.js

@@ -0,0 +1,180 @@
+/**
+ * Backbone model denoting the remote Fuseki server.
+ */
+
+define(
+  function( require ) {
+    "use strict";
+
+    var Marionette = require( "marionette" ),
+        Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        sprintf = require( "sprintf" ),
+        Dataset = require( "app/models/dataset" ),
+        PageUtils = require( "app/util/page-utils" );
+
+    var DATASETS_MANAGEMENT_PATH = "/$/datasets";
+
+    /**
+     * This model represents the core representation of the remote Fuseki
+     * server. Individual datasets have their own model.
+     */
+    var FusekiServer = Backbone.Model.extend( {
+      /** This initializer occurs when the module starts, not when the constructor is invoked */
+      init: function( options ) {
+        this._baseURL = this.currentRootPath();
+        this._managementURL = null;
+        this.set( "selectedDatasetName", PageUtils.queryParam( "ds" ) )
+      },
+
+      baseURL: function() {
+        return this._baseURL;
+      },
+
+      /** Return the URL from which we extract the details of the current server */
+      serverDetailsURL: function() {
+        return sprintf( "%s/$/server", this.baseURL() );
+      },
+
+      /** Return the URL for issuing commands to the management API, or null if no API defined */
+      managementURL: function() {
+        return this._managementURL;
+      },
+
+      /** Return the URL for getting the stats for all datasets */
+      statsURL: function() {
+        return sprintf( "%s/$/stats", this.managementURL() );
+      },
+
+      /** Return the list of datasets that this server knows about. Each dataset will be a Dataset model object */
+      datasets: function() {
+        return this.get( "datasets" );
+      },
+
+      /** Return the dataset with the given name */
+      dataset: function( dsName ) {
+        return _.find( this.datasets(), function( ds ) {return dsName === ds.name();} )
+      },
+
+      /** Return the name of the currently selected dataset, if known */
+      selectedDatasetName: function() {
+        return this.get( "selectedDatasetName" );
+      },
+
+      /** Return the dataset that is currently selected, or null */
+      selectedDataset: function() {
+        var dsName = this.selectedDatasetName();
+        return dsName && this.dataset( dsName );
+      },
+
+      /** Load and cache the remote server description. Trigger change event when done */
+      loadServerDescription: function() {
+          var self = this;
+          return this.getJSON( this.serverDetailsURL() )
+              .done( function( data ) {
+                  self.saveServerDescription( data );
+              } )
+              .then( function() {
+                  fui.vent.trigger( "models.fuseki-server.ready" );
+              });
+      },
+
+      /** Store the server description in this model */
+      saveServerDescription: function( serverDesc ) {
+        // wrap each dataset JSON description as a dataset model
+        var bURL = this.baseURL();
+        var mgmtURL = bURL;
+
+        if (serverDesc.admin) {
+	       // This is too simple.  window.location.port may be empty and matches protocol.
+	       //mgmtURL = bURL.replace( ":" + window.location.port, ":" + serverDesc.admin.port );
+           //console.log("managementURL -- s/"+window.location.port+"/"+serverDesc.admin.port+"/") ;
+	       var path = window.location.pathname.replace( /\/[^/]*$/, "" ) ;
+ 	       mgmtURL = sprintf( "%s//%s:%s%s",  window.location.protocol, window.location.hostname, serverDesc.admin, path );
+        }
+	    this._managementURL = mgmtURL ;
+	
+        var datasets = _.map( serverDesc.datasets, function( d ) {
+          return new Dataset( d, bURL, mgmtURL + DATASETS_MANAGEMENT_PATH );
+        } );
+
+        datasets.sort( function( ds0, ds1 ) {
+          if (ds0.name() > ds1.name()) {
+            return 1;
+          }
+          else if (ds0.name() < ds1.name()) {
+            return -1;
+          }
+          else
+            return 0;
+        } );
+
+        this.set( {
+          serverDescription: serverDesc,
+          datasets: datasets,
+          ready: true
+        } );
+      },
+
+      /**
+       * Get the given relative path from the server, and return a promise object which will
+       * complete with the JSON object denoted by the path.
+       */
+      getJSON: function( path, data ) {
+        return $.getJSON( path, data );
+      },
+
+      /** Update or create a dataset by posting to its endpoint */
+      updateOrCreateDataset: function( datasetId, data ) {
+        var url = sprintf( "%s/$/datasets%s", this.managementURL(),
+                           datasetId ? ("/" + datasetId) : ""
+                         );
+
+        return $.ajax( url,
+                       { data: data,
+                         method: "post"
+                       }
+                     );
+      },
+
+      /** Extract the server root path from the current window href
+       * This is the path, from /, without protocol, host or port.
+       * Then the browser adds protocol, host or port.
+       * Sometimes, the app does not know URL the browser used.
+       * For example, in docker, the port may have been remapped,
+       * or with a reverse proxy, https may have been terminated.
+       */
+      currentRootPath: function() {
+        var path = window.location.pathname.replace( /\/[^/]*$/, "" );
+          /*
+            console.log("window.location="+window.location) ;
+            console.log("window.location.href="+window.location.href) ;
+            
+            console.log("window.location.protocol="+window.location.protocol) ;
+            console.log("window.location.host="+window.location.host) ;
+            console.log("window.location.hostname="+window.location.hostname) ;
+            console.log("window.location.port="+window.location.port) ;
+            console.log("window.location.pathname="+window.location.pathname) ;
+            
+            console.log("window.location.origin="+window.location.origin) ;
+            console.log("window.location.hash="+window.location.hash) ;
+            console.log("window.location.search="+window.location.search) ;
+            console.log("path='"+path+"'") ;
+          */
+        return path ;
+      }
+    } );
+
+    // when the models module starts, automatically load the server description
+    fui.models.addInitializer( function( options ) {
+      var fusekiServer = new FusekiServer();
+      fui.models.fusekiServer = fusekiServer;
+
+      fusekiServer.init( options );
+      fusekiServer.loadServerDescription();
+    } );
+
+    return FusekiServer;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/models/task.js

@@ -0,0 +1,105 @@
+/**
+ * A long-running task, which periodically pings the server for its task status
+ */
+
+define(
+  function( require ) {
+    "use strict";
+
+    var Marionette = require( "marionette" ),
+        Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        sprintf = require( "sprintf" );
+
+    /* Constants */
+
+    var MS = 1000;
+    var MAX_DELAY = 10 * MS;
+
+    /**
+     * This model represents a long running task process
+     */
+    var Task = function( ds, operationType, taskDescription ) {
+      this.taskDescription = taskDescription;
+      this.ds = ds;
+      this.operationType = operationType;
+      this.delay = 500;
+
+      _.bindAll( this, "checkTaskStatus", "onCurrentTaskStatusFail", "onCurrentTaskStatus" );
+
+      this.checkTaskStatus();
+    };
+
+    _.extend( Task.prototype, {
+      /** Return the unique ID (on this server) of the task */
+      taskId: function() {
+        return this.taskDescription.taskId;
+      },
+
+      /** Return the URL for the task's API */
+      taskURL: function() {
+        return sprintf( "%s/$/tasks/%s", this.ds.baseURL(), this.taskId() );
+      },
+
+      /** Test the current status of the task */
+      checkTaskStatus: function() {
+        $.getJSON( this.taskURL() )
+         .done( this.onCurrentTaskStatus )
+         .fail( this.onCurrentTaskStatusFail )
+      },
+
+      /** Successful result from checking the task */
+      onCurrentTaskStatus: function( taskDescription ) {
+        this.taskDescription = taskDescription;
+
+        var status = {
+            task: this,
+            dsId: this.ds.name(),
+            finished: this.taskFinished()
+        };
+
+        fui.vent.trigger( "task.status", status );
+
+        this.queueTaskStatusCheck();
+      },
+
+      /** Failed to check the task */
+      onCurrentTaskStatusFail: function( jqxhr, msg, err ) {
+        var status = {
+            task: this,
+            dsId: this.ds.name(),
+            errorMessage: err || msg
+        };
+
+        fui.vent.trigger( "task.failed", status );
+      },
+
+      /** Re-queue the status check if the task is not yet complete */
+      queueTaskStatusCheck: function() {
+        if (!this.taskFinished()) {
+          _.delay( this.checkTaskStatus, this.statusDelay() );
+        }
+      },
+
+      /** Return the completion time if the task has been fid, otherwise null */
+      taskFinished: function() {
+        return this.taskDescription.finished;
+      },
+
+      /** Return the delay in ms until the next status check is due. */
+      statusDelay: function() {
+        var t = this.delay;
+
+        if (t < MAX_DELAY) {
+          this.delay = t * 2;
+        }
+
+        return t;
+      }
+    } );
+
+    return Task;
+  }
+);
+

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/models/validation-options.js

@@ -0,0 +1,85 @@
+/**
+ * Backbone model denoting the remote Fuseki server.
+ */
+define(
+  function( require ) {
+    "use strict";
+
+    var Marionette = require( "marionette" ),
+        Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        sprintf = require( "sprintf" );
+
+    /**
+     * This model represents the users current choice of options to the
+     * validation service.
+     */
+    var ValidationOptions = Backbone.Model.extend( {
+      initialize: function() {
+        this.set( {validateAs: "sparql"} );
+        this.set( {outputFormat: "algebra"} );
+      },
+
+      validateAs: function() {
+        return this.get( "validateAs" );
+      },
+
+      validateAsQuery: function() {
+        return this.validateAs() === "sparql" || this.validateAs() === "arq";
+      },
+
+      setValidateAs: function( va ) {
+        this.set( "validateAs", va );
+        console.log( JSON.stringify( this.toJSON() ));
+        console.log( "----" );
+      },
+
+      outputFormat: function() {
+        return this.get( "outputFormat" );
+      },
+
+      setOutputFormat: function( of ) {
+        this.set( "outputFormat", of );
+      },
+
+      validationURL: function() {
+        switch (this.get( "validateAs" )) {
+        case "sparql":  return "/validate/query";
+        case "arq":  return "/validate/query";
+        case "Turtle": return "/validate/data";
+        case "TriG": return "/validate/data";
+        case "N-Triples": return "/validate/data";
+        case "N-Quads": return "/validate/data";
+        }
+      },
+
+      payloadParam: function() {
+        return this.validateAsQuery() ? "query" : "data";
+      },
+
+      toJSON: function() {
+        var json = {
+          languageSyntax: this.validateAs(),
+          lineNumbers: true
+        };
+
+        if (this.validateAsQuery()) {
+          json.outputFormat = this.outputFormat();
+        }
+
+        return json;
+      }
+
+    } );
+
+    // when the models module starts, create the model
+    fui.models.addInitializer( function( options ) {
+      fui.models.validationOptions = new ValidationOptions();
+      fui.vent.trigger( "models.validation-options.ready" );
+    } );
+
+
+    return ValidationOptions;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/qonsole-config.js

@@ -0,0 +1,27 @@
+/** Standalone configuration for qonsole on index page */
+
+define( [], function() {
+  return {
+    prefixes: {
+      "rdf":      "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+      "rdfs":     "http://www.w3.org/2000/01/rdf-schema#",
+      "owl":      "http://www.w3.org/2002/07/owl#",
+      "xsd":      "http://www.w3.org/2001/XMLSchema#"
+    },
+    queries: [
+      { "name": "Selection of triples",
+        "query": "SELECT ?subject ?predicate ?object\nWHERE {\n" +
+                 "  ?subject ?predicate ?object\n}\n" +
+                 "LIMIT 25"
+      },
+      { "name": "Selection of classes",
+        "query": "SELECT DISTINCT ?class ?label ?description\nWHERE {\n" +
+                 "  ?class a owl:Class.\n" +
+                 "  OPTIONAL { ?class rdfs:label ?label}\n" +
+                 "  OPTIONAL { ?class rdfs:comment ?description}\n}\n" +
+                 "LIMIT 25",
+        "prefixes": ["owl", "rdfs"]
+      }
+    ]
+  };
+} );