@mmontes11/iot-client/dist/services/observationService.js

ES6 client library for consuming IoT server REST API

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.MeasurementService = exports.EventService = exports.ObservationService = undefined;

var _regenerator = require("babel-runtime/regenerator");

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require("babel-runtime/helpers/asyncToGenerator");

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require("babel-runtime/helpers/inherits");

var _inherits3 = _interopRequireDefault(_inherits2);

var _service = require("./service");

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

var ObservationService = function (_Service) {
  (0, _inherits3.default)(ObservationService, _Service);

  function ObservationService() {
    (0, _classCallCheck3.default)(this, ObservationService);
    return (0, _possibleConstructorReturn3.default)(this, (ObservationService.__proto__ || (0, _getPrototypeOf2.default)(ObservationService)).apply(this, arguments));
  }

  (0, _createClass3.default)(ObservationService, [{
    key: "create",
    value: function () {
      var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(observation) {
        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                return _context.abrupt("return", this.post(undefined, observation));

              case 1:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function create(_x) {
        return _ref.apply(this, arguments);
      }

      return create;
    }()
  }, {
    key: "getData",
    value: function () {
      var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(query) {
        var options;
        return _regenerator2.default.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                options = {
                  query: query,
                  auth: true
                };
                return _context2.abrupt("return", this.get(undefined, options));

              case 2:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function getData(_x2) {
        return _ref2.apply(this, arguments);
      }

      return getData;
    }()
  }, {
    key: "getStats",
    value: function () {
      var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(query) {
        var options;
        return _regenerator2.default.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                options = {
                  query: query,
                  auth: true
                };
                return _context3.abrupt("return", this.get("stats", options));

              case 2:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function getStats(_x3) {
        return _ref3.apply(this, arguments);
      }

      return getStats;
    }()
  }, {
    key: "getStatsByType",
    value: function () {
      var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(type) {
        return _regenerator2.default.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                return _context4.abrupt("return", this.getStats({ type: type }));

              case 1:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this);
      }));

      function getStatsByType(_x4) {
        return _ref4.apply(this, arguments);
      }

      return getStatsByType;
    }()
  }, {
    key: "getStatsByThing",
    value: function () {
      var _ref5 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5(thing) {
        return _regenerator2.default.wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                return _context5.abrupt("return", this.getStats({ thing: thing }));

              case 1:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5, this);
      }));

      function getStatsByThing(_x5) {
        return _ref5.apply(this, arguments);
      }

      return getStatsByThing;
    }()
  }, {
    key: "getStatsByDateRange",
    value: function () {
      var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6(startDate, endDate) {
        return _regenerator2.default.wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                return _context6.abrupt("return", this.getStats({ startDate: startDate, endDate: endDate }));

              case 1:
              case "end":
                return _context6.stop();
            }
          }
        }, _callee6, this);
      }));

      function getStatsByDateRange(_x6, _x7) {
        return _ref6.apply(this, arguments);
      }

      return getStatsByDateRange;
    }()
  }, {
    key: "getStatsByTimePeriod",
    value: function () {
      var _ref7 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee7(timePeriod) {
        return _regenerator2.default.wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                return _context7.abrupt("return", this.getStats({ timePeriod: timePeriod }));

              case 1:
              case "end":
                return _context7.stop();
            }
          }
        }, _callee7, this);
      }));

      function getStatsByTimePeriod(_x8) {
        return _ref7.apply(this, arguments);
      }

      return getStatsByTimePeriod;
    }()
  }, {
    key: "getStatsByCoordinates",
    value: function () {
      var _ref8 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee8(longitude, latitude, maxDistance) {
        return _regenerator2.default.wrap(function _callee8$(_context8) {
          while (1) {
            switch (_context8.prev = _context8.next) {
              case 0:
                return _context8.abrupt("return", this.getStats({ longitude: longitude, latitude: latitude, maxDistance: maxDistance }));

              case 1:
              case "end":
                return _context8.stop();
            }
          }
        }, _callee8, this);
      }));

      function getStatsByCoordinates(_x9, _x10, _x11) {
        return _ref8.apply(this, arguments);
      }

      return getStatsByCoordinates;
    }()
  }, {
    key: "getStatsByAddress",
    value: function () {
      var _ref9 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee9(address, maxDistance) {
        return _regenerator2.default.wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                return _context9.abrupt("return", this.getStats({ address: address, maxDistance: maxDistance }));

              case 1:
              case "end":
                return _context9.stop();
            }
          }
        }, _callee9, this);
      }));

      function getStatsByAddress(_x12, _x13) {
        return _ref9.apply(this, arguments);
      }

      return getStatsByAddress;
    }()
  }, {
    key: "getLast",
    value: function () {
      var _ref10 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee10(thing, type) {
        var options;
        return _regenerator2.default.wrap(function _callee10$(_context10) {
          while (1) {
            switch (_context10.prev = _context10.next) {
              case 0:
                options = {
                  query: {
                    thing: thing,
                    type: type
                  },
                  auth: true
                };
                return _context10.abrupt("return", this.get("last", options));

              case 2:
              case "end":
                return _context10.stop();
            }
          }
        }, _callee10, this);
      }));

      function getLast(_x14, _x15) {
        return _ref10.apply(this, arguments);
      }

      return getLast;
    }()
  }, {
    key: "getTypes",
    value: function () {
      var _ref11 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee11() {
        var options;
        return _regenerator2.default.wrap(function _callee11$(_context11) {
          while (1) {
            switch (_context11.prev = _context11.next) {
              case 0:
                options = { auth: true };
                return _context11.abrupt("return", this.get("types", options));

              case 2:
              case "end":
                return _context11.stop();
            }
          }
        }, _callee11, this);
      }));

      function getTypes() {
        return _ref11.apply(this, arguments);
      }

      return getTypes;
    }()
  }]);
  return ObservationService;
}(_service.Service);

var EventService = function (_ObservationService) {
  (0, _inherits3.default)(EventService, _ObservationService);

  function EventService(client) {
    (0, _classCallCheck3.default)(this, EventService);
    return (0, _possibleConstructorReturn3.default)(this, (EventService.__proto__ || (0, _getPrototypeOf2.default)(EventService)).call(this, client, "event"));
  }

  return EventService;
}(ObservationService);

var MeasurementService = function (_ObservationService2) {
  (0, _inherits3.default)(MeasurementService, _ObservationService2);

  function MeasurementService(client) {
    (0, _classCallCheck3.default)(this, MeasurementService);
    return (0, _possibleConstructorReturn3.default)(this, (MeasurementService.__proto__ || (0, _getPrototypeOf2.default)(MeasurementService)).call(this, client, "measurement"));
  }

  return MeasurementService;
}(ObservationService);

exports.ObservationService = ObservationService;
exports.EventService = EventService;
exports.MeasurementService = MeasurementService;