@enervance/insight-cim-model 0.0.1

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

@@ -0,0 +1,205 @@
+/** Component for showing detailed information about a dataset */
+
+define(
+  function( require ) {
+    var Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        DatasetEditTpl = require( "plugins/text!app/templates/dataset-edit.tpl" ),
+        CodeMirror = require( "lib/codemirror" ),
+        CodeMirrorTurtle = require( "mode/turtle/turtle" );
+
+    var MAX_EDITABLE_SIZE = 10000;
+
+    var DatasetEdit = Backbone.Marionette.ItemView.extend( {
+
+      initialize: function() {
+        _.bindAll( this, "onCountGraphs", "onModelChanged", "onSelectDataset",
+                         "onShownTab", "onShownEditTab", "onGraphContent",
+                         "onSaveEdit", "onCancelEdit" );
+
+        this.model.on( "change", this.onModelChanged );
+        this._editor = null;
+
+        fui.vent.on( "shown.bs.tab", this.onShownTab );
+      },
+
+      template: _.template( DatasetEditTpl ),
+
+      ui: {
+        listGraphs: ".action.list-graphs",
+        editor: "#graph-editor",
+        graphName: "input.graph-name",
+        saveButton: "button.save-edit",
+        cancelButton: "button.cancel-edit"
+      },
+
+      el: "#edit .with-dataset",
+
+      events: {
+        "click .list-graphs": "onCountGraphs",
+        "click .select-dataset": "onSelectDataset",
+        "click .save-edit": "onSaveEdit",
+        "click .cancel-edit": "onCancelEdit"
+      },
+
+      templateHelpers: {
+      },
+
+      serializeData: function() {
+        return this.model;
+      },
+
+      /** Alias for the model */
+      dataset: function() {
+        return this.model;
+      },
+
+      // event handlers
+
+      onModelChanged: function() {
+        if (!this.model.counting) {
+          this.render();
+        }
+      },
+
+      onCountGraphs: function( e ) {
+        e.preventDefault();
+        this.model.count();
+      },
+
+      /** Event that triggers when any tab is shown */
+      onShownTab: function( tab ) {
+        if (tab.attr("href") === "#edit") {
+          this.onShownEditTab();
+        }
+      },
+
+      /** When the tab is show, ensure the editor element is initialised */
+      onShownEditTab: function() {
+        this.showEditor();
+      },
+
+      /** When rendering, only show the code mirror editor if the tab is visible */
+      onRender: function() {
+        this.showEditor();
+      },
+
+      /** Ensure the code mirror element is visible */
+      showEditor: function() {
+        if (this.editorElementVisible() && this.editorNotYetInitialised()) {
+          this._editor = null;
+          this.editorElement();
+        }
+      },
+
+      /** Return true if the editor container element is visible */
+      editorElementVisible: function()  {
+        return this.ui.editor.is( ":visible" );
+      },
+
+      /** Return true if the CodeMirror element has not yet been initialised */
+      editorNotYetInitialised: function() {
+        return this.ui.editor.is( ":not(:has(.CodeMirror))" );
+      },
+
+      /** User has (attempted to) select a dataset */
+      onSelectDataset: function( e ) {
+        e.preventDefault();
+        var self = this;
+        var elem = $(e.currentTarget);
+        var graphName = elem.data( "graph-name" );
+        var graphSize = parseInt( elem.data( "graph-size" ));
+
+        if (graphSize > MAX_EDITABLE_SIZE) {
+          alert( "Sorry, that dataset is too large to load into the editor" );
+        }
+        else {
+          if (this.dirtyCheck()) {
+            $(".nav.graphs").find( ".active" ).removeClass( "active" );
+            elem.parent().addClass( "active" );
+
+            var gn = this.setGraphName( graphName );
+            this.dataset()
+                .fetchGraph( gn )
+                .done( self.onGraphContent );
+          }
+        }
+      },
+
+      /** Return true if the edit buffer is not dirty, or if the user says OK */
+      dirtyCheck: function() {
+        return true; // TODO
+      },
+
+      /** Return the DOM node representing the query editor */
+      editorElement: function() {
+        if (!this._editor) {
+          this._editor = new CodeMirror( this.ui.editor.get(0), {
+            lineNumbers: true,
+            mode: "turtle"
+          } );
+        }
+        return this._editor;
+      },
+
+      /** Set the graph name, return the actual name used */
+      setGraphName: function( name ) {
+        var text = (name === "default" || name === "default graph") ? "default" : name;
+
+        this.ui.graphName.val( text );
+
+        return text;
+      },
+
+      /** Get the graph name */
+      graphName: function() {
+        return this.ui.graphName.val();
+      },
+
+      /** Server has sent the content of the graph encoded as turtle */
+      onGraphContent: function( data ) {
+        this.editorElement().setValue( data );
+      },
+
+      /** User wants to save changes */
+      onSaveEdit: function( e ) {
+        e.preventDefault();
+        var self = this;
+
+        var turtle = this.editorElement().getValue();
+        this.dataset()
+            .putGraph( turtle, this.graphName() )
+            .done( function( data ) {
+              var nq = parseInt( data.quadCount );
+              var nt = parseInt( data.tripleCount );
+              var typ = (nq > nt) ? "quad" : "triple";
+              var s = (nq + nt) === 1 ? "" : "s";
+              var msg = sprintf( "Added %d %s%s", nq + nt, typ, s );
+
+              self.showFeedback( msg, "" );
+            } )
+            .error( function( jqhxr, msg, err ) {
+              self.showFeedback( err || msg, "text-warning" );
+            } );
+      },
+
+      /** User wants to discard changes */
+      onCancelEdit: function( e ) {
+        e.preventDefault();
+        this.ui.graphName.val( "" );
+        this.editorElement().setValue( "" );
+      },
+
+      /** Show feedback from operations */
+      showFeedback: function( msg, cls ) {
+        $(".feedback").html( sprintf( "<span class='%s'>%s</span>", cls, msg ) );
+      }
+
+
+    });
+
+
+    return DatasetEdit;
+  }
+);

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

@@ -0,0 +1,76 @@
+/** Component for showing detailed information about a dataset */
+
+define(
+  function( require ) {
+    var Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        DatasetInfoTpl = require( "plugins/text!app/templates/dataset-info.tpl" ),
+        DatasetStatsView = require( "app/views/dataset-stats" ),
+        DatasetStatsModel = require( "app/models/dataset-stats" );
+
+    var DatasetInfo = Backbone.Marionette.ItemView.extend( {
+
+      initialize: function() {
+        _.bindAll( this, "onModelChanged", "onCountGraphs" );
+
+        this.showStatistics( true );
+        this.model.on( "change", this.onModelChanged );
+      },
+
+      template: _.template( DatasetInfoTpl ),
+
+      ui: {
+        stats: "#statistics",
+        count: ".count-graphs"
+      },
+
+      el: "#info .with-dataset",
+
+      events: {
+        "click .count-graphs": "onCountGraphs"
+      },
+
+      templateHelpers: {
+      },
+
+      serializeData: function() {
+        return this.model;
+      },
+
+      /** Alias for the model */
+      dataset: function() {
+        return this.model;
+      },
+
+      // event handlers
+
+      onModelChanged: function() {
+        if (!this.model.counting) {
+          this.render();
+          this.showStatistics( false );
+        }
+      },
+
+      onCountGraphs: function( e ) {
+        e.preventDefault();
+        this.model.count();
+      },
+
+      showStatistics: function( keep ) {
+        var self = this;
+
+        this.model
+            .statistics( keep )
+            .done( function( data ) {
+                     var statsModel = new DatasetStatsModel( self.dataset(), data );
+                     new DatasetStatsView( {model: statsModel} ).render();
+                   } );
+      }
+
+    });
+
+
+    return DatasetInfo;
+  }
+);

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

@@ -0,0 +1,173 @@
+define(
+  function( require ) {
+    var Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        datasetManagementViewTpl = require( "plugins/text!app/templates/dataset-management.tpl" );
+
+    var DataManagementView = Backbone.Marionette.ItemView.extend( {
+
+      initialize: function(){
+        _.bindAll( this, "onRemoveDataset", "onConfirmAction",
+                         "onDatasetRemoveSuccess", "onDatasetRemoveFail",
+                         "onTaskStatus", "onTaskFailed", "cleanup" );
+
+        this.listenTo( this.model, "change", this.onModelChange, this );
+
+        fui.vent.on( "action.delete.confirm", this.onConfirmRemoveDataset, this );
+        fui.vent.on( "action.backup.confirm", this.onConfirmBackupDataset, this );
+
+        fui.vent.on( "task.status", this.onTaskStatus, this );
+        fui.vent.on( "task.failed", this.onTaskFailed, this );
+      },
+
+      template: _.template( datasetManagementViewTpl ),
+
+      ui: {
+        actionConfirmModal: "#actionConfirmModal"
+      },
+
+      el: "#dataset-management",
+
+      events: {
+        "click .action.remove": "onRemoveDataset",
+        "click .action.confirm": "onConfirmAction",
+        "click .action.backup": "onBackupDataset"
+      },
+
+      templateHelpers: {
+      },
+
+      cleanup: function() {
+        this.unbind();
+        this.undelegateEvents();
+        this.model.unbind( 'change', this.onModelChange, this ); 
+        fui.vent.unbind( 'action.delete.confirm', this.onConfirmRemoveDataset, this );
+      },
+
+      /** If the model changes, update the summary */
+      onModelChange: function( event ) {
+         this.cleanup();
+         this.render();
+      },
+
+      /** User has requested a dataset be removed */
+      onRemoveDataset: function( e ) {
+        e.preventDefault();
+        var elem = $(e.currentTarget);
+        var dsId = elem.data( "ds-id" );
+        var msg = sprintf( "Are you sure you want to delete dataset <code>%s</code>? This action cannot be reversed.", dsId );
+
+        this.showConfirmationModal( msg, dsId, "action.delete.confirm" );
+      },
+
+      /** User has requested a dataset be backed up */
+      onBackupDataset: function( e ) {
+        e.preventDefault();
+        var elem = $(e.currentTarget);
+        var dsId = elem.data( "ds-id" );
+        var msg = sprintf( "Are you sure you want to create a backup of dataset <code>%s</code>? This action may take some time to complete", dsId );
+
+        this.showConfirmationModal( msg, dsId, "action.backup.confirm" );
+      },
+
+      /** Show a generic modal confirmation */
+      showConfirmationModal: function( msg, dsId, eventId ) {
+        this.ui.actionConfirmModal
+               .find( ".modal-body p" )
+               .html( msg );
+
+        this.ui.actionConfirmModal
+               .find( ".action.confirm" )
+               .data( "ds-id", dsId )
+               .data( "event-id", eventId );
+
+        this.clearFeedback();
+        this.ui.actionConfirmModal.modal( 'show' );
+      },
+
+      /** Generic response to confirming the current modal dialogue */
+      onConfirmAction: function( e ) {
+        e.preventDefault();
+        var elem = $(e.currentTarget);
+        var dsId = elem.data( "ds-id" );
+        var eventId = elem.data( "event-id" );
+
+        //this.ui.actionConfirmModal.modal( 'hide' );
+        $('.modal.in').modal('hide');
+        $('body').removeClass('modal-open');
+        $('.modal-backdrop').remove();
+        _.delay( function() {
+          fui.vent.trigger( eventId, dsId );
+        }, 100 );
+      },
+
+      /** User has confirmed that the dataset can be deleted */
+      onConfirmRemoveDataset: function( dsId ) {
+        var self = this;
+
+        fui.models
+           .fusekiServer
+           .dataset( dsId )
+           .deleteDataset()
+           .done( function( data ) {self.onDatasetRemoveSuccess( data, dsId );} )
+           .error( function( jqxhr, msg, err ) {self.onDatasetRemoveFail( jqxhr, msg, err, dsId );} );
+      },
+
+      /** Callback after successfully removing a dataset */
+      onDatasetRemoveSuccess: function( data, dsId ) {
+        this.model.loadServerDescription();
+      },
+
+      /** Removing the dataset did not work: notify the user */
+      onDatasetRemoveFail: function( jqxhr, msg, err, dsId ) {
+        this.feedbackArea( dsId )
+            .html( sprintf( "<p class='text-warning'>Sorry, removing dataset %s did not work, because: '%s'</p>", dsId, err || msg ) );
+      },
+
+      /** User has confirmed backing up the dataset */
+      onConfirmBackupDataset: function( dsId ) {
+        var self = this;
+
+        fui.models
+           .fusekiServer
+           .dataset( dsId )
+           .backupDataset();
+      },
+
+      /** Remove any current feedback content */
+      clearFeedback: function() {
+        $(".action.feedback").empty();
+      },
+
+      /** Long running task has updated status */
+      onTaskStatus: function( status ) {
+        var task = status.task;
+        var msg = sprintf( "<p>Task <strong>%s</strong> started at %s%s</p>",
+                           task.operationType,
+                           task.taskDescription.started,
+                           status.finished ? sprintf( ", finished at %s", status.finished ) : " &ndash; ongoing" );
+
+        this.feedbackArea( status.dsId )
+            .html( msg );
+      },
+
+      /** Long running task has failed to start */
+      onTaskFailed: function( status ) {
+        this.feedbackArea( status.dsId )
+            .html( sprintf( "<p class='text-danger'>Task %s failed: '%s'</p>", task.operationType, task.errorMessage ));
+      },
+
+      /** Find the feedback area for a particular dataset */
+      feedbackArea: function( dsId ) {
+        return $(sprintf( ".action[data-ds-id='%s']", dsId ) )
+               .parent()
+               .siblings(".action.feedback");
+      }
+
+    });
+
+
+    return DataManagementView;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/views/dataset-selection-list.js

@@ -0,0 +1,58 @@
+/**
+ * This view presents a list of the available datasets for the user to interact
+ * with.
+ */
+
+define(
+  function( require ) {
+    var Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        datasetSelectionListTemplate = require( "plugins/text!app/templates/dataset-selection-list.tpl" );
+
+    var DatasetSelectionListView = Backbone.Marionette.ItemView.extend( {
+      initialize: function(){
+//        _.bindAll(this, "onFilter", "onModelChange");
+        this.listenTo( this.model, "change", this.onModelChange, this );
+      },
+
+      template: _.template( datasetSelectionListTemplate ),
+
+      el: "#dataset-selection-list",
+
+      ui: {
+      },
+
+      events: {
+//        "change #independent-variable-selection": "selectVariable",
+//        "click a.action.filter": "onFilter"
+      },
+
+      templateHelpers: {
+      },
+
+//      /** Update the model when the user changes the selection */
+//      selectVariable: function( event ) {
+//        this.model.set( "independentVarSelection", this.ui.variableSelection.val() );
+//      },
+//
+//      /** User wants to open the filter dialog */
+//      onFilter: function( event ) {
+//        var varModel = bgViz.models.variablesConfig.independentVar();
+//        var rangeType = varModel.component.range().rangeType();
+//        var viewName = rangeType.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+//
+//        bgViz.layouts.filterDialog.showFilter( viewName, varModel );
+//      },
+
+      /** If the model changes, update the summary */
+      onModelChange: function( event ) {
+//        this.ui.summary.html( this.model.independentVar().component.range().summarise() );
+      }
+
+    });
+
+
+    return DatasetSelectionListView;
+  }
+);

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

@@ -0,0 +1,84 @@
+/**
+ * Reusable component that encapsulates selecting a dataset to work on in a given page.
+ * Takes the FusekiServer as a model, and populates a select control to choose one of the
+ * current datasets. If the dataset changes, this view will update the `selectedDatasetName`
+ * on the model, and trigger the event `dataset.changed`.
+ **/
+
+define(
+  function( require ) {
+    "use strict";
+
+    var Marionette = require( "marionette" ),
+        Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        sprintf = require( "sprintf" ),
+        datasetSelectorTemplate = require( "plugins/text!app/templates/dataset-selector.tpl" );
+
+    var DatasetSelectorView = Backbone.Marionette.ItemView.extend( {
+
+      initialize: function(){
+        this.listenTo( this.model, "change", this.render, this );
+      },
+
+      template: _.template( datasetSelectorTemplate ),
+
+      el: ".dataset-selector-container",
+
+      ui: {
+        select: ".dataset-selector select"
+      },
+
+      events: {
+        "change .dataset-selector select": "onChangeDataset"
+      },
+
+      /**
+       * After rendering, set up the dataset picker and notify the rest of the
+       * app if the default dataset name is known.
+       */
+      onRender: function() {
+        var selector = $('.selectpicker');
+        selector.selectpicker('refresh');
+
+        if (selector.val()) {
+          this.unHideDatasetElements();
+          this.onChangeDataset();
+        }
+      },
+
+      /**
+       * Respond to a change in the dataset name selection by updating
+       * the underlying model. TODO: should also update the application
+       * URL.
+       */
+      onChangeDataset: function( e ) {
+        var newDatasetName = this.ui.select.val();
+        this.model.set( "selectedDatasetName", newDatasetName );
+        this.notifyDatasetName( newDatasetName );
+      },
+
+      /**
+       * Ensure that elements that should be visible when a dataset is known
+       * are not hidden, and vice-versa.
+       */
+      unHideDatasetElements: function() {
+        $(".no-dataset").addClass( "hidden" );
+        $(".with-dataset").removeClass( "hidden" );
+      },
+
+      /** Trigger an event to notify other components that the dataset
+       * name has been selected.
+       */
+      notifyDatasetName: function( dsName ) {
+        fui.vent.trigger( "dataset.changed", dsName || this.ui.select.val() );
+      }
+
+
+    });
+
+
+    return DatasetSelectorView;
+  }
+);

package/test/apache-jena-fuseki-interface/data/apache-jena-fuseki-3.12.0/webapp/js/app/views/dataset-simple-create.js

@@ -0,0 +1,102 @@
+/** Component for creating a new dataset with a few simple options */
+
+define(
+  function( require ) {
+    var Backbone = require( "backbone" ),
+        _ = require( "underscore" ),
+        fui = require( "app/fui" ),
+        DatasetSimpleCreateTpl = require( "plugins/text!app/templates/dataset-simple-create.tpl" );
+
+    var DatasetSimpleCreate = Backbone.Marionette.ItemView.extend( {
+
+      initialize: function() {
+        _.bindAll( this, "onCommitSimple", "clearWarnings" );
+      },
+
+      template: _.template( DatasetSimpleCreateTpl ),
+
+      ui: {
+      },
+
+      el: "#dataset-simple-create",
+
+      events: {
+        "click a.action.commit.simple": "onCommitSimple",
+        "submit form": "onCommitSimple",
+        "keydown input[name=dbName]": "clearWarnings"
+      },
+
+      templateHelpers: {
+      },
+
+      serializeData: function() {
+        return this.model;
+      },
+
+      // event handlers
+
+      onCommitSimple: function( e ) {
+        e.preventDefault();
+
+        if (this.validateSimpleForm()) {
+          var datasetName = $("input[name=dbName]").val().trim();
+          $("input[name=dbName]").val(datasetName);
+          var options = $("#simple-edit form").serializeArray();
+          fui.models.fusekiServer.updateOrCreateDataset( null, options )
+                                 .done( this.showDataManagementPage )
+                                 .fail( this.showFailureMessage );
+        }
+      },
+
+//      onCommitUpload: function( e ) {
+//        e.preventDefault();
+//
+//        if (this.validateUploadForm()) {
+//          $("#uploadForm").ajaxSubmit( {
+//                            success: this.showDataManagementPage,
+//                            error: this.showFailureMessage
+//                           });
+//        }
+//      },
+//
+      showDataManagementPage: function( e ) {
+        location = "?tab=datasets";
+      },
+
+      /** Todo: need to do a better job of responding to errors */
+      showFailureMessage: function( jqXHR, textStatus, errorThrown ) {
+        $(".errorOutput").html( sprintf( "<p class='has-error'>Sorry, that didn't work because:</p><pre>%s</pre>", errorThrown || textStatus ) );
+      },
+
+      /** Clear current warning states */
+      clearWarnings: function() {
+        this.clearValidation();
+        $(".errorOutput").empty();
+      },
+
+      // validation
+
+      validateSimpleForm: function() {
+        this.clearValidation();
+
+        if (! $("input[name=dbName]").val() || 0 === $("input[name=dbName]").val().trim().length) {
+          $(".dbNameValidation").removeClass("hidden")
+                                .parents(".form-group" )
+                                .addClass( "has-error" );
+          return false;
+        }
+
+        return true;
+      },
+
+      clearValidation: function() {
+        $(".has-error").removeClass( "has-error" );
+        $(".has-warning").removeClass( "has-warning" );
+      }
+
+    });
+
+
+    return DatasetSimpleCreate;
+  }
+);