@selfcommunity/api-services 0.1.4 → 0.1.5

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

@@ -0,0 +1,660 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.FeedObjectApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class FeedObjectApiClient {
+  static getAllFeedObjects(type) {
+    return _client.default.request({
+      url: _Endpoints.default.FeedObjectList.url({
+        type
+      }),
+      method: _Endpoints.default.FeedObjectList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve feed objects (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve feed objects.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getUncommentedFeedObjects(type) {
+    return _client.default.request({
+      url: _Endpoints.default.FeedObjectsUncommented.url({
+        type
+      }),
+      method: _Endpoints.default.FeedObjectsUncommented.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve uncommented feed object (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve uncommented feed object.');
+      return Promise.reject(error);
+    });
+  }
+
+  static searchFeedObject(type) {
+    return _client.default.request({
+      url: _Endpoints.default.SearchFeedObject.url({
+        type
+      }),
+      method: _Endpoints.default.SearchFeedObject.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve feed object (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve feed object.');
+      return Promise.reject(error);
+    });
+  }
+
+  static createFeedObject(type) {
+    return _client.default.request({
+      url: _Endpoints.default.CreateFeedObject.url({
+        type
+      }),
+      method: _Endpoints.default.CreateFeedObject.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 getSpecificFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.FeedObject.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.FeedObject.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve feed object (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve feed object.');
+      return Promise.reject(error);
+    });
+  }
+
+  static updateFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.UpdateFeedObject.url({
+        id,
+        type
+      }),
+      method: _Endpoints.default.UpdateFeedObject.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 deleteFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.DeleteFeedObject.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.DeleteFeedObject.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 feedObjectContributorsList(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.FeedObjectContributorsList.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.FeedObjectContributorsList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve feed object contributors (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve feed object contributors.');
+      return Promise.reject(error);
+    });
+  }
+
+  static feedObjectSharesList(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.FeedObjectSharesList.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.FeedObjectSharesList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve feed object shares (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve feed object shares.');
+      return Promise.reject(error);
+    });
+  }
+
+  static feedObjectUserSharesList(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.FeedObjectUserSharesList.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.FeedObjectUserSharesList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve feed object users shares (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve feed object users shares.');
+      return Promise.reject(error);
+    });
+  }
+
+  static restoreFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.RestoreFeedObject.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.RestoreFeedObject.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 relatedFeedObjects(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.RelatedFeedObjects.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.RelatedFeedObjects.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve related feed objects (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve related feed objects.');
+      return Promise.reject(error);
+    });
+  }
+
+  static voteFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.Vote.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.Vote.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 feedObjectVotes(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.VotesList.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.VotesList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve feed object votes (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve feed object votes.');
+      return Promise.reject(error);
+    });
+  }
+
+  static feedObjectPollVote(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.PollVote.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.PollVote.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 feedObjectPollVotesList(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.PollVotesList.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.PollVotesList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve poll votes (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve poll votes.');
+      return Promise.reject(error);
+    });
+  }
+
+  static followFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.FollowContribution.url({
+        id
+      }),
+      method: _Endpoints.default.FollowContribution.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to perform follow action (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to perform follow action.');
+      return Promise.reject(error);
+    });
+  }
+
+  static feedObjectFollowingList(type) {
+    return _client.default.request({
+      url: _Endpoints.default.FeedObjectFollowingList.url({
+        type
+      }),
+      method: _Endpoints.default.FeedObjectFollowingList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve feed object followings (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve feed object followings.');
+      return Promise.reject(error);
+    });
+  }
+
+  static checkIfFollowingFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.CheckIfFollowingFeedObject.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.CheckIfFollowingFeedObject.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 suspendFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.UserSuspendContributionNotification.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.UserSuspendContributionNotification.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 checkIfSuspendedFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.UserCheckContributionNotificationSuspended.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.UserCheckContributionNotificationSuspended.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 feedObjectSuspendedList(type) {
+    return _client.default.request({
+      url: _Endpoints.default.UserListContributionNotificationSuspended.url({
+        type
+      }),
+      method: _Endpoints.default.UserListContributionNotificationSuspended.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve suspended feed objects (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve suspended feed objects.');
+      return Promise.reject(error);
+    });
+  }
+
+  static flagFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.Flag.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.Flag.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 feedObjectFlagStatus(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.FlagStatus.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.FlagStatus.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve status (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve status.');
+      return Promise.reject(error);
+    });
+  }
+
+  static feedObjectFlagList(type) {
+    return _client.default.request({
+      url: _Endpoints.default.FeedObjectFlagList.url({
+        type
+      }),
+      method: _Endpoints.default.FeedObjectFlagList.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve flagged feed objects (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve flagged feed objects.');
+      return Promise.reject(error);
+    });
+  }
+
+  static hideFeedObject(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.HideFeedObject.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.HideFeedObject.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 feedObjectHideStatus(type, id) {
+    return _client.default.request({
+      url: _Endpoints.default.FeedObjectHideStatus.url({
+        type,
+        id
+      }),
+      method: _Endpoints.default.FeedObjectHideStatus.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve status (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve status.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.FeedObjectApiClient = FeedObjectApiClient;
+
+class FeedObjectService {
+  static async getAllFeedObjects(type) {
+    return FeedObjectApiClient.getAllFeedObjects(type);
+  }
+
+  static async getUncommentedFeedObjects(type) {
+    return FeedObjectApiClient.getUncommentedFeedObjects(type);
+  }
+
+  static async searchFeedObject(type) {
+    return FeedObjectApiClient.searchFeedObject(type);
+  }
+
+  static async createFeedObject(type) {
+    return FeedObjectApiClient.createFeedObject(type);
+  }
+
+  static async getSpecificFeedObject(type, id) {
+    return FeedObjectApiClient.getSpecificFeedObject(type, id);
+  }
+
+  static async updateFeedObject(type, id) {
+    return FeedObjectApiClient.updateFeedObject(type, id);
+  }
+
+  static async deleteFeedObject(type, id) {
+    return FeedObjectApiClient.deleteFeedObject(type, id);
+  }
+
+  static async feedObjectContributorsList(type, id) {
+    return FeedObjectApiClient.feedObjectContributorsList(type, id);
+  }
+
+  static async feedObjectSharesList(type, id) {
+    return FeedObjectApiClient.feedObjectSharesList(type, id);
+  }
+
+  static async feedObjectUserSharesList(type, id) {
+    return FeedObjectApiClient.feedObjectUserSharesList(type, id);
+  }
+
+  static async restoreFeedObject(type, id) {
+    return FeedObjectApiClient.restoreFeedObject(type, id);
+  }
+
+  static async relatedFeedObjects(type, id) {
+    return FeedObjectApiClient.relatedFeedObjects(type, id);
+  }
+
+  static async voteFeedObject(type, id) {
+    return FeedObjectApiClient.voteFeedObject(type, id);
+  }
+
+  static async feedObjectVotes(type, id) {
+    return FeedObjectApiClient.feedObjectVotes(type, id);
+  }
+
+  static async feedObjectPollVote(type, id) {
+    return FeedObjectApiClient.feedObjectPollVote(type, id);
+  }
+
+  static async feedObjectPollVotesList(type, id) {
+    return FeedObjectApiClient.feedObjectPollVotesList(type, id);
+  }
+
+  static async followFeedObject(type, id) {
+    return FeedObjectApiClient.followFeedObject(type, id);
+  }
+
+  static async feedObjectFollowingList(type) {
+    return FeedObjectApiClient.feedObjectFollowingList(type);
+  }
+
+  static async checkIfFollowingFeedObject(type, id) {
+    return FeedObjectApiClient.checkIfFollowingFeedObject(type, id);
+  }
+
+  static async suspendFeedObject(type, id) {
+    return FeedObjectApiClient.suspendFeedObject(type, id);
+  }
+
+  static async checkIfSuspendedFeedObject(type, id) {
+    return FeedObjectApiClient.checkIfSuspendedFeedObject(type, id);
+  }
+
+  static async feedObjectSuspendedList(type) {
+    return FeedObjectApiClient.feedObjectSuspendedList(type);
+  }
+
+  static async flagFeedObject(type, id) {
+    return FeedObjectApiClient.flagFeedObject(type, id);
+  }
+
+  static async feedObjectFlagList(type) {
+    return FeedObjectApiClient.feedObjectFlagList(type);
+  }
+
+  static async feedObjectFlagStatus(type, id) {
+    return FeedObjectApiClient.feedObjectFlagStatus(type, id);
+  }
+
+  static async hideFeedObject(type, id) {
+    return FeedObjectApiClient.hideFeedObject(type, id);
+  }
+
+  static async feedObjectHideStatus(type, id) {
+    return FeedObjectApiClient.feedObjectHideStatus(type, id);
+  }
+
+}
+
+exports.default = FeedObjectService;