@selfcommunity/api-services 0.1.4 → 0.1.5

package/lib/esm/services/incubator/index.js

@@ -0,0 +1,175 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.IncubatorApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class IncubatorApiClient {
+  static getAllIncubators() {
+    return _client.default.request({
+      url: _Endpoints.default.GetAllIncubators.url({}),
+      method: _Endpoints.default.GetAllIncubators.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve incubators (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve incubators.');
+      return Promise.reject(error);
+    });
+  }
+
+  static searchIncubators() {
+    return _client.default.request({
+      url: _Endpoints.default.SearchIncubators.url({}),
+      method: _Endpoints.default.SearchIncubators.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve incubators (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve incubators.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getSpecificIncubator(id) {
+    return _client.default.request({
+      url: _Endpoints.default.GetASpecificIncubator.url({
+        id
+      }),
+      method: _Endpoints.default.GetASpecificIncubator.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve incubator (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve incubator.');
+      return Promise.reject(error);
+    });
+  }
+
+  static createIncubator() {
+    return _client.default.request({
+      url: _Endpoints.default.CreateAnIncubator.url({}),
+      method: _Endpoints.default.CreateAnIncubator.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to perform action (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getIncubatorSubscribers(id) {
+    return _client.default.request({
+      url: _Endpoints.default.GetIncubatorSubscribers.url({
+        id
+      }),
+      method: _Endpoints.default.GetIncubatorSubscribers.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve incubator subscribers (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve incubator subscribers.');
+      return Promise.reject(error);
+    });
+  }
+
+  static subscribeToIncubator(id) {
+    return _client.default.request({
+      url: _Endpoints.default.SubscribeToIncubator.url({
+        id
+      }),
+      method: _Endpoints.default.SubscribeToIncubator.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to perform action (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static checkIncubatorSubscription(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CheckIncubatorSubscription.url({
+        id
+      }),
+      method: _Endpoints.default.CheckIncubatorSubscription.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve result (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve result.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.IncubatorApiClient = IncubatorApiClient;
+
+class IncubatorService {
+  static async getAllIncubators() {
+    return IncubatorApiClient.getAllIncubators();
+  }
+
+  static async searchIncubators() {
+    return IncubatorApiClient.searchIncubators();
+  }
+
+  static async getSpecificIncubator(id) {
+    return IncubatorApiClient.getSpecificIncubator(id);
+  }
+
+  static async createIncubator() {
+    return IncubatorApiClient.createIncubator();
+  }
+
+  static async getIncubatorSubscribers(id) {
+    return IncubatorApiClient.getIncubatorSubscribers(id);
+  }
+
+  static async subscribeToIncubator(id) {
+    return IncubatorApiClient.subscribeToIncubator(id);
+  }
+
+  static async checkIncubatorSubscription(id) {
+    return IncubatorApiClient.checkIncubatorSubscription(id);
+  }
+
+}
+
+exports.default = IncubatorService;

package/lib/esm/services/insight/index.js

@@ -0,0 +1,146 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.InsightApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class InsightApiClient {
+  static getBestContributionInsight() {
+    return _client.default.request({
+      url: _Endpoints.default.InsightBestContribution.url({}),
+      method: _Endpoints.default.InsightBestContribution.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve contribution insights (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve contribution insights.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getBestEmbedInsight() {
+    return _client.default.request({
+      url: _Endpoints.default.InsightBestEmbed.url({}),
+      method: _Endpoints.default.InsightBestEmbed.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve embed insights. (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve embed insights.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getBestUsersInsight() {
+    return _client.default.request({
+      url: _Endpoints.default.InsightBestUser.url({}),
+      method: _Endpoints.default.InsightBestUser.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve user insight (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve user insight.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getContributionsInsightCounters() {
+    return _client.default.request({
+      url: _Endpoints.default.InsightContributionCounter.url({}),
+      method: _Endpoints.default.InsightContributionCounter.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve contribution counters (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve contributions counters.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getEmbedsInsightCounters() {
+    return _client.default.request({
+      url: _Endpoints.default.InsightEmbedCounter.url({}),
+      method: _Endpoints.default.InsightEmbedCounter.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve embeds counters (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve embeds counters.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getUsersInsightCounters() {
+    return _client.default.request({
+      url: _Endpoints.default.InsightUserCounter.url({}),
+      method: _Endpoints.default.InsightUserCounter.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve users counters (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve users counters.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.InsightApiClient = InsightApiClient;
+
+class InsightService {
+  static async getBestContributionInsight() {
+    return InsightApiClient.getBestContributionInsight();
+  }
+
+  static async getBestEmbedInsight() {
+    return InsightApiClient.getBestEmbedInsight();
+  }
+
+  static async getBestUsersInsight() {
+    return InsightApiClient.getBestUsersInsight();
+  }
+
+  static async getContributionsInsightCounters() {
+    return InsightApiClient.getContributionsInsightCounters();
+  }
+
+  static async getEmbedsInsightCounters() {
+    return InsightApiClient.getEmbedsInsightCounters();
+  }
+
+  static async getUsersInsightCounters() {
+    return InsightApiClient.getUsersInsightCounters();
+  }
+
+}
+
+exports.default = InsightService;

package/lib/esm/services/legal_page/index.js

@@ -0,0 +1,152 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.LegalPageApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class LegalPageApiClient {
+  static getLegalPages() {
+    return _client.default.request({
+      url: _Endpoints.default.GetLegalPages.url({}),
+      method: _Endpoints.default.GetLegalPages.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve legal pages (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve legal pages.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getSpecificLegalPage(id) {
+    return _client.default.request({
+      url: _Endpoints.default.LegalPage.url({
+        id
+      }),
+      method: _Endpoints.default.LegalPage.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve legal page (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve legal page.');
+      return Promise.reject(error);
+    });
+  }
+
+  static searchLegalPages() {
+    return _client.default.request({
+      url: _Endpoints.default.SearchLegalPages.url({}),
+      method: _Endpoints.default.SearchLegalPages.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve legal pages (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve legal pages.');
+      return Promise.reject(error);
+    });
+  }
+
+  static ackLegalPage(id) {
+    return _client.default.request({
+      url: _Endpoints.default.AckLegalPage.url({
+        id
+      }),
+      method: _Endpoints.default.AckLegalPage.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to perform action (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getSpecificUserAck(id) {
+    return _client.default.request({
+      url: _Endpoints.default.SpecificUserAck.url({
+        id
+      }),
+      method: _Endpoints.default.SpecificUserAck.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve user ack (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve user ack.');
+      return Promise.reject(error);
+    });
+  }
+
+  static userAckList() {
+    return _client.default.request({
+      url: _Endpoints.default.UserAckList.url({}),
+      method: _Endpoints.default.UserAckList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve user acks (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve user acks.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.LegalPageApiClient = LegalPageApiClient;
+
+class LegalPageService {
+  static async getLegalPages() {
+    return LegalPageApiClient.getLegalPages();
+  }
+
+  static async getSpecificLegalPage(id) {
+    return LegalPageApiClient.getSpecificLegalPage(id);
+  }
+
+  static async searchLegalPages() {
+    return LegalPageApiClient.searchLegalPages();
+  }
+
+  static async ackLegalPage(id) {
+    return LegalPageApiClient.ackLegalPage(id);
+  }
+
+  static async getSpecificUserAck(id) {
+    return LegalPageApiClient.getSpecificUserAck(id);
+  }
+
+  static async userAckList() {
+    return LegalPageApiClient.userAckList();
+  }
+
+}
+
+exports.default = LegalPageService;

package/lib/esm/services/locality/index.js

@@ -0,0 +1,62 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.LocalityApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class LocalityApiClient {
+  static getLocalities() {
+    return _client.default.request({
+      url: _Endpoints.default.GetLocalities.url({}),
+      method: _Endpoints.default.GetLocalities.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve localities (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve localities.');
+      return Promise.reject(error);
+    });
+  }
+
+  static searchLocalities() {
+    return _client.default.request({
+      url: _Endpoints.default.ComposerLocalitySearch.url({}),
+      method: _Endpoints.default.ComposerLocalitySearch.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve localities (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve localities.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.LocalityApiClient = LocalityApiClient;
+
+class LocalityService {
+  static async getLocalities() {
+    return LocalityApiClient.getLocalities();
+  }
+
+  static async searchLocalities() {
+    return LocalityApiClient.searchLocalities();
+  }
+
+}
+
+exports.default = LocalityService;