viewpoint/dist/ews-response.js

the exchange email API for nodejs module

var EWSFoldersResponse, EWSItemsResponse, EWSResponse, EWSRootFolderResponse, EWSSyncResponse, Folder, Folders, Item, Items, Message, Mixin, NAMESPACES, ResponseParser, RootFolder, Types,
  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  hasProp = {}.hasOwnProperty;

NAMESPACES = require('./ews-ns').NAMESPACES;

Item = require('./types/item');

Message = require('./types/message');

Folder = require('./types/folder');

Mixin = require('mixto');

Types = {
  Item: Item,
  Message: Message,
  Folder: Folder
};

RootFolder = (function(superClass) {
  extend(RootFolder, superClass);

  function RootFolder(rootFolderNode) {
    this.rootFolderNode = rootFolderNode;
  }

  RootFolder.prototype.totalItemsInView = function() {
    return parseInt(this.rootFolderNode.attrVal('TotalItemsInView'));
  };

  RootFolder.prototype.includesLastItemInRange = function() {
    return this.rootFolderNode.attrVal('IncludesLastItemInRange') === 'true';
  };

  RootFolder.prototype.items = function() {
    var Constructor, childNode, i, itemsNode, len, ref, resItems;
    itemsNode = this.rootFolderNode.get('t:Items', NAMESPACES);
    resItems = [];
    ref = itemsNode.childNodes();
    for (i = 0, len = ref.length; i < len; i++) {
      childNode = ref[i];
      if ((Constructor = Types[childNode.name()]) != null) {
        resItems.push(new Constructor(childNode));
      }
    }
    return resItems;
  };

  RootFolder.prototype.folders = function() {
    var childNode, foldersNode, i, len, ref, results;
    foldersNode = this.rootFolderNode.get('t:Folders', NAMESPACES);
    ref = foldersNode.childNodes();
    results = [];
    for (i = 0, len = ref.length; i < len; i++) {
      childNode = ref[i];
      results.push(new Folder(childNode));
    }
    return results;
  };

  return RootFolder;

})(Mixin);

Items = (function(superClass) {
  extend(Items, superClass);

  function Items(itemsNode1) {
    this.itemsNode = itemsNode1;
  }

  Items.prototype.items = function() {
    var Constructor, childNode, i, len, ref, resItems;
    resItems = [];
    ref = this.itemsNode.childNodes();
    for (i = 0, len = ref.length; i < len; i++) {
      childNode = ref[i];
      if ((Constructor = Types[childNode.name()]) != null) {
        resItems.push(new Constructor(childNode));
      }
    }
    return resItems;
  };

  return Items;

})(Mixin);

Folders = (function() {
  function Folders(foldersNode1) {
    this.foldersNode = foldersNode1;
  }

  Folders.prototype.folders = function() {
    var childNode, i, len, ref, results;
    ref = this.foldersNode.childNodes();
    results = [];
    for (i = 0, len = ref.length; i < len; i++) {
      childNode = ref[i];
      results.push(new Folder(childNode));
    }
    return results;
  };

  return Folders;

})();

ResponseParser = (function(superClass) {
  var ResponseMsgs;

  extend(ResponseParser, superClass);

  function ResponseParser() {
    return ResponseParser.__super__.constructor.apply(this, arguments);
  }

  ResponseParser.prototype.parseResponse = function() {
    var _msgNode, path;
    path = '/soap:Envelope/soap:Body/*/m:ResponseMessages';
    this.resMsgsNode = this.doc.get(path, NAMESPACES);
    _msgNode = this.resMsgsNode.child(0);
    this.isSuccess = _msgNode.attrVal('ResponseClass') === 'Success';
    if (!this.isSuccess) {
      this.responseCode = _msgNode.get('m:ResponseCode', NAMESPACES);
      this.messageText = _msgNode.get('m:MessageText', NAMESPACES);
    }
    return this.resMsgNode = _msgNode;
  };

  ResponseMsgs = {
    RootFolder: RootFolder,
    Items: Items,
    Folders: Folders
  };

  ResponseParser.prototype._responseNode = function(resMsg) {
    var Constructor, i, len, node, nodeName, ref;
    ref = resMsg.childNodes();
    for (i = 0, len = ref.length; i < len; i++) {
      node = ref[i];
      nodeName = node.name();
      if ((Constructor = ResponseMsgs[nodeName]) != null) {
        return new Constructor(node);
      }
    }
  };

  ResponseParser.prototype.response = function() {
    return this._responseNode(this.resMsgsNode.child(0));
  };

  ResponseParser.prototype.responses = function() {
    var i, len, ref, resNode, results;
    ref = this.resMsgsNode.childNodes();
    results = [];
    for (i = 0, len = ref.length; i < len; i++) {
      resNode = ref[i];
      results.push(this._responseNode(resNode));
    }
    return results;
  };

  return ResponseParser;

})(Mixin);

EWSResponse = (function() {
  ResponseParser.includeInto(EWSResponse);

  function EWSResponse(doc) {
    this.doc = doc;
    this.parseResponse();
  }

  return EWSResponse;

})();

EWSRootFolderResponse = (function() {
  ResponseParser.includeInto(EWSRootFolderResponse);

  RootFolder.includeInto(EWSRootFolderResponse);

  function EWSRootFolderResponse(doc) {
    this.doc = doc;
    this.parseResponse();
    RootFolder.call(this, this.resMsgNode.get('m:RootFolder', NAMESPACES));
  }

  return EWSRootFolderResponse;

})();

EWSItemsResponse = (function() {
  ResponseParser.includeInto(EWSItemsResponse);

  Items.includeInto(EWSItemsResponse);

  function EWSItemsResponse(doc) {
    this.doc = doc;
    this.parseResponse();
    Items.call(this, this.resMsgNode.get('m:Items', NAMESPACES));
  }

  return EWSItemsResponse;

})();

EWSFoldersResponse = (function() {
  ResponseParser.includeInto(EWSFoldersResponse);

  function EWSFoldersResponse(doc) {
    var node, nodes;
    this.doc = doc;
    this.parseResponse();
    nodes = this.resMsgsNode.childNodes();
    this.foldersList = (function() {
      var i, len, results;
      results = [];
      for (i = 0, len = nodes.length; i < len; i++) {
        node = nodes[i];
        results.push(new Folders(node.get('m:Folders', NAMESPACES)));
      }
      return results;
    })();
  }

  EWSFoldersResponse.prototype.folders = function() {
    var i, len, node, ref, res;
    res = [];
    ref = this.foldersList;
    for (i = 0, len = ref.length; i < len; i++) {
      node = ref[i];
      res = res.concat(node.folders());
    }
    return res;
  };

  return EWSFoldersResponse;

})();

EWSSyncResponse = (function() {
  ResponseParser.includeInto(EWSSyncResponse);

  function EWSSyncResponse(doc) {
    this.doc = doc;
    this.parseResponse();
    this.changesNode = this.resMsgNode.get('m:Changes', NAMESPACES);
  }

  EWSSyncResponse.prototype.syncState = function() {
    return this.resMsgNode.get('m:SyncState', NAMESPACES).text();
  };

  EWSSyncResponse.prototype.includesLastItemInRange = function() {
    return this.resMsgNode.get('m:IncludesLastItemInRange', NAMESPACES).text() === 'true';
  };

  EWSSyncResponse.prototype._getChildItems = function(path) {
    var Constructor, createNode, createNodes, i, items, len, node;
    createNodes = this.changesNode.find(path, NAMESPACES);
    items = [];
    for (i = 0, len = createNodes.length; i < len; i++) {
      createNode = createNodes[i];
      node = createNode.child(0);
      if ((Constructor = Types[node.name()]) != null) {
        items.push(new Constructor(node));
      }
    }
    return items;
  };

  EWSSyncResponse.prototype.creates = function() {
    return this._getChildItems('t:Create');
  };

  EWSSyncResponse.prototype.updates = function() {
    return this._getChildItems('t:Update');
  };

  EWSSyncResponse.prototype.deletes = function() {
    return this._getChildItems('t:Delete');
  };

  return EWSSyncResponse;

})();

module.exports = {
  EWSResponse: EWSResponse,
  EWSRootFolderResponse: EWSRootFolderResponse,
  EWSItemsResponse: EWSItemsResponse,
  EWSFoldersResponse: EWSFoldersResponse,
  EWSSyncResponse: EWSSyncResponse
};