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

package/project/client/stores/education-store.js

@@ -0,0 +1,14 @@
+
+'use strict';
+
+import DocumentationStoreBase from 'z-abs-complayer-documentation-client/client/stores/documentation-store-base';
+
+
+class EducationStore extends DocumentationStoreBase {
+  constructor() {
+    super('Education', 'actorjs');
+  }
+}
+
+
+module.exports = EducationStore.export(EducationStore);

package/project/client/stores/filter-store.js

@@ -0,0 +1,30 @@
+
+'use strict';
+
+import StoreBase from 'z-abs-corelayer-client/client/store/store-base';
+
+
+class FilterStore extends StoreBase {
+  constructor() {
+    super({
+      sut: '*',
+      fut: '*',
+      show: false
+    });
+  }
+  
+  onActionSutFilter(action) {
+    this.updateState({sut: {$set: action.sut}});
+  }
+  
+  onActionFutFilter(action) {
+    this.updateState({fut: {$set: action.fut}});
+  }
+  
+  onActionShowFilter(action) {
+    this.updateState({show: {$set: action.show}});
+  }
+}
+
+
+module.exports = FilterStore.export(FilterStore);

package/project/client/stores/function-under-test-store.js

@@ -0,0 +1,58 @@
+
+'use strict';
+
+import TestCaseStore from './test-case-store';
+import TestSuiteStore from './test-suite-store';
+import { DataActionFunctionUnderTestGet, DataActionFunctionUnderTestAdd, DataActionFunctionUnderTestDelete } from '../actions/action-function-under-test';
+import { ActionTestCaseRecentDelete } from '../actions/action-test-case/action-test-case';
+import { ActionTestSuiteRecentDelete } from '../actions/action-test-suite/action-test-suite';
+import StoreBaseData from 'z-abs-corelayer-client/client/store/store-base-data';
+
+
+class FunctionUnderTestStore extends StoreBaseData {
+  constructor() {
+    super({
+      functionUnderTests: []
+    });
+  }
+  
+  onActionFunctionUnderTestGet(action) {
+    this.sendDataAction(new DataActionFunctionUnderTestGet(action.repo, action.sut));
+  }
+  
+  onActionFunctionUnderTestDelete(action) {
+    this.sendDataAction(new DataActionFunctionUnderTestDelete(action.currentRepo, action.currentSut, action.futs));
+  }
+  
+  onActionFunctionUnderTestAdd(action) {
+    this.sendDataAction(new DataActionFunctionUnderTestAdd(action.repo, action.sut, action.fut, action.description));
+  }
+  
+  onDataActionFunctionUnderTestGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.updateState({functionUnderTests: {$set: response.data.functionUnderTests}});
+    }
+  }
+  
+  onDataActionFunctionUnderTestAdd(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.sendDataAction(new DataActionFunctionUnderTestGet(action.repo, action.sut));
+    }
+  }
+  
+  onDataActionFunctionUnderTestDelete(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.sendDataAction(new DataActionFunctionUnderTestGet(action.currentRepo, action.currentSut));
+      action.futs.forEach((fut) => {
+        TestCaseStore.dispatchAction(new ActionTestCaseRecentDelete(fut.repo, fut.sut, fut.fut));
+        TestSuiteStore.dispatchAction(new ActionTestSuiteRecentDelete(fut.repo, fut.sut, fut.fut));
+      });
+    }
+  }
+}
+
+
+module.exports = FunctionUnderTestStore.export(FunctionUnderTestStore);

package/project/client/stores/load-store.js

@@ -0,0 +1,92 @@
+
+'use strict';
+
+import { DataActionLoadEnvironmentGet, DataActionLoadEnvironmentUpdate } from '../actions/action-load/data-action-load';
+//import MarkupLoad from 'z-abs-complayer-markup-client/client/markup/markup-load/markup-load-environment';
+import StoreBaseData from 'z-abs-corelayer-client/client/store/store-base-data';
+
+
+class LoadStore extends StoreBaseData {
+  constructor() {
+    super({
+      testDataLocalGlobals: [],
+      testDataLocalLocals: [],
+      currentView: '',
+      markup: {
+        definition: false,
+        content: undefined,
+        contentOriginal: undefined,
+        rows: undefined
+      }
+    });
+  }
+  
+  onActionLoadEnvironmentGet(action) {
+    this.sendDataAction(new DataActionLoadEnvironmentGet());
+  }
+  
+  onActionLoadMarkup(action) {
+    let markup = this.markupStringify();
+    this.updateState({markup: { definition: {$set: true}}});
+    this.updateState({markup: { content: {$set: markup}}});
+    this.updateState({markup: { contentOriginal: {$set: markup}}});
+  }
+  
+  onActionLoadMarkupSave(action) {
+    const result = this.markupParse(this.state.markup.content);
+    if(!result.success) {
+      this.updateState({markup: { rows: {$set: result.rows}}});
+    }
+    else {
+      if('environment' === this.state.currentView) {
+        this.sendDataAction(new DataActionLoadEnvironmentUpdate(result.globals, result.locals));
+      }
+      this.clearMarkup();
+    }
+  }
+  
+  onActionLoadMarkupCancel(action) {
+     this.clearMarkup();
+  }
+  
+  onActionLoadMarkupChange(action) {
+    const result = this.markupParse(action.markup);
+    this.updateState({markup: { rows: {$set: result.rows}}});
+    this.updateState({markup: { content: {$set: action.markup}}});
+  }
+  
+  onDataActionLoadEnvironmentGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.updateState({testDataEnvironmentGlobals: {$set: response.data[0]}});
+      this.updateState({testDataEnvironmentLocals: {$set: response.data[1]}});
+      this.updateState({currentView: {$set: 'environment'}});
+    }
+  }
+    
+  onDataActionLoadEnvironmentUpdate(action) {
+    this.sendDataAction(new DataActionLoadEnvironmentGet());
+  }
+  
+  clearMarkup() {
+    this.updateState({markup: { definition: {$set: false}}});
+    this.updateState({markup: { content: {$set: undefined}}});
+    this.updateState({markup: { contentOriginal: {$set: undefined}}});
+    this.updateState({markup: { rows: {$set: undefined}}});
+  }
+  
+  markupStringify() {
+    if('environment' === this.state.currentView) {
+      //return MarkupLoadEnvironment.stringify(this.state.testDataEnvironmentGlobals, this.state.testDataEnvironmentLocals);
+    }
+  }
+  
+  markupParse(markup) {
+    if('environment' === this.state.currentView) {
+      //return MarkupLoadEnvironment.parse(markup);
+    }
+  }
+}
+
+
+module.exports = LoadStore.export(LoadStore);

package/project/client/stores/login-store.js

@@ -0,0 +1,232 @@
+
+'use strict';
+
+import ActorDefault from '../actor-default';
+import DataConfig from 'z-abs-corelayer-client/client/communication/data-config';
+import { DataActionLoginWsGet, DataActionLoginGet, DataActionLoginPing, DataActionLoginUpdate, DataActionLoginCreateInterfaces, DataActionLoginDeleteInterfaces, DataActionLoginButtonsAdd, DataActionLoginButtonsGet, DataActionLoginButtonsUpdate, DataActionLoginDataGet } from '../actions/action-login/data-action-login';
+import StoreBaseData from 'z-abs-corelayer-client/client/store/store-base-data';
+
+
+class LoginStore extends StoreBaseData {
+  constructor() {
+    super({
+      login: {
+        labId: '',
+        userId: '',
+        repo: '',
+        systemUnderTest: ActorDefault.NAME(),
+        systemUnderTestInstance: '',
+        nodes: [],
+        forcedLocalhost: false
+      },
+      loginReport: [],
+      virtualNetworks: [],
+      osNetworks: [],
+      chosenAddresses: {},
+      pingResults: new Map(),
+      cpus: [],
+      loggedIn: false,
+      loginDataChanged: false,
+      working: false,
+      buttons: {
+        toolbar: {
+          forceLocalhost: false
+        }
+      }
+    });
+    this.buttonsKey = '';
+    this.pingClearId = -1;
+    this.sendDataAction(new DataActionLoginWsGet());
+    this.sendDataAction(new DataActionLoginGet());
+  }
+  
+  isLoggedIn() {
+    return this.state.loggedIn ? this.state.login : null;
+  }
+  
+  onActionLoginMounted(action) {
+    this.sendDataAction(new DataActionLoginGet());
+    this.once('DataActionLoginGet', (store) => {
+      this.buttonsKey = `${store.state.login.labId}_${store.state.login.userId}`;
+      this.sendDataAction(new DataActionLoginButtonsGet(this.buttonsKey));
+      this.sendDataAction(new DataActionLoginDataGet());
+    });
+  }
+  
+  onActionLoginGet(action) {
+    this.updateState({working: { $set: true}});
+    this.sendDataAction(new DataActionLoginGet());
+  }
+  
+  onActionLoginUpdate(action) {
+    this.updateState({working: { $set: true}});
+    this.sendDataAction(new DataActionLoginUpdate(action.labId, action.userId, action.repo, action.systemUnderTest, action.systemUnderTestInstance, action.nodes, action.forceLocalhost));
+  }
+  
+  onActionLoginDataChanged(action) {
+    this.updateState({loginDataChanged: { $set: true}});
+  }
+  
+  onActionLoginPing(action) {
+    this.updateState({working: { $set: true}});
+    this.sendDataAction(new DataActionLoginPing(this.state.chosenAddresses));
+  }
+  
+  onActionLoginCreateInterfaces(action) {
+    this.updateState({working: { $set: true}});
+    this.sendDataAction(new DataActionLoginCreateInterfaces(action));
+  }
+  
+  onActionLoginDeleteInterfaces(action) {
+    this.updateState({working: { $set: true}});
+    this.sendDataAction(new DataActionLoginDeleteInterfaces(action));
+  }
+  
+  onActionLoginButtonsUpdate(action) {
+    const tab = this.state.buttons[action.tab];
+    tab[action.button] = action.value;
+    this.sendDataAction(new DataActionLoginButtonsUpdate(this.buttonsKey, this.state.buttons));
+  }
+  
+  onDataActionLoginGet(action) {
+    this.updateState({working: { $set: false}});
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      let i = -1;
+      const login = response.data[++i];
+      const nodes = login.nodes.filter((node) => {
+        if(node.instanceName === login.systemUnderTestInstance) {
+          return node;
+        }
+      });
+      this.updateState({login: { labId: {$set: login.labId}}});
+      this.updateState({login: { userId: {$set: login.userId}}});
+      this.updateState({login: { repo: {$set: login.repo}}});
+      this.updateState({login: { systemUnderTest: {$set: login.systemUnderTest}}});
+      this.updateState({login: { systemUnderTestInstance: {$set: login.systemUnderTestInstance}}});
+      this.updateState({login: { nodes: {$set: nodes}}});
+      this.updateState({login: { forcedLocalhost: {$set: login.forcedLocalhost}}});
+      this.updateState({virtualNetworks: { $set: response.data[++i]}});
+      this.updateState({loginReport: { $set: response.data[++i]}});
+      this.updateState({chosenAddresses: { $set: response.data[++i]}});
+      this.updateState({loggedIn: {$set: true}});
+    }
+    else {
+      this.updateState({loggedIn: {$set: false}});
+    }
+  }
+    
+  onDataActionLoginWsGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      DataConfig.setWs(response.data[0]);
+      window.actorJsConfig = response.data[1];
+    }
+  }
+  
+  onDataActionLoginUpdate(action) {
+    this.updateState({working: { $set: false}});
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      let i = -1;
+      const login = response.data[++i];
+      const nodes = login.nodes.filter((node) => {
+        if(node.instanceName === login.systemUnderTestInstance) {
+          return node;
+        }
+      });
+      this.updateState({login: { labId: {$set: login.labId}}});
+      this.updateState({login: { userId: {$set: login.userId}}});
+      this.updateState({login: { repo: {$set: login.repo}}});
+      this.updateState({login: { systemUnderTest: {$set: login.systemUnderTest}}});
+      this.updateState({login: { systemUnderTestInstance: {$set: login.systemUnderTestInstance}}});
+      this.updateState({login: { nodes: {$set: nodes}}});
+      this.updateState({login: { forcedLocalhost: {$set: login.forcedLocalhost}}});
+      this.updateState({virtualNetworks: {$set: response.data[++i]}});
+      this.updateState({loginReport: { $set: response.data[++i]}});
+      this.updateState({chosenAddresses: { $set: response.data[++i]}});
+      this.updateState({loginDataChanged: { $set: false}});
+      this.updateState({pingResults: { $set: new Map()}});
+      this.updateState({loggedIn: {$set: true}});
+      this.buttonsKey = `${this.state.login.labId}_${this.state.login.userId}`;
+      this.sendDataAction(new DataActionLoginButtonsGet(this.buttonsKey));
+    }
+    else {
+      this.updateState({loggedIn: {$set: false}});
+    }
+  }
+  
+  onDataActionLoginDataGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      let i = -1;
+      this.updateState({cpus: {$set: response.data[++i]}});
+      this.updateState({osNetworks: {$set: response.data[++i]}});
+    }
+  }
+  
+  onDataActionLoginPing(action) {
+    this.updateState({working: { $set: false}});
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.updateState({pingResults: {$set: new Map(response.data)}});
+      this.pingClearId = setTimeout(() => {
+        this.pingClearId = -1;
+        this.updateContext(() => {
+          this.updateState({pingResults: {$set: new Map()}});
+        });
+      }, 3000);
+    }
+  }
+  
+  onDataActionLoginCreateInterfaces(action) {
+    this.updateState({working: { $set: false}});
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.updateState({loginDataChanged: {$set: true}});
+    }
+  } 
+  
+  onDataActionLoginDeleteInterfaces(action) {
+    this.updateState({working: { $set: false}});
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.updateState({loginDataChanged: {$set: true}});
+    }
+  }
+  
+  onDataActionLoginButtonsAdd(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.updateState({buttons: {$set: response.data}});
+    }
+  }
+  
+  onDataActionLoginButtonsGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      const keys = Object.keys(this.state.buttons);
+      const resutObject = {};
+      keys.forEach((key) => {
+        const stateObject = this.state.buttons[key];
+        const storedObject = response.data[key];
+        const mergedObject = {...stateObject, ...storedObject};
+        resutObject[key] = mergedObject;
+      });
+      this.updateState({buttons: {$set: resutObject}});
+    }
+    else {
+      this.sendDataAction(new DataActionLoginButtonsAdd(this.buttonsKey, this.state.buttons));
+    }
+  }
+  
+  onDataActionLoginButtonsUpdate(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      this.updateState({buttons: {$set: response.data}});
+    }
+  }
+}
+
+
+module.exports = LoginStore.export(LoginStore);

package/project/client/stores/plugins-store.js

@@ -0,0 +1,255 @@
+
+'use strict';
+
+import { DataActionPluginsGet, DataActionPluginsBundleGet } from '../actions/action-plugins/data-action-plugins';
+import StoreBaseData from 'z-abs-corelayer-client/client/store/store-base-data';
+
+
+class PluginsStore extends StoreBaseData {
+  constructor() {
+    super({
+      plugins: new Map(),
+      dependencies: new Map()
+    });
+  }
+  
+  onInit() {
+    const loadedScripts = [...document.scripts].map((s) => {
+      let bundle = null;
+      if(s.src) {
+        const index = s.src.lastIndexOf('/');
+        if(-1 !== index) {
+          bundle = s.src.substring(index + 1);
+        }
+        return {
+          bundle: bundle,
+          name: s.dataset.name,
+          loaded: true
+        }
+      }
+    }).filter(src => src);
+    loadedScripts.forEach((loadedScript) => {
+      if(loadedScript.name) {
+        this.state.dependencies.set(loadedScript.name, loadedScript);
+      }
+    });
+    this.sendDataAction(new DataActionPluginsGet());
+  }
+  
+  onDataActionPluginsGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      const plugins = new Map();
+      response.data.forEach((plugin) => {
+        plugin.loaded = false;
+        plugin.data = null;
+        const dependencies = plugin.dependencies;
+        plugin.dependencies = new Map();
+        dependencies.forEach((dependency) => {
+          plugin.dependencies.set(dependency.name, dependency);
+          dependency.loaded = this.state.dependencies.has(dependency.name);
+          if(!dependency.loaded) {
+            if(dependency.bundle) {
+              this.sendDataAction(new DataActionPluginsBundleGet(dependency.bundle, 'js', dependency.name, plugin.name));
+            }
+            if(dependency.cssBundle) {
+              this.sendDataAction(new DataActionPluginsBundleGet(dependency.cssBundle, 'css', dependency.name, plugin.name));
+            }
+          }
+        });
+        plugins.set(plugin.name, plugin);
+        this.sendDataAction(new DataActionPluginsBundleGet(plugin.bundle, 'js', plugin.name, null));
+        this.sendDataAction(new DataActionPluginsBundleGet(plugin.cssBundle, 'css', plugin.name, null));
+      });
+      this.updateState({plugins: {$set: plugins}});
+    }
+  }
+  
+  onDataActionPluginsBundleGet(action) {
+    const response = action.getResponse();
+    if(response.isSuccess()) {
+      const f = (production, data, done) => {
+        if(production) {
+          this._gunzipBrowser(new Uint8Array(data.data), done);
+        }
+        else {
+          done(null, data);
+        }
+      };
+      f(response.data[0], response.data[1], (err, data) => {
+        if('js' === action.type) {
+          if(!action.parentName) {
+            if(this._isDependenciesLoaded(action.name)) {
+              this._loadJavaScript({
+                text: data,
+                name: action.name
+              }, (err) => {
+                if(err) {}
+                else {
+                  this.updateState({plugins: (plugins) => {
+                    const plugin = plugins.get(action.name);
+                    const nextPlugin = this.deepCopy(plugin);
+                    nextPlugin.loaded = true;
+                    nextPlugin.data = null;
+                    plugins.set(action.name, nextPlugin);
+                  }});
+                }
+              });
+            }
+            else {
+              this.updateState({plugins: (plugins) => {
+                const plugin = plugins.get(action.name);
+                plugin.data = {
+                  text: data,
+                  name: action.name
+                };
+              }});
+            }
+          }
+          else {
+            this._loadJavaScript({
+              text: data,
+              name: action.name
+            }, (err) => {
+              if(err) {}
+              else {
+                this.updateState({plugins: (plugins) => {
+                  const plugin = plugins.get(action.parentName);
+                  const dependency = plugin.dependencies.get(action.name);
+                  const nextDependency = this.deepCopy(dependency);
+                  nextDependency.loaded = true;
+                  plugin.dependencies.set(action.name, nextDependency);
+                }});
+                if(this._isDependenciesLoaded(action.parentName) && !this._isLoaded(action.parentName)) {
+                  const parent = this.state.plugins.get(action.parentName);
+                  this._loadJavaScript({
+                    text: parent.data.text,
+                    name: parent.data.name
+                  }, (err) => {
+                    this.updateState({plugins: (plugins) => {
+                      const plugin = plugins.get(action.parentName);
+                      const nextPlugin = this.deepCopy(plugin);
+                      nextPlugin.loaded = true;
+                      nextPlugin.data = null;
+                      plugins.set(action.parentName, nextPlugin);
+                    }});
+                  });
+                }       
+              }
+            });
+          }
+        }
+        else if('css' === action.type) {
+          const css = document.createElement('style');
+          css.type = 'text/css';
+          if(css.styleSheet) {
+            css.styleSheet.cssText = data;
+          }
+          else {
+            css.appendChild(document.createTextNode(data));
+          }
+          css.dataset.name = action.name;
+          css.dataset.type = "css";
+          document.head.appendChild(css);
+        }
+        else {
+          ddb.error('unknown:', data);
+        }
+      });
+    }
+    else {
+      ddb.error('error:', response);
+    }
+  }
+  
+  _gunzipBrowser(data, done) {
+    try {
+      const ds = new DecompressionStream("gzip");
+      const stream = new Blob([data]).stream().pipeThrough(ds);
+      new Response(stream).arrayBuffer()
+      .then((buf) => {
+        this.updateContext(() => {
+          done(null, new TextDecoder().decode(buf));
+        });
+      }).catch((err) => {
+        this.updateContext(() => {
+          done(err);
+        });
+      });
+    }
+    catch(err) {
+      done(err);
+    }
+  }
+    
+  _loadJavaScript(data, cb) {
+    const eventName = `ajEvent${data.name}`;
+    const handler = (e) => {
+      document.removeEventListener(eventName, handler);
+      this.updateContext(() => {
+        cb(e.detail.error);
+      });
+    };
+    document.addEventListener(eventName, handler);
+    const script = document.createElement('script');
+    script.type = 'text/javascript';
+    script.dataset.name = data.name;
+    script.dataset.type = "js";
+    script.text = `
+    try {
+      ${data.text}
+      document.dispatchEvent(
+        new CustomEvent('${eventName}', {
+          detail: { error: null }
+        })
+      );
+    } catch (err) {
+      document.dispatchEvent(
+        new CustomEvent('${eventName}', {
+          detail: { error: err }
+        })
+      );
+      throw err;
+    }
+  `;
+   document.body.appendChild(script);
+  }
+    
+  _isDependenciesLoaded(name) {
+    const plugin = this.state.plugins.get(name);
+    let loaded = true;
+    plugin.dependencies.forEach((dependency) => {
+      loaded &&= dependency.loaded;
+    });
+    return loaded;
+  }
+  
+  _isLoaded(name) {
+    const plugin = this.state.plugins.get(name);
+    if(plugin) {
+      return plugin.loaded;
+    }
+    else {
+      return false;
+    }
+  }
+  
+  // --- API ---
+  
+  isLoaded(name) {
+    const plugin = this.state.plugins.get(name);
+    if(plugin) {
+      if(plugin.loaded) {
+        let loaded = true;
+        plugin.dependencies.forEach((dependency) => {
+          loaded &&= dependency.loaded;
+        });
+        return loaded;
+      }
+    }
+    return false;
+  }
+}
+
+
+module.exports = PluginsStore.export(PluginsStore);