@selfcommunity/api-services 0.1.4 → 0.1.5

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

@@ -0,0 +1,269 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.CommentApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class CommentApiClient {
+  static getAllComments() {
+    return _client.default.request({
+      url: _Endpoints.default.Comments.url({}),
+      method: _Endpoints.default.Comments.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve comments (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve comments.');
+      return Promise.reject(error);
+    });
+  }
+
+  static createComment() {
+    return _client.default.request({
+      url: _Endpoints.default.NewComment.url({}),
+      method: _Endpoints.default.NewComment.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.data);
+    }).catch(error => {
+      console.log('Unable to perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getASpecificComment(id) {
+    return _client.default.request({
+      url: _Endpoints.default.Comment.url({
+        id
+      }),
+      method: _Endpoints.default.Comment.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.data);
+    }).catch(error => {
+      console.log('Unable to perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static updateComment(id) {
+    return _client.default.request({
+      url: _Endpoints.default.UpdateComment.url({
+        id
+      }),
+      method: _Endpoints.default.UpdateComment.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.data);
+    }).catch(error => {
+      console.log('Unable to perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static deleteComment(id) {
+    return _client.default.request({
+      url: _Endpoints.default.DeleteComment.url({
+        id
+      }),
+      method: _Endpoints.default.DeleteComment.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.data);
+    }).catch(error => {
+      console.log('Unable to perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static restoreComment(id) {
+    return _client.default.request({
+      url: _Endpoints.default.RestoreComment.url({
+        id
+      }),
+      method: _Endpoints.default.RestoreComment.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.data);
+    }).catch(error => {
+      console.log('Unable to perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getSpecificCommentVotesList(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CommentVotesList.url({
+        id
+      }),
+      method: _Endpoints.default.CommentVotesList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve votes (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res.data);
+    }).catch(error => {
+      console.log('Unable to retrieve votes.');
+      return Promise.reject(error);
+    });
+  }
+
+  static upvoteComment(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CommentVote.url({
+        id
+      }),
+      method: _Endpoints.default.CommentVote.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.data);
+    }).catch(error => {
+      console.log('Unable to perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getSpecificCommentFlags(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CommentFlagList.url({
+        id
+      }),
+      method: _Endpoints.default.CommentFlagList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve flags list (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res.data);
+    }).catch(error => {
+      console.log('Unable to retrieve flags list.');
+      return Promise.reject(error);
+    });
+  }
+
+  static flagComment(id) {
+    return _client.default.request({
+      url: _Endpoints.default.FlagComment.url({
+        id
+      }),
+      method: _Endpoints.default.FlagComment.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.data);
+    }).catch(error => {
+      console.log('Unable to perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getSpecificCommentFlagStatus(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CommentFlagStatus.url({
+        id
+      }),
+      method: _Endpoints.default.CommentFlagStatus.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve flags status (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res.data);
+    }).catch(error => {
+      console.log('Unable to retrieve flags status.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.CommentApiClient = CommentApiClient;
+
+class CommentService {
+  static async getAllComments() {
+    return CommentApiClient.getAllComments();
+  }
+
+  static async createComment() {
+    return CommentApiClient.createComment();
+  }
+
+  static async getASpecificComment(id) {
+    return CommentApiClient.getASpecificComment(id);
+  }
+
+  static async updateComment(id) {
+    return CommentApiClient.updateComment(id);
+  }
+
+  static async deleteComment(id) {
+    return CommentApiClient.deleteComment(id);
+  }
+
+  static async restoreComment(id) {
+    return CommentApiClient.restoreComment(id);
+  }
+
+  static async getSpecificCommentVotesList(id) {
+    return CommentApiClient.getSpecificCommentVotesList(id);
+  }
+
+  static async upvoteComment(id) {
+    return CommentApiClient.upvoteComment(id);
+  }
+
+  static async getSpecificCommentFlags(id) {
+    return CommentApiClient.getSpecificCommentFlags(id);
+  }
+
+  static async flagComment(id) {
+    return CommentApiClient.flagComment(id);
+  }
+
+  static async getSpecificCommentFlagStatus(id) {
+    return CommentApiClient.getSpecificCommentFlagStatus(id);
+  }
+
+}
+
+exports.default = CommentService;

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

@@ -0,0 +1,85 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.CustomAdvApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class CustomAdvApiClient {
+  static getASpecificCustomAdv(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CustomAdv.url({
+        id
+      }),
+      method: _Endpoints.default.CustomAdv.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve custom adv (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve custom adv.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getAllCustomAdv() {
+    return _client.default.request({
+      url: _Endpoints.default.CustomAdvList.url({}),
+      method: _Endpoints.default.CustomAdvList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve custom advs (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve custom advs.');
+      return Promise.reject(error);
+    });
+  }
+
+  static searchCustomAdv() {
+    return _client.default.request({
+      url: _Endpoints.default.CustomAdvSearch.url({}),
+      method: _Endpoints.default.CustomAdvSearch.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve custom advs (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve custom advs.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.CustomAdvApiClient = CustomAdvApiClient;
+
+class CustomAdvService {
+  static async getASpecificCustomAdv(id) {
+    return CustomAdvApiClient.getASpecificCustomAdv(id);
+  }
+
+  static async getAllCustomAdv() {
+    return CustomAdvApiClient.getAllCustomAdv();
+  }
+
+  static async searchCustomAdv() {
+    return CustomAdvApiClient.searchCustomAdv();
+  }
+
+}
+
+exports.default = CustomAdvService;

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

@@ -0,0 +1,85 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.CustomPageApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class CustomPageApiClient {
+  static getASpecificCustomPage(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CustomPage.url({
+        id
+      }),
+      method: _Endpoints.default.CustomPage.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve custom page (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve custom page.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getAllCustomPages() {
+    return _client.default.request({
+      url: _Endpoints.default.GetCustomPages.url({}),
+      method: _Endpoints.default.GetCustomPages.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve custom pages (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve custom pages.');
+      return Promise.reject(error);
+    });
+  }
+
+  static searchCustomPages() {
+    return _client.default.request({
+      url: _Endpoints.default.CustomPageSearch.url({}),
+      method: _Endpoints.default.CustomPageSearch.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve custom pages (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve custom pages.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.CustomPageApiClient = CustomPageApiClient;
+
+class CustomPageService {
+  static async getASpecificCustomPage(id) {
+    return CustomPageApiClient.getASpecificCustomPage(id);
+  }
+
+  static async getAllCustomPages() {
+    return CustomPageApiClient.getAllCustomPages();
+  }
+
+  static async searchCustomPages() {
+    return CustomPageApiClient.searchCustomPages();
+  }
+
+}
+
+exports.default = CustomPageService;

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

@@ -0,0 +1,83 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.DataPortabilityApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class DataPortabilityApiClient {
+  static generateDataPortability() {
+    return _client.default.request({
+      url: _Endpoints.default.GenerateDataPortability.url({}),
+      method: _Endpoints.default.GenerateDataPortability.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to generate data (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to generate data.');
+      return Promise.reject(error);
+    });
+  }
+
+  static downloadDataPortability() {
+    return _client.default.request({
+      url: _Endpoints.default.DataPortabilityDownload.url({}),
+      method: _Endpoints.default.DataPortabilityDownload.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to download data (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to download data.');
+      return Promise.reject(error);
+    });
+  }
+
+  static dataPortabilityStatus() {
+    return _client.default.request({
+      url: _Endpoints.default.DataPortabilityStatus.url({}),
+      method: _Endpoints.default.DataPortabilityStatus.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve data status (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve data status.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.DataPortabilityApiClient = DataPortabilityApiClient;
+
+class DataPortabilityService {
+  static async generateDataPortability() {
+    return DataPortabilityApiClient.generateDataPortability();
+  }
+
+  static async downloadDataPortability() {
+    return DataPortabilityApiClient.downloadDataPortability();
+  }
+
+  static async dataPortabilityStatus() {
+    return DataPortabilityApiClient.dataPortabilityStatus();
+  }
+
+}
+
+exports.default = DataPortabilityService;

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

@@ -0,0 +1,85 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.DynamicPreferenceApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class DynamicPreferenceApiClient {
+  static getASpecificDynamicPreference(id) {
+    return _client.default.request({
+      url: _Endpoints.default.SpecificPreference.url({
+        id
+      }),
+      method: _Endpoints.default.SpecificPreference.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve preference (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve preference.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getAllDynamicPreferences() {
+    return _client.default.request({
+      url: _Endpoints.default.Preferences.url({}),
+      method: _Endpoints.default.Preferences.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve preferences (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve preferences.');
+      return Promise.reject(error);
+    });
+  }
+
+  static searchDynamicPreference() {
+    return _client.default.request({
+      url: _Endpoints.default.PreferenceSearch.url({}),
+      method: _Endpoints.default.PreferenceSearch.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve preferences (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve preferences.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.DynamicPreferenceApiClient = DynamicPreferenceApiClient;
+
+class DynamicPreferenceService {
+  static async getASpecificDynamicPreference(id) {
+    return DynamicPreferenceApiClient.getASpecificDynamicPreference(id);
+  }
+
+  static async getAllDynamicPreferences() {
+    return DynamicPreferenceApiClient.getAllDynamicPreferences();
+  }
+
+  static async searchDynamicPreference() {
+    return DynamicPreferenceApiClient.searchDynamicPreference();
+  }
+
+}
+
+exports.default = DynamicPreferenceService;