viewpoint/dist/ews-builder.js

the exchange email API for nodejs module

var Builder, EWSBuilder, NS, _, pascalCase,
  slice = [].slice;

Builder = require('libxmljs-builder');

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

pascalCase = require('./ews-util').pascalCase;

_ = require('underscore');

module.exports = EWSBuilder = (function() {
  var NS_M, NS_T, _buildFolderIds, convertName, parseId, toArray;

  function EWSBuilder() {}

  NS_T = NS.NS_TYPES;

  NS_M = NS.NS_MESSAGES;

  convertName = function(name) {
    return '$' + name;
  };

  EWSBuilder.build = function(bodyCallback) {
    this.builder = new Builder;
    this.builder.defineNS(NS.NAMESPACES);
    return this.builder.rootNS(NS.NS_SOAP, 'Envelope', function(builder) {
      return builder.nodeNS(NS.NS_SOAP, 'Body', bodyCallback);
    });
  };

  EWSBuilder._addTextMethods = function() {
    var names;
    names = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return names.forEach((function(_this) {
      return function(name) {
        return _this[convertName(name)] = function(builder, params) {
          return builder.nodeNS(NS_T, pascalCase(name), params);
        };
      };
    })(this));
  };

  EWSBuilder._addTextMethods('isSubmitted', 'isDraft', 'isFromMe', 'inReplyTo', 'isResend', 'sensitivity', 'importance', 'itemClass', 'subject', 'isRead');

  EWSBuilder._addTimeMethods = function() {
    var names;
    names = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return names.forEach((function(_this) {
      return function(name) {
        return _this[convertName(name)] = function(builder, params) {
          var val;
          val = params instanceof Date ? params.toISOString() : params;
          return builder.nodeNS(NS_T, pascalCase(name), val);
        };
      };
    })(this));
  };

  EWSBuilder._addTimeMethods('dateTimeSent', 'dateTimeCreated');

  EWSBuilder.$body = function(builder, body) {
    var content, params;
    params = {};
    if (_.isString(body)) {
      params.BodyType = 'HTML';
      content = body;
    } else {
      if (body.bodyType != null) {
        params.BodyType = body.bodyType;
      }
      if (body.isTruncated != null) {
        params.IsTruncated = body.isTruncated;
      }
      content = body.content;
    }
    return builder.nodeNS(NS_T, 'Body', params, content);
  };

  EWSBuilder._addTextMethods('name', 'emailAddress', 'bodyType');

  EWSBuilder.$mimeContent = function(builder, params) {
    var attrs, content;
    attrs = {};
    if (Buffer.isBuffer(params)) {
      content = params;
    } else {
      if (params.characterSet != null) {
        attrs.CharacterSet = params.characterSet;
      }
      content = params.content;
    }
    return builder.nodeNS(NS_T, 'MimeContent', attrs, content.toString('base64'));
  };

  parseId = function(param) {
    var res;
    res = {
      Id: param.id
    };
    if (param.changeKey != null) {
      res.ChangeKey = param.changeKey;
    }
    return res;
  };

  EWSBuilder.$itemId = function(builder, params) {
    return builder.nodeNS(NS_T, 'ItemId', parseId(params));
  };

  EWSBuilder.$folderId = function(builder, param) {
    return builder.nodeNS(NS_T, 'FolderId', parseId(param));
  };

  EWSBuilder.$mailbox = function(builder, params) {
    return builder.nodeNS(NS_T, 'Mailbox', (function(_this) {
      return function(builder) {
        if (params.name != null) {
          _this.$name(builder, params.name);
        }
        if (params.emailAddress != null) {
          return _this.$emailAddress(builder, params.emailAddress);
        }
      };
    })(this));
  };

  EWSBuilder._buildMailbox = function(builder, name, params) {
    return builder.nodeNS(NS_T, pascalCase(name), (function(_this) {
      return function(builder) {
        var i, item, len, results;
        if (!Array.isArray(params)) {
          params = [params];
        }
        results = [];
        for (i = 0, len = params.length; i < len; i++) {
          item = params[i];
          results.push(_this.$mailbox(builder, item));
        }
        return results;
      };
    })(this));
  };

  EWSBuilder._addMailboxMethods = function() {
    var names;
    names = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return names.forEach((function(_this) {
      return function(name) {
        return _this[convertName(name)] = function(builder, params) {
          return this._buildMailbox(builder, name, params);
        };
      };
    })(this));
  };

  EWSBuilder._addMailboxMethods('sender', 'toRecipients', 'ccRecipients', 'bccRecipients', 'from');

  EWSBuilder._addTextMethods('contentType', 'contentId', 'contentLocation');

  EWSBuilder.$content = function(builder, params) {
    if (!Buffer.isBuffer(params)) {
      throw new TypeError('params should be Buffer');
    }
    return builder.nodeNS(NS_T, 'Content', params.toString('base64'));
  };

  EWSBuilder.$attachments = function(builder, attachments) {
    if (!Array.isArray(attachments)) {
      attachments = [attachments];
    }
    return builder.nodeNS(NS_T, 'Attachments', (function(_this) {
      return function(builder) {
        var i, item, len, results;
        results = [];
        for (i = 0, len = attachments.length; i < len; i++) {
          item = attachments[i];
          if (item.type === 'item') {
            results.push(_this.$itemAttachment(builder, item));
          } else {
            results.push(_this.$fileAttachment(builder, item));
          }
        }
        return results;
      };
    })(this));
  };

  EWSBuilder.$internetMessageHeader = function(builder, header) {
    var params;
    params = {
      HeaderName: header.headerName
    };
    return builder.nodeNS(NS_T, 'InternetMessageHeader', params, header.headerValue);
  };

  EWSBuilder.$internetMessageHeaders = function(builder, headers) {
    return builder.nodeNS(NS_T, 'InternetMessageHeaders', (function(_this) {
      return function(builder) {
        var header, i, len, results;
        results = [];
        for (i = 0, len = headers.length; i < len; i++) {
          header = headers[i];
          results.push(_this.$internetMessageHeader(builder, header));
        }
        return results;
      };
    })(this));
  };

  EWSBuilder.$baseShape = function(builder, params) {
    return builder.nodeNS(NS_T, 'BaseShape', pascalCase(params));
  };

  EWSBuilder._addTextMethods('includeMimeContent');

  EWSBuilder.$itemShape = function(builder, itemShape) {
    return builder.nodeNS(NS_M, 'ItemShape', (function(_this) {
      return function(builder) {
        var imc;
        if (itemShape.baseShape != null) {
          _this.$baseShape(builder, itemShape.baseShape);
        }
        if ((imc = itemShape.includeMimeContent) != null) {
          _this.$includeMimeContent(builder, imc);
        }
        if (itemShape.bodyType != null) {
          return _this.$bodyType(builder, itemShape.bodyType);
        }
      };
    })(this));
  };

  _buildFolderIds = function(builder, name, folderIds) {
    return builder.nodeNS(NS_M, pascalCase(name), function(builder) {
      var fid, i, len, results;
      if (!Array.isArray(folderIds)) {
        folderIds = [folderIds];
      }
      results = [];
      for (i = 0, len = folderIds.length; i < len; i++) {
        fid = folderIds[i];
        if (fid.type === 'distinguished') {
          results.push(builder.nodeNS(NS_T, 'DistinguishedFolderId', parseId(fid)));
        } else {
          results.push(builder.nodeNS(NS_T, 'FolderId', parseId(fid)));
        }
      }
      return results;
    });
  };

  EWSBuilder._addFolderIdMethods = function() {
    var names;
    names = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return names.forEach((function(_this) {
      return function(name) {
        return _this[convertName(name)] = function(builder, params) {
          return _buildFolderIds(builder, name, params);
        };
      };
    })(this));
  };

  EWSBuilder._addFolderIdMethods('parentFolderIds', 'folderIds', 'savedItemFolderId', 'toFolderId', 'parentFolderId', 'syncFolderId');

  EWSBuilder.$returnNewItemIds = function(builder, param) {
    return builder.nodeNS(NS_M, 'ReturnNewItemIds', param);
  };

  EWSBuilder.$syncState = function(builder, param) {
    return builder.nodeNS(NS_M, 'SyncState', param);
  };

  EWSBuilder.$maxChangesReturned = function(builder, param) {
    return builder.nodeNS(NS_M, 'MaxChangesReturned', param);
  };

  EWSBuilder.$indexedPageItemView = function(builder, viewOpts) {
    var params, ref;
    params = {
      MaxEntriesReturned: viewOpts.maxReturned,
      Offset: viewOpts.offset.toString(),
      BasePoint: (ref = viewOpts.basePoint) != null ? ref : 'Beginning'
    };
    return builder.nodeNS(NS_M, 'IndexedPageItemView', params);
  };

  EWSBuilder.$itemIds = function(builder, itemIds) {
    if (!Array.isArray(itemIds)) {
      itemIds = [itemIds];
    }
    return builder.nodeNS(NS_M, 'ItemIds', (function(_this) {
      return function(builder) {
        var i, iid, len, results;
        results = [];
        for (i = 0, len = itemIds.length; i < len; i++) {
          iid = itemIds[i];
          results.push(_this.$itemId(builder, iid));
        }
        return results;
      };
    })(this));
  };

  EWSBuilder._buildItem = function(builder, name, params) {
    return builder.nodeNS(NS_T, pascalCase(name), (function(_this) {
      return function(builder) {
        var key, param, ref, results;
        results = [];
        for (key in params) {
          param = params[key];
          if (param != null) {
            results.push((ref = _this[convertName(key)]) != null ? ref.call(_this, builder, param) : void 0);
          }
        }
        return results;
      };
    })(this));
  };

  EWSBuilder._addItemMethods = function() {
    var names;
    names = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return names.forEach((function(_this) {
      return function(name) {
        return _this[convertName(name)] = function(builder, params) {
          return this._buildItem(builder, name, params);
        };
      };
    })(this));
  };

  EWSBuilder._addItemMethods('itemAttachment', 'fileAttachment', 'item', 'message');

  EWSBuilder.$items = function(builder, params) {
    if (!Array.isArray(params)) {
      params = [params];
    }
    return builder.nodeNS(NS_M, 'Items', (function(_this) {
      return function(builder) {
        var i, itemInfo, len, results;
        results = [];
        for (i = 0, len = params.length; i < len; i++) {
          itemInfo = params[i];
          results.push(_this.$message(builder, itemInfo));
        }
        return results;
      };
    })(this));
  };

  EWSBuilder.$fieldURI = function(builder, param) {
    return builder.nodeNS(NS_T, 'FieldURI', {
      FieldURI: param
    });
  };

  EWSBuilder.$additionalProperties = function(builder, params) {
    return builder.nodeNS(NS_T, 'AdditionalProperties', (function(_this) {
      return function(builder) {
        var i, info, len, results;
        if (!Array.isArray(params)) {
          params = [params];
        }
        results = [];
        for (i = 0, len = params.length; i < len; i++) {
          info = params[i];
          results.push(_this.$fieldURI(builder, info));
        }
        return results;
      };
    })(this));
  };

  EWSBuilder.$folderShape = function(builder, param) {
    return builder.nodeNS(NS_M, 'FolderShape', (function(_this) {
      return function(builder) {
        var ap;
        _this.$baseShape(builder, param.baseShape);
        if ((ap = param.additionalProperties) != null) {
          return _this.$additionalProperties(builder, ap);
        }
      };
    })(this));
  };

  EWSBuilder._addItemMethods('appendToItemField', 'setItemField', 'deleteItemField', 'setFolderField');

  toArray = function(item) {
    if (Array.isArray(item)) {
      return item;
    } else {
      return [item];
    }
  };

  EWSBuilder.$updates = function(builder, param) {
    var appendFields, deleteFields, setFields, setFolderFields;
    appendFields = param.appendFields, setFields = param.setFields, deleteFields = param.deleteFields, setFolderFields = param.setFolderFields;
    return builder.nodeNS(NS_T, 'Updates', (function(_this) {
      return function(builder) {
        var field, i, j, k, l, len, len1, len2, len3, results;
        if (appendFields) {
          appendFields = toArray(appendFields);
          for (i = 0, len = appendFields.length; i < len; i++) {
            field = appendFields[i];
            _this.$appendToItemField(builder, field);
          }
        }
        if (setFields) {
          setFields = toArray(setFields);
          for (j = 0, len1 = setFields.length; j < len1; j++) {
            field = setFields[j];
            _this.$setItemField(builder, field);
          }
        }
        if (deleteFields) {
          deleteFields = toArray(deleteFields);
          for (k = 0, len2 = deleteFields.length; k < len2; k++) {
            field = deleteFields[k];
            _this.$deleteItemField(builder, field);
          }
        }
        if (setFolderFields) {
          setFolderFields = toArray(setFolderFields);
          results = [];
          for (l = 0, len3 = setFolderFields.length; l < len3; l++) {
            field = setFolderFields[l];
            results.push(_this.$setFolderField(builder, field));
          }
          return results;
        }
      };
    })(this));
  };

  EWSBuilder.$itemChange = function(builder, param) {
    return builder.nodeNS(NS_T, 'ItemChange', (function(_this) {
      return function(builder) {
        _this.$itemId(builder, param.itemId);
        return _this.$updates(builder, param);
      };
    })(this));
  };

  EWSBuilder.$itemChanges = function(builder, params) {
    return builder.nodeNS(NS_M, 'ItemChanges', (function(_this) {
      return function(builder) {
        var change, i, len, results;
        if (!Array.isArray(params)) {
          params = [params];
        }
        results = [];
        for (i = 0, len = params.length; i < len; i++) {
          change = params[i];
          results.push(_this.$itemChange(builder, change));
        }
        return results;
      };
    })(this));
  };

  EWSBuilder.$folderChange = function(builder, param) {
    return builder.nodeNS(NS_T, 'FolderChange', (function(_this) {
      return function(builder) {
        _this.$folderId(builder, param.folderId);
        return _this.$updates(builder, param);
      };
    })(this));
  };

  EWSBuilder.$folderChanges = function(builder, params) {
    return builder.nodeNS(NS_M, 'FolderChanges', (function(_this) {
      return function(builder) {
        var change, i, len, results;
        if (!Array.isArray(params)) {
          params = [params];
        }
        results = [];
        for (i = 0, len = params.length; i < len; i++) {
          change = params[i];
          results.push(_this.$folderChange(builder, change));
        }
        return results;
      };
    })(this));
  };

  EWSBuilder._addTextMethods('folderClass', 'displayName', 'totalCount', 'childFolderCount', 'unreadCount');

  EWSBuilder._addItemMethods('folder');

  EWSBuilder.$folders = function(builder, params) {
    return builder.nodeNS(NS_M, 'Folders', (function(_this) {
      return function(builder) {
        var folderInfo, i, len, results;
        if (!Array.isArray(params)) {
          params = [params];
        }
        results = [];
        for (i = 0, len = params.length; i < len; i++) {
          folderInfo = params[i];
          results.push(_this.$folder(builder, folderInfo));
        }
        return results;
      };
    })(this));
  };

  return EWSBuilder;

})();