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

package/project/server/plugin-data/content/plugin_data_ContentOtherUpdate.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 ContentOtherUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(globals, locals) {
+    this.asynchWriteFileResponse(ActorPathData.getContentOtherGlobalFile(), globals, false);
+    this.asynchWriteFileResponse(ActorPathData.getContentOtherLocalFile(), locals, false);
+  }
+}
+
+module.exports = ContentOtherUpdate;

package/project/server/plugin-data/content/plugin_data_ContentTextGet.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 ContentTextGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.asynchReadFileResponse(ActorPathData.getContentTextGlobalFile());
+    this.asynchReadFileResponse(ActorPathData.getContentTextLocalFile());
+  }
+}
+
+module.exports = ContentTextGet;

package/project/server/plugin-data/content/plugin_data_ContentTextUpdate.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 ContentTextUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(globals, locals) {
+    this.asynchWriteFileResponse(ActorPathData.getContentTextGlobalFile(), globals, false);
+    this.asynchWriteFileResponse(ActorPathData.getContentTextLocalFile(), locals, false);
+  }
+}
+
+module.exports = ContentTextUpdate;

package/project/server/plugin-data/content/plugin_data_ContentVideoGet.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 ContentVideoGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.asynchReadFileResponse(ActorPathData.getContentVideoGlobalFile());
+    this.asynchReadFileResponse(ActorPathData.getContentVideoLocalFile());
+  }
+}
+
+module.exports = ContentVideoGet;

package/project/server/plugin-data/content/plugin_data_ContentVideoUpdate.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 ContentVideoUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(globals, locals) {
+    this.asynchWriteFileResponse(ActorPathData.getContentVideoGlobalFile(), globals, false);
+    this.asynchWriteFileResponse(ActorPathData.getContentVideoLocalFile(), locals, false);
+  }
+}
+
+module.exports = ContentVideoUpdate;

package/project/server/plugin-data/function-under-test/plugin_data_FunctionUnderTestAdd.js

@@ -0,0 +1,60 @@
+
+'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 FunctionUnderTestAdd extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+  }
+  
+  onRequest(repoName, sutName, futName, description) {
+    let functionUnderTest = {
+      name: futName,
+      description: description,
+      status: 'visible'
+    }
+    let responsePart = this.verifyInput(functionUnderTest);
+    if(true !== responsePart) {
+      return responsePart;
+    }
+    Fs.mkdir(ActorPathData.getFunctionUnderTestFolder(repoName, sutName, futName), (err) => {
+      if(err) {
+        return this.responsePartError(`Could not create the Function Under Test Folder: ' ${ActorPathData.getFunctionUnderTestFolder(repoName, sutName, futName)} '.`);
+      }
+      Fs.writeFile(ActorPathData.getFunctionUnderTestFile(repoName, sutName, futName), JSON.stringify(functionUnderTest, null, 2), (err) => {
+        if(err) {
+          return this.responsePartError(`Could not create the Function Under Test File: ' ${ActorPathData.getFunctionUnderTestFile(repoName, sutName, futName)} '.`);
+        }
+        Fs.mkdir(ActorPathData.getTestCasesFolder(repoName, sutName, futName), (err) => {
+          if(err) {
+            return this.responsePartError(`Could not create the TestCases Folder: ' ${ActorPathData.getTestCasesFolder(repoName, sutName, futName)} '.`);
+          }
+          Fs.mkdir(ActorPathData.getTestSuitesFolder(repoName, sutName, futName), (err) => {
+            if(err) {
+              return this.responsePartError(`Could not create the TestSuites Folder: ' ${ActorPathData.getTestSuitesFolder(repoName, sutName, futName)} '.`);
+            }
+          });   
+        });    
+      });
+    });
+    return this.responsePartSuccess();
+  }
+  
+  verifyInput(functionUnderTest) {
+    let name = functionUnderTest.name;
+    if(0 === name.length) {
+      return this.responsePartError(`The Function Under Test name: '' must not be empty.`);
+    }
+    let first = name.charAt(0);
+    if(first === first.toLowerCase() || first !== first.toUpperCase()) {
+      return this.responsePartError(`A Function Under Test name must start with uppercase, name: '${name}'.`);
+    }
+    return true;
+  }
+}
+
+module.exports = FunctionUnderTestAdd;

package/project/server/plugin-data/function-under-test/plugin_data_FunctionUnderTestDelete.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 FunctionUnderTestDelete extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.DELETE);
+  }
+  
+  onRequest(futs) {
+    futs.forEach((fut) => {
+      this.asynchRmdirResponse(ActorPathData.getFunctionUnderTestFolder(fut.repo, fut.sut, fut.fut), true);
+    });
+  }
+}
+
+module.exports = FunctionUnderTestDelete;

package/project/server/plugin-data/function-under-test/plugin_data_FunctionUnderTestGet.js

@@ -0,0 +1,92 @@
+
+'use strict';
+
+const Fs = require('fs');
+const Path = require('path');
+const Logger = require('z-abs-corelayer-server/server/log/logger');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class FunctionUnderTestGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(repoName, sutName, futName) {
+    if(futName) {
+      return this.responsePartError(`Could not get the Function Under Test ${futName}. NOT IMPLEMENTED`);
+    }
+    else {
+      let responseDone = false;
+      this.getFunctionUnderTests(repoName, sutName, (data, err) => {
+        if(!responseDone) {
+          responseDone = true;
+          if(err) {
+            LOG_ERROR(Logger.ERROR.CATCH, 'FunctionUnderTestGet', err);
+            return this.responsePartError('Could not get the Functions Under Test.');
+          }
+          data.sort((a, b) => {
+            if(a.name < b.name) {
+              return -1;
+            }
+            else if(b.name < a.name) {
+              return 1;
+            }
+            else {
+              return 0;
+            }
+          });
+          return this.responsePartSuccess({
+            functionUnderTests: data
+          });
+        }
+      });
+    }
+  }
+  
+  getFunctionUnderTests(repoName, sutName, done) {
+    let functionUnderTests = [];
+    let dir = ActorPathData.getSystemUnderTestFolder(repoName, sutName);
+    Fs.readdir(dir, (err, files) => {
+      if(err) {
+        return done(functionUnderTests, err);
+      }
+      let pendings = files.length;
+      if(0 === pendings) {
+        return done(functionUnderTests);
+      }
+      for(let i = 0; i < files.length; ++i) {
+        let file = files[i];
+        let resolvedDir = Path.resolve(dir, file);      
+        Fs.stat(resolvedDir, (err, stat) => {
+          if(err) {
+            return done(functionUnderTests, err);
+          }
+          if(stat && stat.isDirectory()) {
+            let prefix = `Fut${sutName}`;
+            if(file.startsWith(prefix) && file.length > prefix.length) {
+              Fs.readFile(ActorPathData.getFunctionUnderTestFile(repoName, sutName, file.substr(prefix.length)), (err, data) => {
+                if(err) {
+                  return done(functionUnderTests, err);
+                }	  
+                functionUnderTests.push(JSON.parse(data));
+                if(0 === --pendings) {
+                  return done(functionUnderTests);
+                }
+              });
+            }
+            else if(0 === --pendings) {
+              return done(functionUnderTests);
+            }
+          }
+          else if(0 === --pendings) {
+            return done(functionUnderTests);
+          }
+        });
+      }
+    });
+  }
+}
+
+module.exports = FunctionUnderTestGet;

package/project/server/plugin-data/login/plugin_data_LoginButtonsAdd.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 LoginButtonsAdd extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+  }
+  
+  onRequest(key, valueObject) {
+    this.asynchWriteFileResponse(ActorPathGenerated.getStagingButtonsFile(key), valueObject, true);
+  }
+}
+
+module.exports = LoginButtonsAdd;

package/project/server/plugin-data/login/plugin_data_LoginButtonsGet.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 LoginButtonsGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(key) {
+    this.asynchReadFileResponse(ActorPathGenerated.getStagingButtonsFile(key));
+  }
+}
+
+module.exports = LoginButtonsGet;

package/project/server/plugin-data/login/plugin_data_LoginButtonsUpdate.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 LoginButtonsUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(key, valueObject) {
+    this.asynchWriteFileResponse(ActorPathGenerated.getStagingButtonsFile(key), valueObject, true);
+  }
+}
+
+module.exports = LoginButtonsUpdate;

package/project/server/plugin-data/login/plugin_data_LoginCreateInterfaces.js

@@ -0,0 +1,73 @@
+
+'use strict';
+
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Os = require('os');
+
+
+class LoginCreateInterfaces extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+    this.pendings = 0;
+    this.results = [];
+    this.interfaceDhcpEnabledCache = new Set();
+  }
+  
+  onRequest(interfaceParameters, password) {
+    interfaceParameters.forEach((interfaceParameter) => {
+      ++this.pendings;
+      this.setDhcpEnabled(interfaceParameter, password, () => {
+        if(0 === --this.pendings) {
+          interfaceParameters.forEach((interfaceParameter) => {
+            ++this.pendings;
+            this.createInterface(interfaceParameter, password, () => {
+              if(0 === --this.pendings) {
+                return this.expectAsynchResponseSuccess(this.results);     
+              }
+            });
+          });
+        }
+      });
+    });
+  }
+  
+  _getCreateInterfacesCommand(interfaceParameter) {
+    if('win32' === Os.platform()) {
+      //netsh interface ip set address "Wi-Fi" dhcp
+      return `netsh interface ip add address "${interfaceParameter.network}" ${interfaceParameter.address} ${interfaceParameter.netmask}`;
+    }
+    else {
+      return `ifconfig ${interfaceParameter.network}:${interfaceParameter.virtualNetwork} ${interfaceParameter.address} netmask ${interfaceParameter.netmask}`;
+    }
+  }
+  
+  setDhcpEnabled(interfaceParameter, password, cb) {
+    if(this.interfaceDhcpEnabledCache.has(interfaceParameter.network) || !interfaceParameter.dhcpEnabled) {
+      process.nextTick(cb);
+    }
+    else {
+      this.interfaceDhcpEnabledCache.add(interfaceParameter.network);
+      this.asynchChildProcess(`netsh interface ip show interfaces "${interfaceParameter.network}"`, (err, std) => {
+        if(-1 === std.indexOf('DHCP/Static IP coexistence         : enabled')) {
+          this.asynchSudoProcess(`netsh interface ip set interface interface="${interfaceParameter.network}" dhcpstaticipcoexistence=enabled`, password, (err, std) => {
+            cb();
+          });
+        }
+        else {
+          cb();
+        }
+      });
+    }
+  }
+  
+  createInterface(interfaceParameter, password, cb) {
+    ++this.pendings;
+    this.asynchSudoProcess(this._getCreateInterfacesCommand(interfaceParameter), password, (err, std) => {
+      ++this.pendings;
+      this.results.push(err);
+      cb();
+    });
+  }
+}
+
+module.exports = LoginCreateInterfaces;

package/project/server/plugin-data/login/plugin_data_LoginDataGet.js

@@ -0,0 +1,88 @@
+
+'use strict';
+
+const OsNetworks = require('../../os/os-networks');
+const OsHardware = require('../../os/os-hardware');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Os = require('os');
+
+
+class LoginDataGet extends PluginBaseMulti {
+  static DHCP_ENABLED = 'DHCP enabled:';
+  static DHCP_ENABLED_LENGTH = LoginDataGet.DHCP_ENABLED.length;
+  static SHOW_IP_ADDRESSES_ADDRESS = 'Address ';
+  static SHOW_IP_ADDRESSES_ADDRESS_LENGTH = LoginDataGet.SHOW_IP_ADDRESSES_ADDRESS.length;
+  
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.expectAsynchResponseSuccess(OsHardware.getCpus());
+    const index = this.expectAsynchResponse();
+    this.getOsNetworks((command, cb) => {
+      this.asynchChildProcess(command, (err, stdout) => {
+        cb(err, stdout);
+      });
+    }, (osNetworks) => {
+      this.asynchResponseSuccess(index, osNetworks);
+    });
+  }
+  
+  getOsNetworks(cbExecute, cb) {
+    const osNetworks = OsNetworks.getArray();
+    if('win32' === Os.platform()) {
+      let pendings = 0;
+      osNetworks.forEach((osNetwork) => {
+        ++pendings;
+        cbExecute(`netsh interface ip show addresses "${osNetwork.name}"`, (err, stdout) => {
+          if(!err) {
+            const lines = stdout.split('\r\n');
+            for(let i = 0; i < lines.length; ++i) {
+              const index = lines[i].indexOf(LoginDataGet.DHCP_ENABLED);
+              if(-1 !== index) {
+                osNetwork.dhcpEnabled = 'Yes' === lines[i].substring(index + LoginDataGet.DHCP_ENABLED_LENGTH).trim();
+                break;
+              }
+            }
+          }
+          if(0 === --pendings) {
+            cb(osNetworks);
+          }
+        });
+        ++pendings;
+        cbExecute(`netsh interface ip show ipaddresses "${osNetwork.name}"`, (err, stdout) => {
+          if(!err) {
+            const addresses = stdout.split('\r\n\r\n');
+            addresses.pop();
+            addresses.forEach((address) => {
+              const addressStartIndex = address.indexOf(LoginDataGet.SHOW_IP_ADDRESSES_ADDRESS) + LoginDataGet.SHOW_IP_ADDRESSES_ADDRESS_LENGTH;
+              if(-1 !== addressStartIndex) {
+                const addressStopIndex = address.indexOf(' ', addressStartIndex);
+                if(-1 !== addressStopIndex) {
+                  const ipAddress = address.substring(addressStartIndex, addressStopIndex);
+                  const dhcpAddress = -1 !== address.indexOf('Address Type       : Dhcp', addressStopIndex);
+                  const foundAddress = osNetwork.addresses.find((osAddress) => {
+                    return osAddress.address === ipAddress;
+                  });
+                  if(undefined !== foundAddress) {
+                    foundAddress.dhcp = dhcpAddress;
+                  }
+                }
+              }
+            });
+          }
+          if(0 === --pendings) {
+            cb(osNetworks);
+          }
+        });
+      });
+    }
+    else { 
+      process.nextTick(cb, osNetworks);
+    }
+  }
+}
+
+
+module.exports = LoginDataGet;

package/project/server/plugin-data/login/plugin_data_LoginDeleteInterfaces.js

@@ -0,0 +1,38 @@
+
+'use strict';
+
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Os = require('os');
+
+
+class LoginDeleteInterfaces extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.DELETE);
+    this.pendings = 0;
+    this.results = [];
+  }
+  
+  onRequest(interfaceParameters, password) {
+    interfaceParameters.forEach((interfaceParameter) => {
+      ++this.pendings;
+      this.asynchSudoProcess(this._getDeleteInterfacesCommand(interfaceParameter), password, (err, std) => {
+        this.results.push(err);
+        if(0 === --this.pendings) {
+          return this.expectAsynchResponseSuccess(this.results);
+        }
+      });
+    });
+  }
+  
+  _getDeleteInterfacesCommand(interfaceParameter) {
+    if('win32' === Os.platform()) {
+      return `netsh interface ip delete address "${interfaceParameter.network}" ${interfaceParameter.address} ${interfaceParameter.netmask}`;
+    }
+    else {
+      return `ifconfig ${interfaceParameter.network} down`;
+    }
+  }
+}
+
+
+module.exports = LoginDeleteInterfaces;

package/project/server/plugin-data/login/plugin_data_LoginGet.js

@@ -0,0 +1,22 @@
+
+'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 LoginGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.asynchReadFileResponse(ActorPathGenerated.getStagingFile());
+    this.asynchReadFileResponse(ActorPathGenerated.getNetworksFile());
+    this.asynchReadFileResponse(ActorPathGenerated.getStagingReport());
+    this.asynchReadFileResponse(ActorPathGenerated.getChosenAddresses());
+  }
+}
+
+
+module.exports = LoginGet;

package/project/server/plugin-data/login/plugin_data_LoginPing.js

@@ -0,0 +1,72 @@
+
+'use strict';
+
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const os = require('os');
+
+
+class LoginPing extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+    this.pendings = 0;
+    this.results = [];
+  }
+  
+  onRequest(chosenAddresses) {
+    this._pingAddresses(chosenAddresses.realAddresses);
+    this._pingAddresses(chosenAddresses.externalAddresses);
+    this._pingAddresses(chosenAddresses.missingAddresses);
+  }
+  
+  _pingAddresses(addresses) {
+    addresses.forEach((address) => {
+      ++this.pendings;
+      this.asynchChildProcess(this._getPingCommand(address.address), (err, stdout) => {
+        this.results.push([address.address, 
+          {
+            address: address,
+            err: err,
+            result: this._parseAnswer(stdout)
+          }
+        ]);
+        if(0 === --this.pendings) {
+          return this.expectAsynchResponseSuccess(this.results);          
+        }
+      });
+    });
+  }
+  
+  _getPingCommand(address) {
+    if('win32' === os.platform()) {
+      return `ping ${address}  -n 1 -w 1`;
+    }
+    else {
+      return `ping ${address} -c 1 -W 1`;
+    }
+  }
+  
+  _parseAnswer(stdout) {
+    if('win32' === os.platform()) {
+      const resp = this._getLine(6, stdout).trim();
+      const expectedResult = 'Packets: Sent = 1, Received = 1';
+      return resp.startsWith(expectedResult);
+    }
+    else {
+      const expectedResult = '1 packets transmitted, 1 received';
+      return this._getLine(5, stdout).startsWith(expectedResult);
+    }
+  }
+  
+  _getLine(line, response) {
+    let currentLine = 0;
+    let indexStart = 0;
+    let indexStop = response.indexOf('\n');
+    while(++currentLine < line && indexStart < response.length) {
+      indexStart = indexStop + 1;
+      indexStop = response.indexOf('\n', indexStart);
+    }
+    return response.substring(indexStart, indexStop);
+  }
+}
+
+module.exports = LoginPing;

package/project/server/plugin-data/login/plugin_data_LoginReposGet.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class LoginReposGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    const index = this.expectAsynchResponse();
+    return this.asynchResponseSuccess(index, []);
+  }
+}
+
+module.exports = PluginBaseMulti;