forforf / bufsui Goto Github PK

Fix the create node function so that the ajax to the server returns the new node the json for just the new node and its parent (node is added to root if the parent doesn't exist as a node).
The current approach is to return json data for the complete set of data (not scalable to large data).

Note, it may be sufficient to just provide the parent's node id used in the visualization and not the entire node data set, but this needs testing.

The backend is correct, but the old data is presented.
Potential Issues: Caching, AJAX timing, other?

The DB and file system locations should be set in a single location, and not screw up test cases. This may require refactoring. Also, will need some tests for this.

Update the flow between the server and the client to be more restful (i.e. no html, just json), let the client render things dynamically, rather than sending html via ajax.

Need to add delete tests to specs and fix delete (probably in the datastructure somewhere).

Integrate Dropbox so that files on the server can be synced with Dropbox

Now that borged is working it should be added to the web view too.
Important Note, the borg functionality needs to be refactored out of the file making and made generic so that file views and db views (web) can access it DRYly

In some cases it is
{ link => link_label }
in other cases
{ link => [ array of link labels ]}

Don't need arrays for initial version, but this is probably baked into the Model Independent Data structure.

Creating a new node on a new db required a manual refresh in order for it to be displayed.

Need to create spec tests for the rails app.

Right now I just check to see if parent categories are nil before adding a node to root, I need to check to see if none of the parent cats map to nodes, and if they don't then add the root category to the node.

A point and click user interface that allows for the easy modification of relationships, as well as providing data about relationships (most linked heat map for example).

Right now its mostly living in the model. Probably Ok, but think it through

Provide a capability to attach a file via a URL (rather than file upload). Overlaps somewhat with the linking capability but allows for the transfer of control of content.

Determine whether to insert authenticity token via partial (or other server initiated method into the served web page), ajax query, or to exempt certain post methods (most notably the iframe updater)

An interface is needed so that the user can arbitrarily select which models the data should be synced against.

Currently attachments are downloaded by reading the data from CouchDB and then rails downloading the data as raw data to the browser (which will store as a file). A much better approach would be for rails to proxy the request to CouchDB (for security reasons CouchDB is not externally accessible), and proxy the response (the data) back to the browser.

No label to click on so the node can't be accessed to delete

The fix is to explicitly set the arrow direction in the graph data. Best place is most likely in javascript since it's specific to the view.

Need a holistic method for dealing with orphaned (i.e., disconnected) nodes/trees. I'm not sure why these don't get reattached to root upon re-initialization, but that's not a great solution either.
Current thought: The UI has a list of graphs when there are graphs that become orphaned from the user root. Choosing that graph brings it up in its own window under user root. Then there could be operations to combine it to the main graph. This would be in a future release.

For friendly testing, just provide a user id.

As an example, loading files into the vis.

Leverage the default RESTful routing in Rails (assuming it makes sense, but it should work)

See http://guides.rubyonrails.org/routing.html

Currently the links are hard-coded when the url is dynamically created. A better approach would be to create the link, but have the url determined when the link is clicked.

There really is no animation, I'm just reloading the new data. Morph doesn't seem to work (duplicate node ids?, mis-matched root ids?).

One idea would be to use mod_rewrite to prevent a user from being able to browse other users directories. The current UI prevents this, but a user could put another user's path in the url to ge to their directory. Perhaps a public key exchange via a custom HTTP header?. Or maybe some form of http auth?

Add dot file into the file view to support arbitrary node data (i.e., description)

The database is correct, but when deleting a link, moving to another node, then moving back to the original node, the link reappears. There is no communication with the server so the data is persisting in the DOM or the visualization somewhere.

Add the ability to import from a file view structure, creating both a file mode and a doc model

Update the sign on functions to be secure ... or at least protected from viewing by others

Need to verify it's not needed and if it's not being used, it needs to be deleted

However, need to ensure that Dropbox exports the files appropriately first.

Currently, the update mechanism and the query mechanism to the underlying model (CouchDB) are asynchronous. This results in stale data if a query occurs too quickly after an update. I'm thinking a call back after the update occurs is what is needed.

The .model directory is not in sync with the CouchDB model when file export is used.

Organize the interface for deleting attachments. Align the delete buttons (maybe change to something different than a checkbox?), and add a Delete All Attachments option.

On the sign-in screen, sometimes attempts at creating a new db will fail inexplicably. Needs investigation.

The html, javascript, css, controllers, views, and model are inconsistent and very unclean. Some model functions are in the controllers, controllers need to be renamed for better mapping to RESTful behavior, orphaned code abounds, etc

Using an @ in the user name causes a 500 error. Needs more investigation.

my_category is assumed to be a unique key in and of itself, but it's quite likely that is may be duplicated, and it's uniqueness established by its relationships.
Needs (serious) investigation as this uniq key relationship permeates throughout

Clicking on the attachment should result in the attachment being downloaded to the user

Currently a session is tied to a user is tied to a single bufs/joha model.
So in essence a user can only have a single bufs/joha model, which is limiting
Fix it so that a user can have multiple (simultaneous) models. Whether this is a user can have multiple sessions, or a session can have multiple models needs to be determined.

Especially important if the node name must be unique

Content should be able to be stored as urls. Think about how this would be rendered in a file system.