Moves list_notebooks to ContentManager

IPython/html/static/base/js/contentmanager.js

@@ -1,209 +1,255 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
     'base/js/dialog',
 ], function(IPython, $, utils, dialog) {
     var ContentManager = function(options) {
         // Constructor
         //
         // A contentmanager handles passing file operations
         // to the back-end.  This includes checkpointing
         // with the normal file operations.
         //
         // Parameters:
         //  options: dictionary
         //      Dictionary of keyword arguments.
         //          events: $(Events) instance
         //          base_url: string
         this.version = 0.1;
         this.events = options.events;
         this.base_url = options.base_url;
     };
  
     /**
+     * Notebook Functions
+     */
+
+    /**
      * Creates a new notebook file at the specified path, and
      * opens that notebook in a new window.
      *
      * @method scroll_to_cell
      * @param {String} path The path to create the new notebook at
      */
     ContentManager.prototype.new_notebook = function(path) {
         var base_url = this.base_url;
         var settings = {
             processData : false,
             cache : false,
             type : "POST",
             dataType : "json",
             async : false,
             success : function (data, status, xhr){
                 var notebook_name = data.name;
                 window.open(
                     utils.url_join_encode(
                         base_url,
                         'notebooks',
                         path,
                         notebook_name
                     ),
                     '_blank'
                 );
             },
             error : function(xhr, status, error) {
                 utils.log_ajax_error(xhr, status, error);
                 var msg;
                 if (xhr.responseJSON && xhr.responseJSON.message) {
                     msg = xhr.responseJSON.message;
                 } else {
                     msg = xhr.statusText;
                 }
                 dialog.modal({
                     title : 'Creating Notebook Failed',
                     body : "The error was: " + msg,
                     buttons : {'OK' : {'class' : 'btn-primary'}}
                 });
             }
         };
         var url = utils.url_join_encode(
             base_url,
             'api/notebooks',
             path
         );
         $.ajax(url,settings);
     };
 
     ContentManager.prototype.delete_notebook = function(name, path) {
         var settings = {
             processData : false,
             cache : false,
             type : "DELETE",
             dataType : "json",
             success : $.proxy(this.events.trigger, this.events,
                 'notebook_deleted.ContentManager',
                 {
                     name: name,
                     path: path
                 }),
             error : utils.log_ajax_error
         };
         var url = utils.url_join_encode(
             this.base_url,
             'api/notebooks',
             path,
             name
         );
         $.ajax(url, settings);
     };
 
     ContentManager.prototype.rename_notebook = function(path, name, new_name) {
         var that = this;
         var data = {name: new_name};
         var settings = {
             processData : false,
             cache : false,
             type : "PATCH",
             data : JSON.stringify(data),
             dataType: "json",
             contentType: 'application/json',
             success :  function (json, status, xhr) {
                 that.events.trigger('notebook_rename_success.ContentManager',
                     json);
             },
             error : function (xhr, status, error) {
                 that.events.trigger('notebook_rename_error.ContentManager',
                     [xhr, status, error]);
             }
         };
         var url = utils.url_join_encode(
             this.base_url,
             'api/notebooks',
             path,
             name
         );
         $.ajax(url, settings);
     };
 
     ContentManager.prototype.save_notebook = function(path, name, content,
         extra_settings) {
         var that = notebook;
         // Create a JSON model to be sent to the server.
         var model = {
             name : name,
             path : path,
             content : content
         };
         // time the ajax call for autosave tuning purposes.
         var start =  new Date().getTime();
         // We do the call with settings so we can set cache to false.
         var settings = {
             processData : false,
             cache : false,
             type : "PUT",
             data : JSON.stringify(model),
             contentType: 'application/json',
             success : $.proxy(this.events.trigger, this.events,
                 'notebook_save_success.ContentManager',
                 $.extend(model, { start : start })),
             error : function (xhr, status, error) {
                 that.events.trigger('notebook_save_error.ContentManager',
                     [xhr, status, error, model]);
             }
         };
         if (extra_settings) {
             for (var key in extra_settings) {
                 settings[key] = extra_settings[key];
             }
         }
         var url = utils.url_join_encode(
             this.base_url,
             'api/notebooks',
             path,
             name
         );
         $.ajax(url, settings);
     };
 
+    /**
+     * Checkpointing Functions
+     */
+
     ContentManager.prototype.save_checkpoint = function() {
         // This is not necessary - integrated into save
     };
 
     ContentManager.prototype.restore_checkpoint = function(notebook, id) {
         that = notebook;
         this.events.trigger('notebook_restoring.Notebook', checkpoint);
         var url = utils.url_join_encode(
             this.base_url,
             'api/notebooks',
             this.notebook_path,
             this.notebook_name,
             'checkpoints',
             checkpoint
         );
         $.post(url).done(
             $.proxy(that.restore_checkpoint_success, that)
         ).fail(
             $.proxy(that.restore_checkpoint_error, that)
         );
     };
 
     ContentManager.prototype.list_checkpoints = function(notebook) {
         that = notebook;
         var url = utils.url_join_encode(
             that.base_url,
             'api/notebooks',
             that.notebook_path,
             that.notebook_name,
             'checkpoints'
         );
         $.get(url).done(
             $.proxy(that.list_checkpoints_success, that)
         ).fail(
             $.proxy(that.list_checkpoints_error, that)
         );
     };
 
+    /**
+     * File management functions
+     */
+
+    /**
+     * List notebooks and directories at a given path
+     *
+     * On success, load_callback is called with an array of dictionaries
+     * representing individual files or directories.  Each dictionary has
+     * the keys:
+     *     type: "notebook" or "directory"
+     *     name: the name of the file or directory
+     *     created: created date
+     *     last_modified: last modified dat
+     *     path: the path
+     * @method list_notebooks
+     * @param {String} path The path to list notebooks in
+     * @param {Function} load_callback called with list of notebooks on success
+     * @param {Function} error_callback called with ajax results on error
+     */
+    ContentManager.prototype.list_contents = function(path, load_callback,
+        error_callback) {
+        var that = this;
+        var settings = {
+            processData : false,
+            cache : false,
+            type : "GET",
+            dataType : "json",
+            success : load_callback,
+            error : error_callback
+        };
+
+        var url = utils.url_join_encode(this.base_url, 'api', 'notebooks',
+            path);
+        $.ajax(url, settings);
+    }
+
+
     IPython.ContentManager = ContentManager;
 
     return {'ContentManager': ContentManager};
 }); 

IPython/html/static/tree/js/notebooklist.js

@@ -1,496 +1,497 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
     'base/js/dialog',
 ], function(IPython, $, utils, dialog) {
     "use strict";
     
     var NotebookList = function (selector, options) {
         // Constructor
         //
         // Parameters:
         //  selector: string
         //  options: dictionary
         //      Dictionary of keyword arguments.
         //          session_list: SessionList instance
         //          element_name: string
         //          base_url: string
         //          notebook_path: string
         //          content_manager: ContentManager instance
         var that = this;
         this.session_list = options.session_list;
         // allow code re-use by just changing element_name in kernellist.js
         this.element_name = options.element_name || 'notebook';
         this.selector = selector;
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.style();
             this.bind_events();
         }
         this.notebooks_list = [];
         this.sessions = {};
         this.base_url = options.base_url || utils.get_body_data("baseUrl");
         this.notebook_path = options.notebook_path || utils.get_body_data("notebookPath");
         this.content_manager = options.content_manager;
         if (this.session_list && this.session_list.events) {
             this.session_list.events.on('sessions_loaded.Dashboard', 
                 function(e, d) { that.sessions_loaded(d); });
         }
 
 
         if (this.content_manager && this.content_manager.events) {
             this.content_manager.events.on('notebook_deleted.ContentManager',
                 function(e, d) {
                     // Remove the deleted notebook.
                     $( ":data(nbname)" ).each(function() {
                         var element = $( this );
                         if (element.data( "nbname" ) == d.name &&
                             element.data( "path" ) == d.path) {
                             element.remove();
                         }
                     });
                 });
         }
     };
 
     NotebookList.prototype.style = function () {
         var prefix = '#' + this.element_name;
         $(prefix + '_toolbar').addClass('list_toolbar');
         $(prefix + '_list_info').addClass('toolbar_info');
         $(prefix + '_buttons').addClass('toolbar_buttons');
         $(prefix + '_list_header').addClass('list_header');
         this.element.addClass("list_container");
     };
 
 
     NotebookList.prototype.bind_events = function () {
         var that = this;
         $('#refresh_' + this.element_name + '_list').click(function () {
             that.load_sessions();
         });
         this.element.bind('dragover', function () {
             return false;
         });
         this.element.bind('drop', function(event){
             that.handleFilesUpload(event,'drop');
             return false;
         });
     };
 
     NotebookList.prototype.handleFilesUpload =  function(event, dropOrForm) {
         var that = this;
         var files;
         if(dropOrForm =='drop'){
             files = event.originalEvent.dataTransfer.files;
         } else 
         {
             files = event.originalEvent.target.files;
         }
         for (var i = 0; i < files.length; i++) {
             var f = files[i];
             var name_and_ext = utils.splitext(f.name);
             var file_ext = name_and_ext[1];
 
             var reader = new FileReader();
             if (file_ext === '.ipynb') {
                 reader.readAsText(f);
             } else {
                 // read non-notebook files as binary
                 reader.readAsArrayBuffer(f);
             }
             var item = that.new_item(0);
             item.addClass('new-file');
             that.add_name_input(f.name, item, file_ext == '.ipynb' ? 'notebook' : 'file');
             // Store the list item in the reader so we can use it later
             // to know which item it belongs to.
             $(reader).data('item', item);
             reader.onload = function (event) {
                 var item = $(event.target).data('item');
                 that.add_file_data(event.target.result, item);
                 that.add_upload_button(item);
             };
             reader.onerror = function (event) {
                 var item = $(event.target).data('item');
                 var name = item.data('name')
                 item.remove();
                 dialog.modal({
                     title : 'Failed to read file',
                     body : "Failed to read file '" + name + "'",
                     buttons : {'OK' : { 'class' : 'btn-primary' }}
                 });
             };
         }
         // Replace the file input form wth a clone of itself. This is required to
         // reset the form. Otherwise, if you upload a file, delete it and try to 
         // upload it again, the changed event won't fire.
         var form = $('input.fileinput');
         form.replaceWith(form.clone(true));
         return false;
     };
 
     NotebookList.prototype.clear_list = function (remove_uploads) {
         // Clears the navigation tree.
         //
         // Parameters
         // remove_uploads: bool=False
         //      Should upload prompts also be removed from the tree.
         if (remove_uploads) {
             this.element.children('.list_item').remove();
         } else {
             this.element.children('.list_item:not(.new-file)').remove();  
         }
     };
 
     NotebookList.prototype.load_sessions = function(){
         this.session_list.load_sessions();
     };
 
 
     NotebookList.prototype.sessions_loaded = function(data){
         this.sessions = data;
         this.load_list();
     };
 
     NotebookList.prototype.load_list = function () {
-        var that = this;
-        var settings = {
-            processData : false,
-            cache : false,
-            type : "GET",
-            dataType : "json",
-            success : $.proxy(this.list_loaded, this),
-            error : $.proxy( function(xhr, status, error){
+        this.content_manager.list_contents(
+            this.notebook_path,
+            $.proxy(this.draw_notebook_list, this),
+            $.proxy( function(xhr, status, error) { 
                 utils.log_ajax_error(xhr, status, error);
-                that.list_loaded([], null, null, {msg:"Error connecting to server."});
-                             },this)
-        };
-
-        var url = utils.url_join_encode(
-                this.base_url,
-                'api',
-                'contents',
-                this.notebook_path
+                that.draw_notebook_list([], "Error connecting to server.");
+            }, this)
         );
-        $.ajax(url, settings);
     };
 
-
-    NotebookList.prototype.list_loaded = function (data, status, xhr, param) {
-        var message = 'Notebook list empty.';
-        if (param !== undefined && param.msg) {
-            message = param.msg;
-        }
+    /**
+     * Draw the list of notebooks
+     * @method draw_notebook_list
+     * @param {Array} list An array of dictionaries representing files or
+     *     direcotories.
+     * @param {String} error_msg An error message
+     */
+    NotebookList.prototype.draw_notebook_list = function (list, error_msg) {
+        var message = error_msg || 'Notebook list empty.';
         var item = null;
-        var model = null;
-        var list = data.content;
         var len = list.length;
         this.clear_list();
         var n_uploads = this.element.children('.list_item').length;
         if (len === 0) {
             item = this.new_item(0);
             var span12 = item.children().first();
             span12.empty();
             span12.append($('<div style="margin:auto;text-align:center;color:grey"/>').text(message));
         }
         var path = this.notebook_path;
         var offset = n_uploads;
         if (path !== '') {
             item = this.new_item(offset);
             model = {
                 type: 'directory',
                 name: '..',
                 path: path,
             };
             this.add_link(model, item);
             offset += 1;
         }
         for (var i=0; i<len; i++) {
-            model = list[i];
-            item = this.new_item(i+offset);
-            this.add_link(model, item);
+            if (list[i].type === 'directory') {
+                var name = list[i].name;
+                item = this.new_notebook_item(i+offset);
+                this.add_dir(path, name, item);
+            } else {
+                var name = list[i].name;
+                item = this.new_notebook_item(i+offset);
+                this.add_link(path, name, item);
+                name = utils.url_path_join(path, name);
+                if(this.sessions[name] === undefined){
+                    this.add_delete_button(item);
+                } else {
+                    this.add_shutdown_button(item,this.sessions[name]);
+                }
+            }
         }
     };
 
 
     NotebookList.prototype.new_item = function (index) {
         var item = $('<div/>').addClass("list_item").addClass("row");
         // item.addClass('list_item ui-widget ui-widget-content ui-helper-clearfix');
         // item.css('border-top-style','none');
         item.append($("<div/>").addClass("col-md-12").append(
             $('<i/>').addClass('item_icon')
         ).append(
             $("<a/>").addClass("item_link").append(
                 $("<span/>").addClass("item_name")
             )
         ).append(
             $('<div/>').addClass("item_buttons btn-group pull-right")
         ));
         
         if (index === -1) {
             this.element.append(item);
         } else {
             this.element.children().eq(index).after(item);
         }
         return item;
     };
 
 
     NotebookList.icons = {
         directory: 'folder_icon',
         notebook: 'notebook_icon',
         file: 'file_icon',
     };
 
     NotebookList.uri_prefixes = {
         directory: 'tree',
         notebook: 'notebooks',
         file: 'files',
     };
 
 
     NotebookList.prototype.add_link = function (model, item) {
         var path = model.path,
             name = model.name;
         item.data('name', name);
         item.data('path', path);
         item.find(".item_name").text(name);
         var icon = NotebookList.icons[model.type];
         var uri_prefix = NotebookList.uri_prefixes[model.type];
         item.find(".item_icon").addClass(icon).addClass('icon-fixed-width');
         var link = item.find("a.item_link")
             .attr('href',
                 utils.url_join_encode(
                     this.base_url,
                     uri_prefix,
                     path,
                     name
                 )
             );
         // directory nav doesn't open new tabs
         // files, notebooks do
         if (model.type !== "directory") {
             link.attr('target','_blank');
         }
         var path_name = utils.url_path_join(path, name);
         if (model.type == 'file') {
             this.add_delete_button(item);
         } else if (model.type == 'notebook') {
             if(this.sessions[path_name] === undefined){
                 this.add_delete_button(item);
             } else {
                 this.add_shutdown_button(item, this.sessions[path_name]);
             }
         }
     };
 
 
     NotebookList.prototype.add_name_input = function (name, item, icon_type) {
         item.data('name', name);
         item.find(".item_icon").addClass(NotebookList.icons[icon_type]).addClass('icon-fixed-width');
         item.find(".item_name").empty().append(
             $('<input/>')
             .addClass("filename_input")
             .attr('value', name)
             .attr('size', '30')
             .attr('type', 'text')
             .keyup(function(event){
                 if(event.keyCode == 13){item.find('.upload_button').click();}
                 else if(event.keyCode == 27){item.remove();}
             })
         );
     };
 
 
     NotebookList.prototype.add_file_data = function (data, item) {
         item.data('filedata', data);
     };
 
 
     NotebookList.prototype.add_shutdown_button = function (item, session) {
         var that = this;
         var shutdown_button = $("<button/>").text("Shutdown").addClass("btn btn-xs btn-danger").
             click(function (e) {
                 var settings = {
                     processData : false,
                     cache : false,
                     type : "DELETE",
                     dataType : "json",
                     success : function () {
                         that.load_sessions();
                     },
                     error : utils.log_ajax_error,
                 };
                 var url = utils.url_join_encode(
                     that.base_url,
                     'api/sessions',
                     session
                 );
                 $.ajax(url, settings);
                 return false;
             });
         // var new_buttons = item.find('a'); // shutdown_button;
         item.find(".item_buttons").text("").append(shutdown_button);
     };
 
     NotebookList.prototype.add_delete_button = function (item) {
         var new_buttons = $('<span/>').addClass("btn-group pull-right");
         var notebooklist = this;
         var delete_button = $("<button/>").text("Delete").addClass("btn btn-default btn-xs").
             click(function (e) {
                 // $(this) is the button that was clicked.
                 var that = $(this);
                 // We use the filename from the parent list_item element's
                 // data because the outer scope's values change as we iterate through the loop.
                 var parent_item = that.parents('div.list_item');
                 var nbname = parent_item.data('nbname');
                 var path = parent_item.data('path');
                 var message = 'Are you sure you want to permanently delete the notebook: ' + nbname + '?';
                 dialog.modal({
                     title : "Delete file",
                     body : message,
                     buttons : {
                         Delete : {
                             class: "btn-danger",
                             click: function() {
                                 notebooklist.content_manager.delete_notebook(nbname, path);
                             }
                         },
                         Cancel : {}
                     }
                 });
                 return false;
             });
         item.find(".item_buttons").text("").append(delete_button);
     };
 
 
     NotebookList.prototype.add_upload_button = function (item, type) {
         var that = this;
         var upload_button = $('<button/>').text("Upload")
             .addClass('btn btn-primary btn-xs upload_button')
             .click(function (e) {
                 var path = that.notebook_path;
                 var filename = item.find('.item_name > input').val();
                 var filedata = item.data('filedata');
                 var format = 'text';
                 if (filename.length === 0 || filename[0] === '.') {
                     dialog.modal({
                         title : 'Invalid file name',
                         body : "File names must be at least one character and not start with a dot",
                         buttons : {'OK' : { 'class' : 'btn-primary' }}
                     });
                     return false;
                 }
                 if (filedata instanceof ArrayBuffer) {
                     // base64-encode binary file data
                     var bytes = '';
                     var buf = new Uint8Array(filedata);
                     var nbytes = buf.byteLength;
                     for (var i=0; i<nbytes; i++) {
                         bytes += String.fromCharCode(buf[i]);
                     }
                     filedata = btoa(bytes);
                     format = 'base64';
                 }
                 var model = {
                     path: path,
                     name: filename
                 };
 
                 var name_and_ext = utils.splitext(filename);
                 var file_ext = name_and_ext[1];
                 var content_type;
                 if (file_ext === '.ipynb') {
                     model.type = 'notebook';
                     model.format = 'json';
                     try {
                         model.content = JSON.parse(filedata);
                     } catch (e) {
                         dialog.modal({
                             title : 'Cannot upload invalid Notebook',
                             body : "The error was: " + e,
                             buttons : {'OK' : {
                                 'class' : 'btn-primary',
                                 click: function () {
                                     item.remove();
                                 }
                             }}
                         });
                         return false;
                     }
                     content_type = 'application/json';
                 } else {
                     model.type = 'file';
                     model.format = format;
                     model.content = filedata;
                     content_type = 'application/octet-stream';
                 }
                 var filedata = item.data('filedata');
 
                 var settings = {
                     processData : false,
                     cache : false,
                     type : 'PUT',
                     data : JSON.stringify(model),
                     contentType: content_type,
                     success : function (data, status, xhr) {
                         item.removeClass('new-file');
                         that.add_link(model, item);
                         that.add_delete_button(item);
                         that.session_list.load_sessions();
                     },
                     error : utils.log_ajax_error,
                 };
 
                 var url = utils.url_join_encode(
                     that.base_url,
                     'api/contents',
                     that.notebook_path,
                     filename
                 );
                 
                 var exists = false;
                 $.each(that.element.find('.list_item:not(.new-file)'), function(k,v){
                     if ($(v).data('name') === filename) { exists = true; return false; }
                 });
                 if (exists) {
                     dialog.modal({
                         title : "Replace file",
                         body : 'There is already a file named ' + filename + ', do you want to replace it?',
                         buttons : {
                             Overwrite : {
                                 class: "btn-danger",
                                 click: function() { $.ajax(url, settings); }
                             },
                             Cancel : {
                                 click: function() { item.remove(); }
                             }
                         }
                     });
                 } else {
                     $.ajax(url, settings);
                 }
                 
                 return false;
             });
         var cancel_button = $('<button/>').text("Cancel")
             .addClass("btn btn-default btn-xs")
             .click(function (e) {
                 item.remove();
                 return false;
             });
         item.find(".item_buttons").empty()
             .append(upload_button)
             .append(cancel_button);
     };
 
 
     // Backwards compatability.    
     IPython.NotebookList = NotebookList;
 
     return {'NotebookList': NotebookList};
 });