Clean start

models/Node.js

@@ -0,0 +1,220 @@
+var db = require('../lib/db');
+
+var NodeSchema = new db.Schema({
+    text: {type: String}, 
+    children: {type: Array}, 
+    parents: {type: Array}
+})
+
+var SnapSchema = new db.Schema({
+    text: {type: String}, 
+    children: {type: Array}, 
+    parents: {type: Array}, 
+    timestamp: {type: Number}, 
+    cur_id: {type: String}
+});
+
+
+
+var rootID;
+
+var MySnap = db.mongoose.model('snaps', SnapSchema);
+var MyNode = db.mongoose.model('nodes', NodeSchema);
+
+// Exports
+module.exports.addNode = addNode;
+module.exports.findNodes = findNodes;
+module.exports.updateParent = updateParent;
+module.exports.updateText = updateText;
+module.exports.setUpDB = setUpDB;
+module.exports.removeNode = removeNode;
+module.exports.moveNode = moveNode;
+module.exports.rootNodeId = rootNodeId;
+module.exports.MySnap = MySnap; 
+
+function rootNodeId(){
+  return rootID;
+}
+
+function moveNode(ids, arrays){
+  var thisId = ids[0]; //draggedId
+  var now = Date.now();
+  MyNode.findById(thisId, null, function(err, node){
+    addSnap(node, now);
+    node.parents = arrays[0];
+    node.save();
+  });
+  var oldParId = ids[1];
+  MyNode.findById(oldParId, null, function(err, node){
+    addSnap(node, now);
+    node.children = arrays[1];
+    node.save();
+  });
+  var newParId = ids[2];
+  MyNode.findById(newParId, null, function(err, node){
+    addSnap(node, now);
+    node.children = arrays[2];
+    node.save();
+  });
+}
+
+function addSnap(node, now, callback){
+  var instance = new MySnap();
+  instance.text = node.text;
+  instance.children = node.children;
+  instance.parents = node.parents;
+  instance.cur_id = node._id;
+  instance.timestamp = now;
+  instance.save(function(err){
+    if(err){
+      //callback(err);
+    }
+    else{
+      //callback(null, instance);
+    }
+  });
+  
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+//this is technically not good asynchronous code. 
+//this coulde be made into a recursive function which takes an array of todo-strings. 
+function addListOfNodes(){
+  addNode("0root", [], [], function(err, rootNode){
+    rootID = rootNodeId._id;
+    var parId = rootNode._id;
+    addNode("Todos", [], [parId], function(err, vadar){ //called vadar because it is the parent/father
+      var vadarId = vadar._id;
+      var childArray = []; 
+      addNode("Revision Control", [], [vadarId], function(err, child){
+        childArray.push(child._id); 
+      }); 
+      addNode("LatexEditor", [], [vadarId], function(err, child){
+        childArray.push(child._id); 
+      }); 
+      addNode("Lots of other stuff", [], [vadarId], function(err, child){
+        childArray.push(child._id); 
+        vadar.children = childArray; 
+        vadar.save(); 
+      }); 
+      rootNode.children = [vadarId];
+      rootNode.save();
+    }); 
+  });
+}
+
+
+function setUpDB(){
+  MyNode.remove({}, function(err) { console.log('collection removed') });
+  MySnap.remove({}, function(err) { console.log('collection removed') });
+  addListOfNodes(); 
+}
+
+function removeNode(thisId, thisIndex, parId){
+  var now = Date.now();
+  MyNode.findById(parId, null, function(err, parNode){
+    if(err || parNode == null){
+      return;
+    }
+    addSnap(parNode, now);
+    var temp = parNode.children;
+    console.log(temp.splice(thisIndex, 1));
+    console.log(temp);
+    parNode.children = temp;
+
+    parNode.save();
+  });
+  MyNode.findById(thisId, null, function(err, delNode){
+    if(err || delNode == null){
+      return;
+    }
+    addSnap(delNode, now);
+    if(delNode.parents.length ==1 ){
+      delNode.remove();
+    }
+    else{ //this is the condition that we'll have to take care of if there are dups. 
+      delNode.parents = _.without(parents, parId);
+      delNode.save();
+    }
+  })
+}
+
+function updateText(id, newText){
+  console.log("\nUPDATE TEXT\n" + id + newText);
+  var now = Date.now();
+  MyNode.findById(id, null, function(err, node){
+    if(err || node == null){
+      return;
+    }
+    addSnap(node, now);
+    node.text = newText;
+    node.save();
+  });
+}
+
+function updateParent(parId, newId ,newIndex, now){
+  MyNode.findById(parId, null, function(err, parNode){
+    if(err || parNode == null){
+      return;
+    }
+    addSnap(parNode, now);
+    parNode.children.insert(newIndex, newId);
+    parNode.save();
+  })
+}
+
+//add Node to the DB. 
+function addNode(text, children, parents, callback){
+  var now = Date.now();
+  var instance = new MyNode();
+  instance.text = text; 
+  instance.children = children;
+  instance.parents = parents;
+  addSnap(instance, now);
+
+  instance.save(function (err) { 
+    if (err) {
+      callback(err);
+    }
+  else {
+      callback(null, instance, now);
+    }
+  }); 
+}
+
+
+function findNodes(socket){
+  var nodes = {'keeping': 'calm'}
+  MyNode.find(function(err, nodes){
+    if(!err){
+      socket.emit('nodeData', nodes)
+      return {'hell': 'yes'}
+    }else{
+      socket.emit('nodeData', "error!!!")
+     return {'hell': 'no'}
+    }
+
+    
+  }); 
+}
+
+Array.prototype.insert = function (index, item) {
+  this.splice(index, 0, item);
+};
+
+Array.prototype.remove = function(from, to) {
+  var rest = this.slice((to || from) + 1 || this.length);
+  this.length = from < 0 ? this.length + from : from;
+  return this.push.apply(this, rest);
+};