@selfcommunity/api-services 0.1.4 → 0.1.5

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

@@ -0,0 +1,209 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.NotificationApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class NotificationApiClient {
+  static listUserNotification() {
+    return _client.default.request({
+      url: _Endpoints.default.UserNotificationList.url({}),
+      method: _Endpoints.default.UserNotificationList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve results (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve results.');
+      return Promise.reject(error);
+    });
+  }
+
+  static markReadNotification() {
+    return _client.default.request({
+      url: _Endpoints.default.UserMarkReadNotification.url({}),
+      method: _Endpoints.default.UserMarkReadNotification.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 getUnseenNotification() {
+    return _client.default.request({
+      url: _Endpoints.default.UserUnseenNotificationCount.url({}),
+      method: _Endpoints.default.UserUnseenNotificationCount.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve results (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve results.');
+      return Promise.reject(error);
+    });
+  }
+
+  static createCustomNotification() {
+    return _client.default.request({
+      url: _Endpoints.default.CreateCustomNotification.url({}),
+      method: _Endpoints.default.CreateCustomNotification.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 listBroadcastMessages() {
+    return _client.default.request({
+      url: _Endpoints.default.BroadcastMessagesList.url({}),
+      method: _Endpoints.default.BroadcastMessagesList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve results (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve results.');
+      return Promise.reject(error);
+    });
+  }
+
+  static listBroadcastMessagesUnseenCount() {
+    return _client.default.request({
+      url: _Endpoints.default.BroadcastMessagesUnseenCount.url({}),
+      method: _Endpoints.default.BroadcastMessagesUnseenCount.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve results  (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve results.');
+      return Promise.reject(error);
+    });
+  }
+
+  static listBroadcastMessagesUndisposedCount() {
+    return _client.default.request({
+      url: _Endpoints.default.BroadcastMessagesUndisposedCount.url({}),
+      method: _Endpoints.default.BroadcastMessagesUndisposedCount.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve results (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve results.');
+      return Promise.reject(error);
+    });
+  }
+
+  static markReadBroadcastMessages() {
+    return _client.default.request({
+      url: _Endpoints.default.BroadcastMessagesMarkRead.url({}),
+      method: _Endpoints.default.BroadcastMessagesMarkRead.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 disposeBroadcastMessages() {
+    return _client.default.request({
+      url: _Endpoints.default.BroadcastMessagesDispose.url({}),
+      method: _Endpoints.default.BroadcastMessagesDispose.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve results  (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve results.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.NotificationApiClient = NotificationApiClient;
+
+class NotificationService {
+  static async listUserNotification() {
+    return NotificationApiClient.listUserNotification();
+  }
+
+  static async markReadNotification() {
+    return NotificationApiClient.markReadNotification();
+  }
+
+  static async getUnseenNotification() {
+    return NotificationApiClient.getUnseenNotification();
+  }
+
+  static async createCustomNotification() {
+    return NotificationApiClient.createCustomNotification();
+  }
+
+  static async listBroadcastMessages() {
+    return NotificationApiClient.listBroadcastMessages();
+  }
+
+  static async listBroadcastMessagesUnseenCount() {
+    return NotificationApiClient.listBroadcastMessagesUnseenCount();
+  }
+
+  static async listBroadcastMessagesUndisposedCount() {
+    return NotificationApiClient.listBroadcastMessagesUndisposedCount();
+  }
+
+  static async disposeBroadcastMessages() {
+    return NotificationApiClient.disposeBroadcastMessages();
+  }
+
+  static async markReadBroadcastMessages() {
+    return NotificationApiClient.markReadBroadcastMessages();
+  }
+
+}
+
+exports.default = NotificationService;

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

@@ -0,0 +1,236 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.PrivateMessageApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class PrivateMessageApiClient {
+  static getAllSnippets() {
+    return _client.default.request({
+      url: _Endpoints.default.GetSnippets.url({}),
+      method: _Endpoints.default.GetSnippets.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve results (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve results.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getAThread() {
+    return _client.default.request({
+      url: _Endpoints.default.GetAThread.url({}),
+      method: _Endpoints.default.GetAThread.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve thread (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve thread.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getASingleMessage(id) {
+    return _client.default.request({
+      url: _Endpoints.default.GetASingleMessage.url({
+        id
+      }),
+      method: _Endpoints.default.GetASingleMessage.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve message (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve message.');
+      return Promise.reject(error);
+    });
+  }
+
+  static sendAMessage() {
+    return _client.default.request({
+      url: _Endpoints.default.SendMessage.url({}),
+      method: _Endpoints.default.SendMessage.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 deleteAMessage(id) {
+    return _client.default.request({
+      url: _Endpoints.default.DeleteASingleMessage.url({
+        id
+      }),
+      method: _Endpoints.default.DeleteASingleMessage.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 deleteAThread(id) {
+    return _client.default.request({
+      url: _Endpoints.default.DeleteAThread.url({
+        id
+      }),
+      method: _Endpoints.default.DeleteAThread.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 perform action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static uploadMedia() {
+    return _client.default.request({
+      url: _Endpoints.default.PrivateMessageUploadMedia.url({}),
+      method: _Endpoints.default.PrivateMessageUploadMedia.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 uploadThumbnail() {
+    return _client.default.request({
+      url: _Endpoints.default.PrivateMessageUploadThumbnail.url({}),
+      method: _Endpoints.default.PrivateMessageUploadThumbnail.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 uploadMediaInChunks() {
+    return _client.default.request({
+      url: _Endpoints.default.PrivateMessageUploadMediaInChunks.url({}),
+      method: _Endpoints.default.PrivateMessageUploadMediaInChunks.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 chunkUploadDone() {
+    return _client.default.request({
+      url: _Endpoints.default.PrivateMessageChunkUploadDone.url({}),
+      method: _Endpoints.default.PrivateMessageChunkUploadDone.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);
+    });
+  }
+
+}
+
+exports.PrivateMessageApiClient = PrivateMessageApiClient;
+
+class PrivateMessageService {
+  static async getAllSnippets() {
+    return PrivateMessageApiClient.getAllSnippets();
+  }
+
+  static async getAThread() {
+    return PrivateMessageApiClient.getAThread();
+  }
+
+  static async getASingleMessage(id) {
+    return PrivateMessageApiClient.getASingleMessage(id);
+  }
+
+  static async sendAMessage() {
+    return PrivateMessageApiClient.sendAMessage();
+  }
+
+  static async deleteAMessage(id) {
+    return PrivateMessageApiClient.deleteAMessage(id);
+  }
+
+  static async deleteAThread(id) {
+    return PrivateMessageApiClient.deleteAThread(id);
+  }
+
+  static async uploadMedia() {
+    return PrivateMessageApiClient.uploadMedia();
+  }
+
+  static async uploadThumbnail() {
+    return PrivateMessageApiClient.uploadThumbnail();
+  }
+
+  static async uploadMediaInChunks() {
+    return PrivateMessageApiClient.uploadMediaInChunks();
+  }
+
+  static async chunkUploadDone() {
+    return PrivateMessageApiClient.chunkUploadDone();
+  }
+
+}
+
+exports.default = PrivateMessageService;

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

@@ -0,0 +1,83 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.ScoreApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ScoreApiClient {
+  static getAllScores() {
+    return _client.default.request({
+      url: _Endpoints.default.ScoresList.url({}),
+      method: _Endpoints.default.ScoresList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve scores (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve scores.');
+      return Promise.reject(error);
+    });
+  }
+
+  static searchScore() {
+    return _client.default.request({
+      url: _Endpoints.default.SearchScore.url({}),
+      method: _Endpoints.default.SearchScore.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve score (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve score.');
+      return Promise.reject(error);
+    });
+  }
+
+  static addScore() {
+    return _client.default.request({
+      url: _Endpoints.default.AddScore.url({}),
+      method: _Endpoints.default.AddScore.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);
+    });
+  }
+
+}
+
+exports.ScoreApiClient = ScoreApiClient;
+
+class ScoreService {
+  static async getAllScores() {
+    return ScoreApiClient.getAllScores();
+  }
+
+  static async searchScore() {
+    return ScoreApiClient.searchScore();
+  }
+
+  static async addScore() {
+    return ScoreApiClient.addScore();
+  }
+
+}
+
+exports.default = ScoreService;

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

@@ -0,0 +1,62 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.SSOApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class SSOApiClient {
+  static SignIn() {
+    return _client.default.request({
+      url: _Endpoints.default.SignIn.url({}),
+      method: _Endpoints.default.SignIn.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 SignUp() {
+    return _client.default.request({
+      url: _Endpoints.default.SignUp.url({}),
+      method: _Endpoints.default.SignUp.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);
+    });
+  }
+
+}
+
+exports.SSOApiClient = SSOApiClient;
+
+class SSOService {
+  static async SignIn() {
+    return SSOApiClient.SignIn();
+  }
+
+  static async SignUp() {
+    return SSOApiClient.SignUp();
+  }
+
+}
+
+exports.default = SSOService;

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

@@ -0,0 +1,104 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.SuggestionApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class SuggestionApiClient {
+  static getCategorySuggestion() {
+    return _client.default.request({
+      url: _Endpoints.default.CategoriesSuggestion.url({}),
+      method: _Endpoints.default.CategoriesSuggestion.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve categories (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve categories.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getIncubatorSuggestion() {
+    return _client.default.request({
+      url: _Endpoints.default.GetIncubatorSuggestion.url({}),
+      method: _Endpoints.default.GetIncubatorSuggestion.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 getPollSuggestion() {
+    return _client.default.request({
+      url: _Endpoints.default.PollSuggestion.url({}),
+      method: _Endpoints.default.PollSuggestion.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve polls (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve polls.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getUserSuggestion() {
+    return _client.default.request({
+      url: _Endpoints.default.UserSuggestion.url({}),
+      method: _Endpoints.default.UserSuggestion.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve users (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve users.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.SuggestionApiClient = SuggestionApiClient;
+
+class SuggestionService {
+  static async getCategorySuggestion() {
+    return SuggestionApiClient.getCategorySuggestion();
+  }
+
+  static async getIncubatorSuggestion() {
+    return SuggestionApiClient.getIncubatorSuggestion();
+  }
+
+  static async getPollSuggestion() {
+    return SuggestionApiClient.getPollSuggestion();
+  }
+
+  static async getUserSuggestion() {
+    return SuggestionApiClient.getUserSuggestion();
+  }
+
+}
+
+exports.default = SuggestionService;