invoro/lib/services/FeaturesApi.service.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

require("core-js/modules/es6.array.from");

require("core-js/modules/es6.regexp.to-string");

require("core-js/modules/es7.symbol.async-iterator");

require("core-js/modules/es6.symbol");

require("core-js/modules/web.dom.iterable");

require("core-js/modules/es6.array.iterator");

require("core-js/modules/es6.string.iterator");

require("core-js/modules/es6.set");

require("core-js/modules/es6.string.link");

require("regenerator-runtime/runtime");

require("core-js/modules/es6.promise");

require("core-js/modules/es6.object.to-string");

var _Feature = require("../dataModel/Feature");

var _FeaturesCategory = _interopRequireDefault(require("../dataModel/FeaturesCategory"));

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

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
  return new (P || (P = Promise))(function (resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }

    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }

    function step(result) {
      result.done ? resolve(result.value) : new P(function (resolve) {
        resolve(result.value);
      }).then(fulfilled, rejected);
    }

    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};

var FeaturesApi =
/*#__PURE__*/
function () {
  function FeaturesApi(userIdentifier, h) {
    _classCallCheck(this, FeaturesApi);

    this.userIdentifier = userIdentifier;
    this.h = h;
    this.FEATURES_API = 'https://localhost/api/Features';
    this.headers = {
      "Accept-Encoding": "gzip, deflate, br"
    };

    if (this.userIdentifier != null) {
      this.headers.Authorization = this.userIdentifier;
    }
  }

  _createClass(FeaturesApi, [{
    key: "getFeatures",
    value: function getFeatures() {
      return __awaiter(this, void 0, void 0,
      /*#__PURE__*/
      regeneratorRuntime.mark(function _callee() {
        var response, features, categories;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return this.h(this.FEATURES_API, {
                  headers: this.headers
                });

              case 2:
                response = _context.sent;

                if (response.ok) {
                  _context.next = 5;
                  break;
                }

                throw new Error(response.statusText);

              case 5:
                _context.next = 7;
                return this.GetFeaturesFromResponse(response);

              case 7:
                features = _context.sent;
                categories = this.MapFeaturesDTOtoCategories(features);
                return _context.abrupt("return", categories);

              case 10:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));
    }
  }, {
    key: "GetFeaturesFromResponse",
    value: function GetFeaturesFromResponse(response) {
      return __awaiter(this, void 0, void 0,
      /*#__PURE__*/
      regeneratorRuntime.mark(function _callee2() {
        var responseData, features;
        return regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return response.json();

              case 2:
                responseData = _context2.sent;
                features = this.convertJsonToTypedFeatures(responseData); // Validate DataModel 

                return _context2.abrupt("return", features);

              case 5:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));
    }
  }, {
    key: "convertJsonToTypedFeatures",
    value: function convertJsonToTypedFeatures(featuresAsRawJson) {
      return featuresAsRawJson.map(function (feature) {
        return new _Feature.FeatureDTO(feature.id, feature.name, feature.status, feature.link, feature.categoryName, new Date(feature.creationTime), new Date(feature.lastTimeModified));
      });
    }
  }, {
    key: "MapFeaturesDTOtoCategories",
    value: function MapFeaturesDTOtoCategories(features) {
      var uniqueCategoryNames = this.getUniqueCategoryNames(features);
      var categories = this.MapCategoryToItsFeatures(_toConsumableArray(uniqueCategoryNames), features);
      return categories;
    }
  }, {
    key: "getUniqueCategoryNames",
    value: function getUniqueCategoryNames(features) {
      var categoriesNames = features.map(function (feature) {
        return feature.categoryName;
      });
      var uniqueCategoriesNames = new Set(categoriesNames);
      return uniqueCategoriesNames;
    }
  }, {
    key: "MapCategoryToItsFeatures",
    value: function MapCategoryToItsFeatures(uniqueCategoryNames, features) {
      return uniqueCategoryNames.map(function (categoryName) {
        var categoryFeatures = features.filter(function (feature) {
          return feature.categoryName === categoryName;
        });
        return new _FeaturesCategory.default(categoryName, categoryFeatures);
      });
    }
  }]);

  return FeaturesApi;
}();

exports.default = FeaturesApi;