@aj-shadow/actorjs-app 0.0.0-aj-beta.221

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorFileRename.js

@@ -0,0 +1,27 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Fs = require('fs');
+
+
+class StackEditorFileRename extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(oldPath, newPath) {
+    Fs.access(ActorPathData.getStackFile(newPath), Fs.constants.F_OK, (err) => {
+      if(err && 'ENOENT' === err.code) {
+        this.asynchRenameResponse(ActorPathData.getStackFile(oldPath), ActorPathData.getStackFile(newPath));
+      }
+      else {
+        this.expectAsynchResponseError(`Path '${newPath}' does already exist.`);
+      }
+    });
+  }
+}
+
+
+module.exports = StackEditorFileRename;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorFileUpdate.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class StackEditorFileUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.Update);
+  }
+  
+  onRequest(file, data) {
+    this.asynchWriteTextFileResponse(ActorPathData.getStackFile(file), data);
+  }
+}
+
+module.exports = StackEditorFileUpdate;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorFolderDelete.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const ActorPathDist = require('z-abs-corelayer-server/server/path/actor-path-dist');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class StackEditorFolderDelete extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.DELETE);
+  }
+  
+  onRequest(file) {
+    this.asynchRmdirResponse(ActorPathData.getStackFile(file), true, true);
+    this.asynchRmdirResponse(ActorPathDist.getActorFile(file), true, true);
+  }
+}
+
+
+module.exports = StackEditorFolderDelete;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorFolderNew.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class StackEditorFolderNew extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+  }
+  
+  onRequest(file) {
+    this.asynchMkdirResponse(ActorPathData.getStackFile(file));
+  }
+}
+
+
+module.exports = StackEditorFolderNew;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorFolderUpdate.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class StackEditorFolderUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+  }
+  
+  onRequest(oldPath, newPath) {
+    this.asynchRenameResponse(ActorPathData.getStackFile(oldPath), ActorPathData.getStackFile(newPath));
+  }
+}
+
+
+module.exports = StackEditorFolderUpdate;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorProjectGet.js

@@ -0,0 +1,77 @@
+
+'use strict';
+
+const Project = require('z-abs-corelayer-cs/clientServer/project');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class StackEditorProjectGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    let pendings = 2;
+    let fLocal = null;
+    let fGlobal = null;
+    this._getProject(ActorPathData.getStacksLocalProjectPureFile(), ActorPathGenerated.getStacksProjectFile('./Stacks-local'), (f) => {
+      fLocal = f;
+      if(0 === --pendings) {
+        fLocal();
+        fGlobal();
+      }
+    });
+    this._getProject(ActorPathData.getStacksGlobalProjectPureFile(), ActorPathGenerated.getStacksProjectFile('./Stacks-global'), (f) => {
+      fGlobal = f;
+      if(0 === --pendings) {
+        fLocal();
+        fGlobal();
+      }
+    });
+    /*this.asynchReadFileResponse(ActorPathData.getStacksGlobalProject(), (err, object) => {
+      const project = new Project(object);
+      this.asynchWriteTextFile(ActorPathData.getStacksGlobalProjectPureFile(), project.exportPure());
+    });
+    this.asynchReadFileResponse(ActorPathData.getStacksLocalProject(), (err, object) => {
+      const project = new Project(object);
+      this.asynchWriteTextFile(ActorPathData.getStacksLocalProjectPureFile(), project.exportPure());
+    });*/
+  }
+  
+  _getProject(pureFile, jsonFile, done) {
+    let pendings = 2;
+    let pureProject = null;
+    let jsonProject = null;
+    this.asynchReadTextFile(pureFile, (err, pureP) => {
+      if(!err) {
+        pureProject = pureP;
+      }
+      if(0 === --pendings) {
+        done(() => {
+          this._handle(pureProject, jsonProject, jsonFile);
+        });
+      }
+    });
+    this.asynchReadFile(jsonFile, (err, jsonP) => {
+      if(!err) {
+        jsonProject = jsonP;
+      }
+      if(0 === --pendings) {
+        done(() => {
+          this._handle(pureProject, jsonProject, jsonFile);
+        });
+      }
+    });
+  }
+  
+  _handle(pureProject, jsonProject, jsonFile) {
+    const project = new Project();
+    project.importPure(pureProject, jsonProject);
+    this.asynchWriteFileResponse(jsonFile, project.source, true);
+  }
+}
+
+
+module.exports = StackEditorProjectGet;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorProjectToggle.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class StackEditorProjectToggle extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(content, path) {
+    this.asynchWriteFileResponse(ActorPathGenerated.getStacksProjectFile(path), content, false);
+  }
+}
+
+module.exports = StackEditorProjectToggle;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorProjectUpdate.js

@@ -0,0 +1,22 @@
+
+'use strict';
+
+const Project = require('z-abs-corelayer-cs/clientServer/project');
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class StackEditorProjectUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(path, content) {
+    const project = new Project(content);
+    this.asynchWriteTextFile(ActorPathData.getStacksProjectPureFile(path), project.exportPure(), false);
+    this.asynchWriteFileResponse(ActorPathGenerated.getStacksProjectFile(path), content, false);
+  }
+}
+
+module.exports = StackEditorProjectUpdate;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorWizard.js

@@ -0,0 +1,43 @@
+
+'use strict';
+
+const Template = require('./helpers/template');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class StackEditorWizard extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+    this.template = new Template();
+  }
+  
+  onRequest(path, name, types, templateDatas, transportName) {
+    const stackFolderName = this.template.getPath(path, name)
+    Fs.lstat(stackFolderName, (err, stat) => {
+      if(!err || err.code !== 'ENOENT') {
+        const log = `Do stack folder '${stackFolderName}' already exist?`;
+        return this.asynchResponseError(log);
+      }
+      else {
+        Fs.mkdir(stackFolderName, (err) => {
+          if(err) {
+            const log = `Could not create stack folder '${stackFolderName}'.`;
+            return this.asynchResponseError(log);
+          }
+          this.expectAsynchResponseTemp();
+          templateDatas.forEach((templateData, index) => {
+            this.template.createFile(`${path}${Path.sep}${name}`, name, types[index], templateData.name, transportName, (file, text, fileName) => {
+              this.asynchWriteTextFileResponse(file, text, fileName);
+            });
+          });
+          this.unExpectAsynchResponseTemp();
+        });
+      }
+    });
+  }
+}
+
+
+module.exports = StackEditorWizard;

package/project/server/plugin-data/system-under-test/plugin_data_SystemUnderTestAdd.js

@@ -0,0 +1,72 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Fs = require('fs');
+
+
+class SystemUnderTestAdd extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+    this.parsedData = {};
+  }
+  
+  onRequest(repoName, sutName, description) {
+    this.addSystemUnderTest(repoName, sutName, description);
+  }
+  
+  addSystemUnderTest(repoName, sutName, description) {
+    const systemUnderTest = {
+      name: sutName,
+      description: description,
+      status: 'visible'
+    }
+    const responsePart = this.verifyInput(systemUnderTest);
+    if(true !== responsePart) {
+      return responsePart;
+    }
+    Fs.mkdir(ActorPathData.getSystemUnderTestFolder(repoName, sutName), (err) => {
+      if(err) {
+        return this.responsePartError(`Could not create the System Under Test: ' ${ActorPathData.getSystemUnderTestFolder(repoName, sutName)} '.`);
+      }
+      Fs.writeFile(ActorPathData.getSystemUnderTestFile(repoName, sutName), JSON.stringify(systemUnderTest, null, 2), (err) => {
+        if(err) {
+          return this.responsePartError(`Could not create the System Under Test File: ' ${ActorPathData.getSystemUnderTestFile(repoName, sutName)} '.`);
+        }
+      });
+    });
+    return this.responsePartSuccess();
+  }
+  
+  verifyInput(systemUnderTest) {
+    const name = systemUnderTest.name;
+    if(0 === name.length) {
+      return this.responsePartError(`The System Under Test name: '' must not be empty.`);
+    }
+    if('Actor' === name) {
+      return this.responsePartError(`The System Under Test name: '${name}' is reserved.`);
+    }
+    let first = name.charAt(0);
+    if(first === first.toLowerCase() || first !== first.toUpperCase()) {
+      return this.responsePartError(`A System Under Test name must start with uppercase, name: '${name}'.`);
+    }
+    return true;
+  }
+  
+  failureResponse(systemUnderTest, msg) {
+    const status = {
+      name: {
+        text: systemUnderTest.name,
+	      status: false
+      },
+      description: {
+        text: systemUnderTest.description,
+        status: true
+      }
+    }
+    return this.responsePartError(status);
+  }
+}
+
+module.exports = SystemUnderTestAdd;

package/project/server/plugin-data/system-under-test/plugin_data_SystemUnderTestDelete.js

@@ -0,0 +1,20 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class SystemUnderTestDelete extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.DELETE);
+  }
+  
+  onRequest(suts) {
+    suts.forEach((sut) => {
+      this.asynchRmdirResponse(ActorPathData.getSystemUnderTestFolder(sut.repo, sut.name), true);
+    });
+  }
+}
+
+module.exports = SystemUnderTestDelete;

package/project/server/plugin-data/system-under-test/plugin_data_SystemUnderTestGet.js

@@ -0,0 +1,138 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class SystemUnderTestGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.getRepos(ActorPathData.getReposLocalFolder(), (repos, err) => {
+      if(err) {
+        return this.responsePartError('Could not get the repos.');
+      }
+      if(ActorPathData.getReposGlobalFolder() !== ActorPathData.getReposLocalFolder()) {
+        repos.push(ActorPathData.getGlobalDataRepoName());
+      }
+      repos.sort();
+      let errorResponse = false;
+      let pendings = 0;
+      let systemUnderTests = [];
+      repos.forEach((repoName) => {
+        ++pendings;
+        this.getSystemUnderTests(ActorPathData.getTestAbstractionFolder(repoName), repoName, (data, err) => {
+          if(!errorResponse) {
+            if(err) {
+              errorResponse = true;
+              return this.responsePartError(`Could not get the Systems Under Test in the repo: '${repoName}'.`);
+            }
+            systemUnderTests = systemUnderTests.concat(data);
+            systemUnderTests.forEach((systemUnderTest) => {
+              if(!systemUnderTest.instances) {
+                systemUnderTest.instances = [];
+              }
+              if(!systemUnderTest.nodes) {
+                systemUnderTest.nodes = [];
+              }
+            });
+            if(0 === --pendings && !errorResponse) {
+               systemUnderTests.sort((a, b) => {
+                if(a.name < b.name) {
+                  return -1;
+                }
+                else if(b.name < a.name) {
+                  return 1;
+                }
+                else {
+                  return 0;
+                }
+              });
+              return this.responsePartSuccess({
+                systemUnderTests: systemUnderTests
+              });
+            }
+          }
+        });
+      });
+    });
+  }
+    
+  getRepos(dir, done) {
+    const repos = [];
+    Fs.readdir(dir, (err, files) => {
+      if(err) {
+        return done(repos, err);
+      }
+      let pendings = files.length;
+      if(0 === pendings) {
+        return done(repos);
+      }
+      for(let i = 0; i < files.length; ++i) {
+        const file = files[i];
+        const resolvedDir = Path.resolve(dir, file);      
+        Fs.stat(resolvedDir, (err, stat) => {
+          if(err) {
+            return done(repos, err);
+          }
+          if(stat && stat.isDirectory()) {
+            repos.push(file);
+          }
+          if(0 === --pendings) {
+            return done(repos);
+          }
+        });
+      }
+    });
+  }
+  
+  getSystemUnderTests(dir, repoName, done) {
+    const systemUnderTests = [];
+    Fs.readdir(dir, (err, files) => {
+      if(err) {
+        return done(systemUnderTests, err);
+      }
+      let pendings = files.length;
+      if(0 === pendings) {
+        return done(systemUnderTests);
+      }
+      for(let i = 0; i < files.length; ++i) {
+        const file = files[i];
+        const resolvedDir = Path.resolve(dir, file);      
+        Fs.stat(resolvedDir, (err, stat) => {
+          if(err) {
+            return done(systemUnderTests, err);
+          }
+          if(stat && stat.isDirectory()) {
+            if(file.startsWith('Sut') && file.length > 'Sut'.length) {
+              Fs.readFile(ActorPathData.getSystemUnderTestFile(repoName, file.substr('Sut'.length)), (err, data) => {
+                if(err) {
+                  return done(systemUnderTests, err);
+                }	  
+                const ts = JSON.parse(data);
+                ts.repo = repoName;
+                systemUnderTests.push(ts);
+                if(0 === --pendings) {
+                  return done(systemUnderTests);
+                }
+              });
+            }
+            else if(0 === --pendings) {
+              return done(systemUnderTests);
+            }
+          }
+          else if(0 === --pendings) {
+            return done(systemUnderTests);
+          }
+        });
+      }
+    });
+  }
+}
+
+module.exports = SystemUnderTestGet;

package/project/server/plugin-data/system-under-test/plugin_data_SystemUnderTestInstancesUpdate.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class SystemUnderTestInstancesUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(sut, instances) {
+    if(undefined !== instances) {
+      sut.instances = instances;
+    }
+    this.asynchWriteFileResponse(ActorPathData.getSystemUnderTestFile(sut.repo, sut.name), sut, true);
+  }
+}
+
+module.exports = SystemUnderTestInstancesUpdate;

package/project/server/plugin-data/system-under-test/plugin_data_SystemUnderTestNodesUpdate.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class SystemUnderTestNodesUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(sut, nodes) {
+    if(undefined !== nodes) {
+      sut.nodes = nodes;
+    }
+    this.asynchWriteFileResponse(ActorPathData.getSystemUnderTestFile(sut.repo, sut.name), sut, true);
+  }
+}
+
+module.exports = SystemUnderTestNodesUpdate;

package/project/server/plugin-data/system-under-test/plugin_data_SystemUnderTestRepoAdd.js

@@ -0,0 +1,46 @@
+
+'use strict';
+
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const Fs = require('fs');
+
+
+class SystemUnderTestRepoAdd extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(repoName) {
+    const responsePart = this.verifyInput(repoName);
+    if(true !== responsePart) {
+      return responsePart;
+    }
+    Fs.mkdir(ActorPathData.getReposRepoFolder(repoName), (err) => {
+      if(err) {
+        return this.responsePartError(`Could not create the Repo Folder: ' ${ActorPathData.getReposRepoFolder(repoName)} '.`);
+      }
+      Fs.mkdir(ActorPathData.getTestAbstractionFolder(repoName), (err) => {
+        if(err) {
+          return this.responsePartError(`Could not create the Repo TestAbstraction Folder: ' ${ActorPathData.getTestAbstractionFolder(repoName)} '.`);
+        }
+        return this.responsePartSuccess();
+      });
+    });      
+  }
+  
+  verifyInput(repoName) {
+    if(0 === repoName.length) {
+      return this.responsePartError(`The Repo name: '' must not be empty.`);
+    }
+    if('actorjs-data-global' === repoName) {
+       return this.responsePartError(`A Repo name must not be 'actorjs-data-global'. It is already used by ActorJs.`);
+    }
+    if('actorjs-data-local' === repoName) {
+       return this.responsePartError(`A Repo name must not be 'actorjs-data-local'. It is already used by by ActorJs.`);
+    }
+    return true;
+  }
+}
+
+module.exports = SystemUnderTestRepoAdd;

package/project/server/plugin-data/system-under-test/plugin_data_SystemUnderTestRepoGet.js

@@ -0,0 +1,57 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class SystemUnderTestRepoGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.getRepos(ActorPathData.getReposLocalFolder(), (repos, err) => {
+      if(err) {
+        return this.responsePartError('Could not get the System Under Test Repos.');
+      }
+      if(ActorPathData.getReposGlobalFolder() !== ActorPathData.getReposLocalFolder()) {
+        repos.push(ActorPathData.getGlobalDataRepoName());
+      }
+      repos.sort();
+      return this.responsePartSuccess(repos);
+    });
+  }
+  
+  getRepos(dir, done) {
+    const repos = [];
+    Fs.readdir(dir, (err, files) => {
+      if(err) {
+        return done(repos, err);
+      }
+      let pendings = files.length;
+      if(0 === pendings) {
+        return done(repos);
+      }
+      for(let i = 0; i < files.length; ++i) {
+        const file = files[i];
+        const resolvedDir = Path.resolve(dir, file);      
+        Fs.stat(resolvedDir, (err, stat) => {
+          if(err) {
+            return done(repos, err);
+          }
+          if(stat && stat.isDirectory()) {
+            repos.push(file);
+          }
+          if(0 === --pendings) {
+            return done(repos);
+          }
+        });
+      }
+    });
+  }
+}
+
+module.exports = SystemUnderTestRepoGet;

package/project/server/plugin-data/system-under-test/plugin_data_SystemUnderTestSpecificationUpdate.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class SystemUnderTestSpecificationUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(sut, specification) {
+    if(undefined !== specification) {
+      sut.specification = specification;
+    }
+    this.asynchWriteFileResponse(ActorPathData.getSystemUnderTestFile(sut.repo, sut.name), sut, true);
+  }
+}
+
+module.exports = SystemUnderTestSpecificationUpdate;