nexmo/lib/Events.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _index = require("./index");

var _index2 = _interopRequireDefault(_index);

var _Utils = require("./Utils");

var _Utils2 = _interopRequireDefault(_Utils);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Provides access to the `events` resource.
 */
var Events = function () {
  _createClass(Events, null, [{
    key: "PATH",

    /**
     * The path to the `events` resource.
     */
    get: function get() {
      return "/v0.1/conversations/{conversation_uuid}/events";
    }

    /**
     * Creates a new Events instance.
     *
     * @param {Credentials} creds - Credentials used when interacting with the Nexmo API.
     * @param {Object} options - additional options for the class.
     */

  }]);

  function Events(creds, options) {
    _classCallCheck(this, Events);

    this.creds = creds;
    this.options = options;
  }

  /**
   * Creates an event in a conversation.
   *
   * @param {string} conversationId - The unique identifier for the conversation
   * @param {Object} params - Parameters used when adding an event to the conversation. See https://developer.nexmo.com/api/conversation#createEvent for more information.
   * @param {function} callback - function to be called when the request completes.
   */


  _createClass(Events, [{
    key: "create",
    value: function create(conversationId, params, callback) {
      params = JSON.stringify(params);

      var config = {
        host: this.options.host || "api.nexmo.com",
        path: Events.PATH.replace("{conversation_uuid}", conversationId),
        method: "POST",
        body: params,
        headers: {
          "Content-Type": "application/json",
          Authorization: "Bearer " + this.creds.generateJwt()
        }
      };
      this.options.httpClient.request(config, callback);
    }

    /**
     * Get an existing event.
     *
     * @param {string} conversationId - The unique identifier for the conversation
     * @param {string|object} query - The unique identifier for the event to retrieve
     *               or a set of filter parameters for the query. For more information
     *               see https://developer.nexmo.com/api/conversation#getEvents
     * @param {function} callback - function to be called when the request completes.
     */

  }, {
    key: "get",
    value: function get(conversationId, query, callback) {
      var config = {
        host: this.options.host || "api.nexmo.com",
        path: _Utils2.default.createPathWithQuery(Events.PATH.replace("{conversation_uuid}", conversationId), query),
        method: "GET",
        body: undefined,
        headers: {
          "Content-Type": "application/json",
          Authorization: "Bearer " + this.creds.generateJwt()
        }
      };
      this.options.httpClient.request(config, callback);
    }

    /**
     * Get next page of events for a conversation.
     *
     * @param {object} response - The response from a paginated events list
     *               see https://ea.developer.nexmo.com/api/conversation#getEvents
     * @param {function} callback - function to be called when the request completes.
     */

  }, {
    key: "next",
    value: function next(response, callback) {
      if (response._links.next) {
        var conversationId = response._links.next.href.match(/CON-[^/]*/g);
        this.get(conversationId, _Utils2.default.getQuery(response._links.next.href), callback);
      } else {
        var error = new Error("The response doesn't have a next page.");
        callback(error, null);
      }
    }

    /**
     * Get previous page of events for a conversation.
     *
     * @param {object} response - The response from a paginated events list
     *               see https://ea.developer.nexmo.com/api/conversation#getEvents
     * @param {function} callback - function to be called when the request completes.
     */

  }, {
    key: "prev",
    value: function prev(response, callback) {
      if (response._links.prev) {
        var conversationId = response._links.prev.href.match(/CON-[^/]*/g);
        this.get(conversationId, _Utils2.default.getQuery(response._links.prev.href), callback);
      } else {
        var error = new Error("The response doesn't have a previous page.");
        callback(error, null);
      }
    }

    /**
     * Deleta an existing event.
     *
     * @param {string} conversationId- The unique identifier for the conversation to delete the event from.
     * @param {string} eventId - The unique identifier for the event to delete.
     * @param {function} callback - function to be called when the request completes.
     */

  }, {
    key: "delete",
    value: function _delete(conversationId, eventId, callback) {
      var config = {
        host: this.options.host || "api.nexmo.com",
        path: Events.PATH.replace("{conversation_uuid}", conversationId) + "/" + eventId,
        method: "DELETE",
        headers: {
          "Content-Type": "application/json",
          Authorization: "Bearer " + this.creds.generateJwt()
        }
      };

      this.options.httpClient.request(config, callback);
    }
  }]);

  return Events;
}();

exports.default = Events;
module.exports = exports["default"];
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Events.js"],"names":["Events","creds","options","conversationId","params","callback","JSON","stringify","config","host","path","PATH","replace","method","body","headers","Authorization","generateJwt","httpClient","request","query","createPathWithQuery","undefined","response","_links","next","href","match","get","getQuery","error","Error","prev","eventId"],"mappings":"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","file":"Events.js","sourcesContent":["import nexmo from \"./index\";\n\nimport Utils from \"./Utils\";\n\n/**\n * Provides access to the `events` resource.\n */\nclass Events {\n  /**\n   * The path to the `events` resource.\n   */\n  static get PATH() {\n    return \"/v0.1/conversations/{conversation_uuid}/events\";\n  }\n\n  /**\n   * Creates a new Events instance.\n   *\n   * @param {Credentials} creds - Credentials used when interacting with the Nexmo API.\n   * @param {Object} options - additional options for the class.\n   */\n  constructor(creds, options) {\n    this.creds = creds;\n    this.options = options;\n  }\n\n  /**\n   * Creates an event in a conversation.\n   *\n   * @param {string} conversationId - The unique identifier for the conversation\n   * @param {Object} params - Parameters used when adding an event to the conversation. See https://developer.nexmo.com/api/conversation#createEvent for more information.\n   * @param {function} callback - function to be called when the request completes.\n   */\n  create(conversationId, params, callback) {\n    params = JSON.stringify(params);\n\n    var config = {\n      host: this.options.host || \"api.nexmo.com\",\n      path: Events.PATH.replace(\"{conversation_uuid}\", conversationId),\n      method: \"POST\",\n      body: params,\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${this.creds.generateJwt()}`\n      }\n    };\n    this.options.httpClient.request(config, callback);\n  }\n\n  /**\n   * Get an existing event.\n   *\n   * @param {string} conversationId - The unique identifier for the conversation\n   * @param {string|object} query - The unique identifier for the event to retrieve\n   *               or a set of filter parameters for the query. For more information\n   *               see https://developer.nexmo.com/api/conversation#getEvents\n   * @param {function} callback - function to be called when the request completes.\n   */\n\n  get(conversationId, query, callback) {\n    var config = {\n      host: this.options.host || \"api.nexmo.com\",\n      path: Utils.createPathWithQuery(\n        Events.PATH.replace(\"{conversation_uuid}\", conversationId),\n        query\n      ),\n      method: \"GET\",\n      body: undefined,\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${this.creds.generateJwt()}`\n      }\n    };\n    this.options.httpClient.request(config, callback);\n  }\n\n  /**\n   * Get next page of events for a conversation.\n   *\n   * @param {object} response - The response from a paginated events list\n   *               see https://ea.developer.nexmo.com/api/conversation#getEvents\n   * @param {function} callback - function to be called when the request completes.\n   */\n  next(response, callback) {\n    if (response._links.next) {\n      const conversationId = response._links.next.href.match(/CON-[^/]*/g);\n      this.get(\n        conversationId,\n        Utils.getQuery(response._links.next.href),\n        callback\n      );\n    } else {\n      const error = new Error(\"The response doesn't have a next page.\");\n      callback(error, null);\n    }\n  }\n\n  /**\n   * Get previous page of events for a conversation.\n   *\n   * @param {object} response - The response from a paginated events list\n   *               see https://ea.developer.nexmo.com/api/conversation#getEvents\n   * @param {function} callback - function to be called when the request completes.\n   */\n  prev(response, callback) {\n    if (response._links.prev) {\n      const conversationId = response._links.prev.href.match(/CON-[^/]*/g);\n      this.get(\n        conversationId,\n        Utils.getQuery(response._links.prev.href),\n        callback\n      );\n    } else {\n      const error = new Error(\"The response doesn't have a previous page.\");\n      callback(error, null);\n    }\n  }\n\n  /**\n   * Deleta an existing event.\n   *\n   * @param {string} conversationId- The unique identifier for the conversation to delete the event from.\n   * @param {string} eventId - The unique identifier for the event to delete.\n   * @param {function} callback - function to be called when the request completes.\n   */\n  delete(conversationId, eventId, callback) {\n    var config = {\n      host: this.options.host || \"api.nexmo.com\",\n      path: `${Events.PATH.replace(\n        \"{conversation_uuid}\",\n        conversationId\n      )}/${eventId}`,\n      method: \"DELETE\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${this.creds.generateJwt()}`\n      }\n    };\n\n    this.options.httpClient.request(config, callback);\n  }\n}\n\nexport default Events;\n"]}