roar-sdk/lib/resources/Node.js

Node.js SDK for developing Roar inspectors

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.SecurityZones = exports.payload = undefined;

var _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

var _assign = require('babel-runtime/core-js/object/assign');

var _assign2 = _interopRequireDefault(_assign);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

exports.setTemplate = setTemplate;

var _crypto = require('crypto');

var _crypto2 = _interopRequireDefault(_crypto);

var _toPascalCase = require('to-pascal-case');

var _toPascalCase2 = _interopRequireDefault(_toPascalCase);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var payload = exports.payload = {
  nodes: [],
  relationships: [],
  suggestions: []
};

var currentTemplate = void 0;
function setTemplate(template) {
  currentTemplate = template;
}

var SecurityZones = exports.SecurityZones = {
  PUBLIC: 0,
  PRIVATE: 1,
  parse: function parse(str) {
    if (typeof str === 'string') {
      if (str.match(/public/i)) {
        return SecurityZones.PUBLIC;
      }

      if (str.match(/private/i)) {
        return SecurityZones.PRIVATE;
      }

      throw new Error('Unrecognized zone was specified');
    }

    throw new Error('You must specify a string to be parsed');
  },
  toString: function toString(zone) {
    if (zone === SecurityZones.PUBLIC) {
      return 'Public';
    }

    if (zone === SecurityZones.PRIVATE) {
      return 'Private';
    }

    throw new Error('Unrecognized zone was specified');
  }
};

var Node = function () {
  function Node(data, opts) {
    (0, _classCallCheck3.default)(this, Node);

    this.name = data.name || '';
    this.uniqueCompositeKey = data.uniqueCompositeKey || '';
    this.description = data.description || '';
    this.securityZone = data.securityZone || SecurityZones.PUBLIC;
    this.configuration = data.configuration || {};
    this.configurationHash = data.configurationHash || null;

    Object.defineProperty(this, 'entityId', {
      enumerable: false,
      configurable: false,
      writable: false,
      value: currentTemplate.EntityID
    });

    Object.defineProperty(this, 'templateDataId', {
      enumerable: false,
      configurable: false,
      writable: false,
      value: currentTemplate.TemplateDataID
    });

    Object.defineProperty(this, 'intel', {
      enumerable: false,
      configurable: false,
      writable: false,
      value: {}
    });
  }

  (0, _createClass3.default)(Node, [{
    key: 'getName',
    value: function getName() {
      return this.name;
    }
  }, {
    key: 'setName',
    value: function setName(name) {
      this.name = name;
    }
  }, {
    key: 'getUniqueCompositeKey',
    value: function getUniqueCompositeKey() {
      return this.uniqueCompositeKey;
    }
  }, {
    key: 'setUniqueCompositeKey',
    value: function setUniqueCompositeKey(uniqueCompositeKey) {
      this.uniqueCompositeKey = uniqueCompositeKey;
    }
  }, {
    key: 'getDescription',
    value: function getDescription() {
      return this.description;
    }
  }, {
    key: 'setDescription',
    value: function setDescription(description) {
      this.description = description;
    }
  }, {
    key: 'getSecurityZone',
    value: function getSecurityZone() {
      return this.securityZone;
    }
  }, {
    key: 'setSecurityZone',
    value: function setSecurityZone(zone) {
      if (typeof zone === 'string') {
        if (zone.match(/public/i) || zone.match(/private/i)) {
          this.securityZone = zone.match(/public/i) ? SecurityZones.PUBLIC : SecurityZones.PRIVATE;
        } else {
          throw new Error('Unrecognized zone of ' + zone + ' was specified');
        }
      } else if (typeof zone === 'number') {
        if (zone === SecurityZones.PUBLIC || zone === SecurityZones.PRIVATE) {
          this.securityZone = zone;
        } else {
          throw new Error('Unrecognized zone was specified');
        }
      }
    }
  }, {
    key: 'getConfiguration',
    value: function getConfiguration() {
      return this.configuration;
    }
  }, {
    key: 'setConfiguration',
    value: function setConfiguration(configuration) {
      this.configuration = configuration;
    }
  }, {
    key: 'mergeConfiguration',
    value: function mergeConfiguration(configuration) {
      this.configuration = (0, _assign2.default)(this.configuration, configuration);
    }
  }, {
    key: 'getConfigurationHash',
    value: function getConfigurationHash() {
      return this.configurationHash;
    }
  }, {
    key: 'setConfigurationHash',
    value: function setConfigurationHash(configurationHash) {
      this.configurationHash = configurationHash;
    }
  }, {
    key: 'addIntelField',
    value: function addIntelField(name, value) {
      var newName = '__' + name.split('.').map(function (n) {
        return (0, _toPascalCase2.default)(n);
      }).join('.');
      this.intel[newName] = value;
      return newName;
    }
  }, {
    key: 'appendNode',
    value: function appendNode(node) {
      // add this node type to the configuration
      // {
      // [NodeClass](s): []
      // }
    }
  }, {
    key: 'serialize',
    value: function serialize() {
      this.intel['__._RoarInternal.StartTime'] = global.startTime;
      this.intel['__._RoarInternal.SizeInBytes'] = Buffer.byteLength((0, _stringify2.default)((0, _assign2.default)(this.intel, this.configuration)), 'utf8');

      return {
        EntityID: this.entityId,
        TemplateDataID: this.templateDataId,
        UniqueCompositeKey: this.uniqueCompositeKey,
        NodeClass: this.nodeClass,
        Name: this.name,
        Description: this.description,
        SecurityZone: SecurityZones.toString(this.securityZone),
        details: {
          Configuration: (0, _assign2.default)(this.intel, this.configuration),
          ConfigurationHash: this.configurationHash ? this.configurationHash : _crypto2.default.createHash('sha256').update((0, _stringify2.default)(this.configuration)).digest('hex')
        }
      };
    }
  }]);
  return Node;
}();

exports.default = Node;
;
//# sourceMappingURL=Node.js.map