#251 Add option of creating project.

Place holder for loading nodes.

src/addon/AddOnBase.js

@@ -1,13 +1,14 @@
-/*
- * Copyright (C) 2014 Vanderbilt University, All rights reserved.
- *
- * Author: Tamas Kecskes
+/*globals define*/
+/*jshint node:true*/
+
+/**
+ * @author kecso / https://github.com/kecso
  */
 
-'use strict';
 
 define([],
     function(){
+        'use strict';
         var AddOnBase = function(Core,Storage, gmeConfig){
             this._Core = Core;
             this._Storage = Storage; //TODO: Should Storage be lower-case? It seems to be an instance..

src/common/util/opencontext.js

@@ -12,6 +12,8 @@ define(['util/assert', 'common/core/core'], function (ASSERT, Core) {
      * @param {object} gmeConfig - global webgme configuration
      * @param {object} parameters
      * @param {string} [parameters.projectName] - name of project to open -> result.project
+     * @param {boolean} [parameters.createProject] - if not found will create a project -> result.project
+     * @param {boolean} [parameters.overwriteProject] - if found will overwrite the existing project -> result.project
      * @param {string} [parameters.branchName] - name of branch to load root from. -> result.rootNode, result.commitHash
      * @param {string} [parameters.commitHash] - if branchName not given commitHash will be loaded. -> result.rootNode
      * @param {string} [parameters.nodeIds] - //TODO: will load all specified node ids. -> result.nodes
@@ -47,36 +49,50 @@ define(['util/assert', 'common/core/core'], function (ASSERT, Core) {
             }
             if (parameters.projectName) {
                 storage.getProjectNames(function (err, projectNames) {
+                    var projectExists = projectNames.indexOf(parameters.projectName) > -1;
                     if (err) {
                         closeOnError(err);
                         return;
                     }
-                    if (projectNames.indexOf(parameters.projectName) === -1) {
+                    if (!projectExists && !parameters.createProject && !parameters.overwriteProject) {
                         closeOnError('"' + parameters.projectName + '" does not exists among: ' +
-                        projectNames.toString());
+                        projectNames.toString() + '. Set flag "createProject" to create a new project.');
+                        return;
+                    } else if (projectExists && parameters.createProject && !parameters.overwriteProject) {
+                        closeOnError('"' + parameters.projectName + '" already exists: ' +
+                        projectNames.toString() + '. Set flag "overwriteProject" to overwrite project.');
                         return;
                     }
+
                     storage.openProject(parameters.projectName, function (err, project) {
                         if (err) {
                             closeOnError(err);
                             return;
                         }
                         result.project = project;
+
                         if (parameters.branchName || parameters.commitHash) {
-                            _getCommitHash(result.project, gmeConfig, parameters, function (err, commitHash) {
+                            _getCommitHash(parameters, result, function (err) {
                                 if (err) {
                                     closeOnError(err);
                                     return;
                                 }
-                                result.commitHash = commitHash;
-                                _loadRoot(project, gmeConfig, commitHash, parameters, function (err, rootNode, core) {
+                                _loadCommitHash(parameters, result, gmeConfig, function (err) {
                                     if (err) {
                                         closeOnError(err);
                                         return;
                                     }
-                                    result.rootNode = rootNode;
-                                    result.core = core;
-                                    callback(null, result);
+
+                                    if (parameters.nodeIds || parameters.meta) {
+                                        _loadNodes(parameters, result, function (err) {
+                                            if (err) {
+                                                closeOnError(err);
+                                                return;
+                                            }
+                                        });
+                                    } else {
+                                        callback(null, result);
+                                    }
                                 });
                             });
                         } else {
@@ -90,40 +106,48 @@ define(['util/assert', 'common/core/core'], function (ASSERT, Core) {
         });
     };
 
-    function _getCommitHash(project, gmeConfig, parameters, callback) {
+    function _getCommitHash(parameters, result, callback) {
         if (parameters.branchName) {
-            project.getBranchNames(function (err, names) {
+            result.project.getBranchNames(function (err, names) {
                 if (err) {
                     callback(err);
                 } else if (names.hasOwnProperty(parameters.branchName) === false) {
                     callback('"' + parameters.branchName + '" not in project: "' +
                     parameters.projectName + '".');
                 } else {
-                    callback(null, names[parameters.branchName]);
+                    result.commitHash = names[parameters.branchName];
+                    callback(null);
                 }
             });
         } else {
-            callback(null, parameters.commitHash);
+            result.commitHash = parameters.commitHash;
+            callback(null);
         }
     }
 
-    function _loadRoot(project, gmeConfig, commitHash, parameters, callback) {
+    function _loadCommitHash(parameters, result, gmeConfig, callback) {
         var core;
-        project.loadObject(commitHash, function (err, commitObj) {
+        result.project.loadObject(result.commitHash, function (err, commitObj) {
             if (err) {
                 callback(err);
                 return;
             }
-            core = parameters.core || new Core(project, {globConf: gmeConfig});
+            core = parameters.core || new Core(result.project, {globConf: gmeConfig});
             core.loadRoot(commitObj.root, function (err, rootNode) {
                 if (err) {
                     callback(err);
                     return;
                 }
-                callback(null, rootNode, core);
+                result.rootNode = rootNode;
+                result.core = core;
+                callback(null);
             });
         });
     }
 
+    function _loadNodes(parameters, result, callback) {
+        callback('Not implemented!');
+    }
+
     return openContext;
 });

test/addon/AddOnBase.spec.js

@@ -0,0 +1,11 @@
+/*jshint node:true, mocha:true*/
+/**
+ * @author pmeijer / https://github.com/pmeijer
+ */
+
+var testFixture = require('../_globals');
+
+describe('AddOnBase', function () {
+    'use strict';
+
+});

test/addon/core/TestAddOn.spec.js

@@ -0,0 +1,84 @@
+/*jshint node:true, mocha:true*/
+/**
+ * @author pmeijer / https://github.com/pmeijer
+ */
+
+var testFixture = require('../../_globals');
+
+describe('TestAddOn', function () {
+    'use strict';
+
+    var expect = testFixture.expect,
+        WebGME = testFixture.WebGME,
+        Core = testFixture.WebGME.core,
+        addOnName = 'TestAddOn',
+        TestAddOn = testFixture.requirejs('addon/' + addOnName + '/' + addOnName + '/' + addOnName);
+
+    var getConnectedStorage = function (webGMESessionId, gmeConfig, callback) {
+        var connStorage = new WebGME.clientStorage({
+            globConf: gmeConfig,
+            type: 'node',
+            host: (gmeConfig.server.https.enable === true ? 'https' : 'http') + '://127.0.0.1',
+            webGMESessionId: webGMESessionId
+        });
+        connStorage.openDatabase(function (err) {
+            callback(err, connStorage);
+        });
+    };
+
+    var getConnectedProject = function (storage, projectName, callback) {
+        storage.getProjectNames(function (err, names) {
+            if (err) {
+                return callback(err);
+            }
+            console.log('names', names);
+            if (names.indexOf(projectName) === -1) {
+                return callback(new Error('nonexsistent project'));
+            }
+            storage.openProject(projectName, callback);
+        });
+    };
+
+    it('should start', function (done) {
+        var gmeConfig = testFixture.getGmeConfig(),
+            server,
+            importParam = {
+                filePath: './test/asset/sm_basic.json',
+                projectName: 'testAddOn',
+                branchName: 'master',
+                gmeConfig: gmeConfig,
+                storage: null
+            };
+        gmeConfig.server.port = 9001;
+        server = WebGME.standaloneServer(gmeConfig);
+        server.start(function () {
+            getConnectedStorage('sessionId', gmeConfig, function (err, storage) {
+                console.log('getConnectedStorage');
+                expect(err).equal(null);
+                importParam.storage = storage;
+                testFixture.importProject(importParam, function (err, result) {
+                    expect(err).equal(null);
+                    console.log('importProject');
+                    getConnectedProject(storage, importParam.projectName, function (err, project) {
+                        console.log('getConnectedProject');
+                        var startParam,
+                            addon;
+                        addon = new TestAddOn(Core, storage, gmeConfig);
+                        expect(err).equal(null);
+                        startParam = {
+                            projectName: importParam.projectName,
+                            branchName: importParam.branchName,
+                            project: project
+                        };
+                        addon.start(startParam, function (err) {
+                            expect(err).equal(null);
+                            done();
+                        });
+                    });
+
+                });
+
+            });
+        });
+    });
+});

test/common/util/opencontext.spec.js

@@ -67,7 +67,20 @@ describe('openContext', function () {
                 projectName: 'doesNotExist'
             };
             openContext(storage, gmeConfig, parameters, function (err, result) {
-                expect(err).to.equal('"doesNotExist" does not exists among: doesExist');
+                expect(err).to.equal('"doesNotExist" does not exists among: doesExist. ' +
+                    'Set flag "createProject" to create a new project.');
+                done();
+            });
+        });
+
+        it('should open non-existing project with flag createProject=true', function (done) {
+            var parameters = {
+                projectName: 'doesNotExist',
+                createProject: true
+            };
+            openContext(storage, gmeConfig, parameters, function (err, result) {
+                expect(err).equal(null);
+                expect(result).to.have.keys('project');
                 done();
             });
         });