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

package/project/server/plugin-data/actor-editor/plugin_data_ActorEditorFileNew.js

@@ -0,0 +1,396 @@
+
+'use strict';
+
+const StackComponentsFactory = require('z-abs-funclayer-stack-server/server/factory/stack-components-factory');
+const StackComponentsHelpers = require('z-abs-funclayer-engine-server/server/stack/factory/stack-components-helpers');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Os = require('os');
+
+
+class ActorEditorFileNew extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+  }
+  
+  onRequest(path, name, type, templateName, dynamicTemplateName, dynamicTemplateName2) {
+    let formatFunction = null;
+    if(!dynamicTemplateName) {
+      formatFunction = ActorEditorFileNew.templates.get(templateName);
+      this._create(path, name, type, templateName, formatFunction);
+    }
+    else {
+      StackComponentsFactory.getStacks((stacks) => {
+        const stackTemplateFactory = StackComponentsFactory.createTemplatesActors(dynamicTemplateName);
+        if(stackTemplateFactory) {
+          const actorsTypes = new stackTemplateFactory().templates;
+          const actorTemplate = actorsTypes.find((actorType) => {
+            return actorType.name === templateName;
+          });
+          if(actorTemplate) {
+            const formatIndex = actorTemplate.templateNames.findIndex((templateName) => {
+              return templateName === dynamicTemplateName2;
+            });
+            if(-1 !== formatIndex) {
+              formatFunction = actorTemplate.templates[formatIndex];
+            }
+            else {
+              ddb.error('NO formatObject');
+              return; //TODO: Error response
+            }
+          }
+          else {
+            ddb.error('NO actorTemplate');
+            return; //TODO: Error response
+          }
+        }
+        this._create(path, name, type, templateName, formatFunction);
+      });
+    }
+  }
+  
+  _create(path, name, type, templateName, formatFunction) {
+    const fileName = this._fileName(path, name, type, templateName);
+    const actorEnding = ActorEditorFileNew.actorEndings.get(templateName);
+    const text = formatFunction({
+      actorEnding: actorEnding,
+      name: this._formatName(name),
+      actorType: templateName,
+      ups: this._getUps(path)
+    });
+    const file = ActorPathData.getActorFile(`${path}/${fileName}`);
+    this.asynchWriteTextFileResponse(file, text, fileName);
+  }
+  
+  _formatNamePart(namePart) {
+    if(0 === namePart.length) {
+      return '';
+    }
+    else if(1 === namePart.length) {
+      return `${namePart[0].toUpperCase()}`;
+    }
+    else {
+      return `${namePart[0].toUpperCase()}${namePart.slice(1)}`;
+    }
+  }
+  
+  _formatName(name) {
+    const nameParts = name.split('-');
+    const newNameParts = nameParts.map((namePart) => {
+      return this._formatNamePart(namePart);
+    });
+    return newNameParts.join('');
+  }
+  
+  _fileName(path, name, type, templateName) {
+    return `${name}${ActorEditorFileNew.actorEndings.get(templateName)}.${type}`;
+  }
+  
+  _getUps(path) {
+    return '../'.repeat(path.split('/').length - 1);
+  }
+}
+
+ActorEditorFileNew.actorEndings = new Map([
+  ['Originating', 'Orig'],
+  ['Terminating', 'Term'],
+  ['Intercepting', 'Inter'],
+  ['Proxy', 'Proxy'],
+  ['Condition', 'Cond'],
+  ['Local', 'Local'],
+  ['Sut', 'Sut'],
+  ['ActorPartPre', 'Pre'],
+  ['ActorPartPost', 'Post'],
+  ['Msg', ''],
+  ['Class [class js file]', ''],
+  ['None [empty js file]', '']
+]);
+
+ActorEditorFileNew.templates = new Map([
+  [
+    'Originating',
+    StackComponentsHelpers._template`
+const ActorApi = require('actor-api');
+
+
+class ${'name'}${'actorEnding'} extends ActorApi.Actor${'actorType'} {
+  constructor() {
+    super();
+    this.connection = null;
+  }
+  
+  *data() {
+  }
+  
+  *initClient() {
+    this.connection = this.createConnection('__stack_name__');
+  }
+  
+  *run() {
+  }
+  
+  *exit(interrupted) {
+    this.closeConnection(this.connection);
+  }
+}
+
+module.exports = ${'name'}${'actorEnding'};
+`
+  ],
+  [
+    'Terminating',
+    StackComponentsHelpers._template`
+const ActorApi = require('actor-api');
+
+
+class ${'name'}${'actorEnding'} extends ActorApi.Actor${'actorType'} {
+  constructor() {
+    super();
+    this.connection = null;
+  }
+  
+  *data() {
+  }
+    
+  *initServer() {
+    this.connection = this.createServer('__stack_name__');
+  }
+  
+  *run() {
+    this.connection.accept();
+  }
+  
+  *exit(interrupted) {
+    this.closeConnection(this.connection);
+  }
+}
+
+module.exports = ${'name'}${'actorEnding'};
+`
+  ],
+  [
+    'Intercepting',
+    StackComponentsHelpers._template`
+const ActorApi = require('actor-api');
+const __MessageSelector_object__ = require('__path_to_ MessageSelector_object__');
+
+
+class ${'name'}${'actorEnding'} extends ActorApi.Actor${'actorType'} {
+  constructor() {
+    super();
+    this.connection = null;
+  }
+  
+  *data() {
+  }
+    
+  *initServer() {
+    this.connection = this.createServer('__stack_name__', {
+      messageSelector: new __MessageSelector_object__(__message_selector_parameters__)
+    });
+  }
+  
+  *run() {
+    this.connection.accept();
+  }
+  
+  *exit(interrupted) {
+    this.closeConnection(this.connection);
+  }
+}
+
+module.exports = ${'name'}${'actorEnding'};
+`
+  ],
+  [
+    'Proxy',
+    StackComponentsHelpers._template`
+const ActorApi = require('actor-api');
+
+
+class ${'name'}${'actorEnding'} extends ActorApi.Actor${'actorType'} {
+  constructor() {
+    super();
+    this.clientConnection = null;
+    this.serverConnection = null;
+  }
+  
+  *data() {
+  }
+  
+  *initServer() {
+    this.serverConnection = this.createServer('__stack_name__');
+  }
+  
+  *initClient() {
+    this.clientConnection = this.createConnection('__stack_name__');
+  }
+  
+  *run() {
+    this.serverConnection.accept();
+  }
+  
+  *exit(interrupted) {
+    this.closeConnection(this.serverConnection);
+    this.closeConnection(this.clientConnection);
+  }
+}
+
+module.exports = ${'name'}${'actorEnding'};
+`
+  ],
+  [
+    'Condition',
+    StackComponentsHelpers._template`
+const ActorApi = require('actor-api');
+
+
+class ${'name'}${'actorEnding'} extends ActorApi.Actor${'actorType'} {
+  constructor() {
+    super();
+  }
+  
+  *data() {
+  }
+  
+  *initClientPre() {
+  }
+  
+  *runPre() {
+  }
+  
+  *exitPre() {
+  }
+  
+  *initClientPost() {
+  }
+  
+  *runPost() {
+  }
+  
+  *exitPost() {
+  }
+}
+
+module.exports = ${'name'}${'actorEnding'};
+`
+  ],
+  [
+    'Local',
+    StackComponentsHelpers._template`
+const ActorApi = require('actor-api');
+
+
+class ${'name'}${'actorEnding'} extends ActorApi.Actor${'actorType'} {
+  constructor() {
+    super();
+  }
+  
+  *data() {
+  }
+  
+  *run() {
+  }
+}
+
+module.exports = ${'name'}${'actorEnding'};
+`
+  ],
+  [
+    'Sut',
+    StackComponentsHelpers._template`
+const ActorApi = require('actor-api');
+
+
+class ${'name'}${'actorEnding'} extends ActorApi.Actor${'actorType'} {
+  constructor() {
+    super();
+    this.clientConnection = null;
+    this.serverConnection = null;
+  }
+  
+  *data() {
+  }
+  
+  *initServer() {
+    this.serverConnection = this.createServer('__stack_name__');
+  }
+  
+  *initClient() {
+    this.clientConnection = this.createConnection('__stack_name__');
+  }
+  
+  *run() {
+    this.serverConnection.accept();
+  }
+  
+  *exit(interrupted) {
+    this.closeConnection(this.serverConnection);
+    this.closeConnection(this.clientConnection);
+  }
+}
+
+module.exports = ${'name'}${'actorEnding'};
+`
+  ],
+  [
+    'ActorPartPre',
+    StackComponentsHelpers._template`
+const ActorApi = require('actor-api');
+
+
+class ${'name'}${'actorEnding'} extends ActorApi.ActorPartPre {
+  constructor() {
+    super();
+  }
+  
+  *run() {
+  }
+}
+
+module.exports = ${'name'}${'actorEnding'};
+`
+  ],
+  [
+    'ActorPartPost',
+    StackComponentsHelpers._template`
+const ActorApi = require('actor-api');
+
+
+class ${'name'}${'actorEnding'} extends ActorApi.ActorPartPost {
+  constructor() {
+    super();
+  }
+  
+  *run() {
+  }
+}
+
+module.exports = ${'name'}${'actorEnding'};
+`
+  ],
+  [
+    'Msg',
+    StackComponentsHelpers._template``
+  ],
+  [
+    'Class [class js file]',
+    StackComponentsHelpers._template`
+
+class ${'name'} {
+  constructor() {
+    
+  }
+}
+
+module.exports = ${'name'};
+`
+  ],
+  [
+    'None [empty js file]',
+    StackComponentsHelpers._template``
+  ]
+]);
+
+
+module.exports = ActorEditorFileNew;

package/project/server/plugin-data/actor-editor/plugin_data_ActorEditorFileRename.js

@@ -0,0 +1,28 @@
+
+'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 ActorEditorFileRename extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(oldPath, newPath) {
+    Fs.access(ActorPathData.getActorFile(newPath), Fs.constants.F_OK, (err) => {
+      if(err && 'ENOENT' === err.code) {
+        this.asynchRenameResponse(ActorPathData.getActorFile(oldPath), ActorPathData.getActorFile(newPath));
+      }
+      else {
+        this.expectAsynchResponseError(`Path '${newPath}' does already exist.`);
+      }
+    });
+  }
+}
+
+
+
+module.exports = ActorEditorFileRename;

package/project/server/plugin-data/actor-editor/plugin_data_ActorEditorFileUpdate.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 ActorEditorFileUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.Update);
+  }
+  
+  onRequest(file, data) {
+    this.asynchWriteTextFileResponse(ActorPathData.getActorFile(file), data);
+  }
+}
+
+module.exports = ActorEditorFileUpdate;

package/project/server/plugin-data/actor-editor/plugin_data_ActorEditorFolderDelete.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 ActorEditorFolderDelete extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.DELETE);
+  }
+  
+  onRequest(file) {
+    this.asynchRmdirResponse(ActorPathData.getActorFile(file), true, true);
+    this.asynchRmdirResponse(ActorPathDist.getActorFile(file), true, true);
+  }
+}
+
+
+module.exports = ActorEditorFolderDelete;

package/project/server/plugin-data/actor-editor/plugin_data_ActorEditorFolderNew.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 ActorEditorFolderNew extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+  }
+  
+  onRequest(file) {
+    this.asynchMkdirResponse(ActorPathData.getActorFile(file));
+  }
+}
+
+
+module.exports = ActorEditorFolderNew;

package/project/server/plugin-data/actor-editor/plugin_data_ActorEditorFolderUpdate.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 ActorEditorFolderUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+  }
+  
+  onRequest(oldPath, newPath) {
+    this.asynchRenameResponse(ActorPathData.getActorFile(oldPath), ActorPathData.getActorFile(newPath));
+  }
+}
+
+
+module.exports = ActorEditorFolderUpdate;

package/project/server/plugin-data/actor-editor/plugin_data_ActorEditorProjectGet.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 ActorEditorProjectGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    let pendings = 2;
+    let fLocal = null;
+    let fGlobal = null;
+    this._getProject(ActorPathData.getActorsLocalProjectPureFile(), ActorPathGenerated.getActorsProjectFile('./Actors-local'), (f) => {
+      fLocal = f;
+      if(0 === --pendings) {
+        fLocal();
+        fGlobal();
+      }
+    });
+    this._getProject(ActorPathData.getActorsGlobalProjectPureFile(), ActorPathGenerated.getActorsProjectFile('./Actors-global'), (f) => {
+      fGlobal = f;
+      if(0 === --pendings) {
+        fLocal();
+        fGlobal();
+      }
+    });
+    /*this.asynchReadFileResponse(ActorPathData.getActorsGlobalProject(), (err, object) => {
+      const project = new Project(object);
+      this.asynchWriteTextFile(ActorPathData.getActorsGlobalProjectPureFile(), project.exportPure());
+    });
+    this.asynchReadFileResponse(ActorPathData.getActorsLocalProject(), (err, object) => {
+      const project = new Project(object);
+      this.asynchWriteTextFile(ActorPathData.getActorsLocalProjectPureFile(), 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 = ActorEditorProjectGet;

package/project/server/plugin-data/actor-editor/plugin_data_ActorEditorProjectToggle.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 ActorEditorProjectToggle extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(content, path) {
+    this.asynchWriteFileResponse(ActorPathGenerated.getActorsProjectFile(path), content, false);
+  }
+}
+
+module.exports = ActorEditorProjectToggle;

package/project/server/plugin-data/actor-editor/plugin_data_ActorEditorProjectUpdate.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 ActorEditorProjectUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(path, content) {
+    const project = new Project(content);
+    this.asynchWriteTextFile(ActorPathData.getActorsProjectPureFile(path), project.exportPure(), false);
+    this.asynchWriteFileResponse(ActorPathGenerated.getActorsProjectFile(path), content, false);
+  }
+}
+
+module.exports = ActorEditorProjectUpdate;

package/project/server/plugin-data/actor-editor/plugin_data_ActorEditorStacksGet.js

@@ -0,0 +1,54 @@
+
+'use strict';
+
+const StackComponentsFactory = require('z-abs-funclayer-stack-server/server/factory/stack-components-factory');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class ActorEditorStacksGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    const templatesMap = [];
+    StackComponentsFactory.getStacks((stacks) => {
+      stacks.forEach((stack) => {
+        let foundTemplates = false;
+        const actorStackTemplateFactory = StackComponentsFactory.createTemplatesActors(stack.name);
+        if(actorStackTemplateFactory) {
+          try {
+            const actorsTypesMap = [];
+            const actorsTypes = new actorStackTemplateFactory().templates;
+            if(actorsTypes) {
+              actorsTypes.forEach((actorsType) => {
+                foundTemplates = foundTemplates || 0 !== actorsType.templateNames.length;
+                actorsTypesMap.push([
+                  actorsType.name,
+                  {
+                    names: actorsType.templateNames,
+                    markupNodes: actorsType.markupNodes,
+                    markupStyles: actorsType.markupStyles,
+                    markups: actorsType.markups
+                  }
+                ]);
+              });
+              if(foundTemplates) {
+                templatesMap.push([
+                  stack.name,
+                  actorsTypesMap
+                ]);
+              }
+            }
+          }
+          catch(e) {
+            ddb.error(`Failing to load stack '${stack.name}' for Stack Templates.`, e);
+          }
+        }
+      });
+      this.expectAsynchResponseSuccess(templatesMap);
+    });
+  }
+}
+
+module.exports = ActorEditorStacksGet;

package/project/server/plugin-data/addresses/plugin_data_AddressesClientAddressGet.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 AddressesClientAddressGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.asynchReadFileResponse(ActorPathData.getAddressesGlobalAddressesClientFile());
+    this.asynchReadFileResponse(ActorPathData.getAddressesLocalAddressesClientFile());
+  }
+}
+
+module.exports = AddressesClientAddressGet;