@selfcommunity/api-services 0.1.4 → 0.1.5

package/lib/esm/index.js

@@ -17,29 +17,166 @@ var _http = require("./utils/http");
 
 exports.formatHttpError = _http.formatHttpError;
 
+var _token = require("./utils/token");
+
+exports.generateJWTToken = _token.generateJWTToken;
+exports.parseJwt = _token.parseJwt;
+
+var _category = _interopRequireWildcard(require("./services/category"));
+
+exports.CategoryService = _category.default;
+exports.CategoryApiClient = _category.CategoryApiClient;
+exports.CategoryApiClientInterface = _category.CategoryApiClientInterface;
+
+var _comment = _interopRequireWildcard(require("./services/comment"));
+
+exports.CommentService = _comment.default;
+exports.CommentApiClient = _comment.CommentApiClient;
+exports.CommentApiClientInterface = _comment.CommentApiClientInterface;
+
+var _custom_adv = _interopRequireWildcard(require("./services/custom_adv"));
+
+exports.CustomAdvService = _custom_adv.default;
+exports.CustomAdvApiClient = _custom_adv.CustomAdvApiClient;
+exports.CustomAdvApiClientInterface = _custom_adv.CustomAdvApiClientInterface;
+
+var _custom_page = _interopRequireWildcard(require("./services/custom_page"));
+
+exports.CustomPageService = _custom_page.default;
+exports.CustomPageApiClient = _custom_page.CustomPageApiClient;
+exports.CustomPageApiClientInterface = _custom_page.CustomPageApiClientInterface;
+
+var _data_portability = _interopRequireWildcard(require("./services/data_portability"));
+
+exports.DataPortabilityService = _data_portability.default;
+exports.DataPortabilityApiClient = _data_portability.DataPortabilityApiClient;
+exports.DataPortabilityApiClientInterface = _data_portability.DataPortabilityApiClientInterface;
+
+var _dynamic_preference = _interopRequireWildcard(require("./services/dynamic_preference"));
+
+exports.DynamicPreferenceService = _dynamic_preference.default;
+exports.DynamicPreferenceApiClient = _dynamic_preference.DynamicPreferenceApiClient;
+exports.DynamicPreferenceApiClientInterface = _dynamic_preference.DynamicPreferenceApiClientInterface;
+
+var _embed = _interopRequireWildcard(require("./services/embed"));
+
+exports.EmbedService = _embed.default;
+exports.EmbedApiClient = _embed.EmbedApiClient;
+exports.EmbedApiClientInterface = _embed.EmbedApiClientInterface;
+
+var _feature = _interopRequireWildcard(require("./services/feature"));
+
+exports.FeatureService = _feature.default;
+exports.FeatureApiClient = _feature.FeatureApiClient;
+exports.FeatureApiClientInterface = _feature.FeatureApiClientInterface;
+
+var _feed = _interopRequireWildcard(require("./services/feed"));
+
+exports.FeedService = _feed.default;
+exports.FeedApiClient = _feed.FeedApiClient;
+exports.FeedApiClientInterface = _feed.FeedApiClientInterface;
+
+var _feed_object = _interopRequireWildcard(require("./services/feed_object"));
+
+exports.FeedObjectService = _feed_object.default;
+exports.FeedObjectApiClient = _feed_object.FeedObjectApiClient;
+exports.FeedObjectApiClientInterface = _feed_object.FeedObjectApiClientInterface;
+
+var _incubator = _interopRequireWildcard(require("./services/incubator"));
+
+exports.IncubatorService = _incubator.default;
+exports.IncubatorApiClient = _incubator.IncubatorApiClient;
+exports.IncubatorApiClientInterface = _incubator.IncubatorApiClientInterface;
+
+var _insight = _interopRequireWildcard(require("./services/insight"));
+
+exports.InsightService = _insight.default;
+exports.InsightApiClient = _insight.InsightApiClient;
+exports.InsightApiClientInterface = _insight.InsightApiClientInterface;
+
+var _legal_page = _interopRequireWildcard(require("./services/legal_page"));
+
+exports.LegalPageService = _legal_page.default;
+exports.LegalPageApiClient = _legal_page.LegalPageApiClient;
+exports.LegalPageApiClientInterface = _legal_page.LegalPageApiClientInterface;
+
+var _locality = _interopRequireWildcard(require("./services/locality"));
+
+exports.LocalityService = _locality.default;
+exports.LocalityApiClient = _locality.LocalityApiClient;
+exports.LocalityApiClientInterface = _locality.LocalityApiClientInterface;
+
+var _loyalty = _interopRequireWildcard(require("./services/loyalty"));
+
+exports.LoyaltyService = _loyalty.default;
+exports.LoyaltyApiClient = _loyalty.LoyaltyApiClient;
+exports.LoyaltyApiClientInterface = _loyalty.LoyaltyApiClientInterface;
+
+var _media = _interopRequireWildcard(require("./services/media"));
+
+exports.MediaService = _media.default;
+exports.MediaApiClient = _media.MediaApiClient;
+exports.MediaApiClientInterface = _media.MediaApiClientInterface;
+
+var _moderation = _interopRequireWildcard(require("./services/moderation"));
+
+exports.ModerationService = _moderation.default;
+exports.ModerationApiClient = _moderation.ModerationApiClient;
+exports.ModerationApiClientInterface = _moderation.ModerationApiClientInterface;
+
+var _notification = _interopRequireWildcard(require("./services/notification"));
+
+exports.NotificationService = _notification.default;
+exports.NotificationApiClient = _notification.NotificationApiClient;
+exports.NotificationApiClientInterface = _notification.NotificationApiClientInterface;
+
 var _preference = _interopRequireWildcard(require("./services/preference"));
 
 exports.PreferenceService = _preference.default;
 exports.PreferenceApiClient = _preference.PreferenceApiClient;
 exports.PreferenceApiClientInterface = _preference.PreferenceApiClientInterface;
 
+var _private_message = _interopRequireWildcard(require("./services/private_message"));
+
+exports.PrivateMessageService = _private_message.default;
+exports.PrivateMessageApiClient = _private_message.PrivateMessageApiClient;
+exports.PrivateMessageApiClientInterface = _private_message.PrivateMessageApiClientInterface;
+
+var _score = _interopRequireWildcard(require("./services/score"));
+
+exports.ScoreService = _score.default;
+exports.ScoreApiClient = _score.ScoreApiClient;
+exports.ScoreApiClientInterface = _score.ScoreApiClientInterface;
+
+var _sso = _interopRequireWildcard(require("./services/sso"));
+
+exports.SSOService = _sso.default;
+exports.SSOApiClient = _sso.SSOApiClient;
+exports.SSOApiClientInterface = _sso.SSOApiClientInterface;
+
+var _suggestion = _interopRequireWildcard(require("./services/suggestion"));
+
+exports.SuggestionService = _suggestion.default;
+exports.SuggestionApiClient = _suggestion.SuggestionApiClient;
+exports.SuggestionApiClientInterface = _suggestion.SuggestionApiClientInterface;
+
+var _tag = _interopRequireWildcard(require("./services/tag"));
+
+exports.TagService = _tag.default;
+exports.TagApiClient = _tag.TagApiClient;
+exports.TagApiClientInterface = _tag.TagApiClientInterface;
+
 var _user = _interopRequireWildcard(require("./services/user"));
 
 exports.UserService = _user.default;
 exports.UserApiClient = _user.UserApiClient;
 exports.UserApiClientInterface = _user.UserApiClientInterface;
 
-var _feature = _interopRequireWildcard(require("./services/feature"));
-
-exports.FeatureService = _feature.default;
-exports.FeatureApiClient = _feature.FeatureApiClient;
-exports.FeatureApiClientInterface = _feature.FeatureApiClientInterface;
-
-var _category = _interopRequireWildcard(require("./services/category"));
+var _webhook = _interopRequireWildcard(require("./services/webhook"));
 
-exports.CategoryService = _category.default;
-exports.CategoryApiClient = _category.CategoryApiClient;
-exports.CategoryApiClientInterface = _category.CategoryApiClientInterface;
+exports.WebhookService = _webhook.default;
+exports.WebhookApiClient = _webhook.WebhookApiClient;
+exports.WebhookApiClientInterface = _webhook.WebhookApiClientInterface;
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 

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

@@ -12,8 +12,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 class CategoryApiClient {
   static getAllCategories() {
     return _client.default.request({
-      url: _Endpoints.default.Category.url({}),
-      method: _Endpoints.default.Category.method
+      url: _Endpoints.default.CategoryList.url({}),
+      method: _Endpoints.default.CategoryList.method
     }).then(res => {
       if (res.status >= 300) {
         console.log(`Unable to retrieve categories (Response code: ${res.status}).`);
@@ -27,12 +27,46 @@ class CategoryApiClient {
     });
   }
 
+  static searchCategory() {
+    return _client.default.request({
+      url: _Endpoints.default.SearchCategory.url({}),
+      method: _Endpoints.default.SearchCategory.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve category (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve category.');
+      return Promise.reject(error);
+    });
+  }
+
+  static createCategory() {
+    return _client.default.request({
+      url: _Endpoints.default.CreateCategory.url({}),
+      method: _Endpoints.default.CreateCategory.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 getSpecificCategory(id) {
     return _client.default.request({
       url: _Endpoints.default.Category.url({
         id
       }),
-      method: _Endpoints.default.User.method
+      method: _Endpoints.default.Category.method
     }).then(res => {
       if (res.status >= 300) {
         console.log(`Unable to retrieve category (Response code: ${res.status}).`);
@@ -46,6 +80,230 @@ class CategoryApiClient {
     });
   }
 
+  static updateASpecificCategory(id) {
+    return _client.default.request({
+      url: _Endpoints.default.UpdateCategory.url({
+        id
+      }),
+      method: _Endpoints.default.UpdateCategory.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 patchASpecificCategory(id) {
+    return _client.default.request({
+      url: _Endpoints.default.PatchCategory.url({
+        id
+      }),
+      method: _Endpoints.default.PatchCategory.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 deleteASpecificCategory(id) {
+    return _client.default.request({
+      url: _Endpoints.default.DeleteCategory.url({
+        id
+      }),
+      method: _Endpoints.default.DeleteCategory.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 getCategoryAudience(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CategoryAudience.url({
+        id
+      }),
+      method: _Endpoints.default.CategoryAudience.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve category audience (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve category audience.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getCategoryFollowers(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CategoryFollowers.url({
+        id
+      }),
+      method: _Endpoints.default.CategoryFollowers.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve category followers (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve category followers.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getCategoryFeed(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CategoryFeed.url({
+        id
+      }),
+      method: _Endpoints.default.CategoryFeed.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve category feed (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve category feed.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getCategoryTrendingFeed(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CategoryTrendingFeed.url({
+        id
+      }),
+      method: _Endpoints.default.CategoryTrendingFeed.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve category trending feed (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve category trending feed.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getCategoryTrendingFollowers(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CategoryTrendingPeople.url({
+        id
+      }),
+      method: _Endpoints.default.CategoryTrendingPeople.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve category followers (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve category followers.');
+      return Promise.reject(error);
+    });
+  }
+
+  static followCategory(id) {
+    return _client.default.request({
+      url: _Endpoints.default.FollowCategory.url({
+        id
+      }),
+      method: _Endpoints.default.FollowCategory.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 checkCategoryIsFollowed(id) {
+    return _client.default.request({
+      url: _Endpoints.default.CheckCategoryIsFollowed.url({
+        id
+      }),
+      method: _Endpoints.default.CheckCategoryIsFollowed.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 getFollowedCategories() {
+    return _client.default.request({
+      url: _Endpoints.default.CategoriesFollowed.url({}),
+      method: _Endpoints.default.CategoriesFollowed.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve categories followed (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve categories followed.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getPopularCategories() {
+    return _client.default.request({
+      url: _Endpoints.default.PopularCategories.url({}),
+      method: _Endpoints.default.PopularCategories.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);
+    });
+  }
+
 }
 
 exports.CategoryApiClient = CategoryApiClient;
@@ -55,10 +313,66 @@ class CategoryService {
     return CategoryApiClient.getAllCategories();
   }
 
+  static async searchCategory() {
+    return CategoryApiClient.searchCategory();
+  }
+
+  static async createCategory() {
+    return CategoryApiClient.createCategory();
+  }
+
   static async getSpecificCategory(id) {
     return CategoryApiClient.getSpecificCategory(id);
   }
 
+  static async updateASpecificCategory(id) {
+    return CategoryApiClient.updateASpecificCategory(id);
+  }
+
+  static async patchASpecificCategory(id) {
+    return CategoryApiClient.patchASpecificCategory(id);
+  }
+
+  static async deleteASpecificCategory(id) {
+    return CategoryApiClient.deleteASpecificCategory(id);
+  }
+
+  static async getCategoryAudience(id) {
+    return CategoryApiClient.getCategoryAudience(id);
+  }
+
+  static async getCategoryFollowers(id) {
+    return CategoryApiClient.getCategoryFollowers(id);
+  }
+
+  static async getCategoryFeed(id) {
+    return CategoryApiClient.getCategoryFeed(id);
+  }
+
+  static async getCategoryTrendingFeed(id) {
+    return CategoryApiClient.getCategoryTrendingFeed(id);
+  }
+
+  static async getCategoryTrendingFollowers(id) {
+    return CategoryApiClient.getCategoryTrendingFollowers(id);
+  }
+
+  static async followCategory(id) {
+    return CategoryApiClient.followCategory(id);
+  }
+
+  static async checkCategoryIsFollowed(id) {
+    return CategoryApiClient.checkCategoryIsFollowed(id);
+  }
+
+  static async getFollowedCategories() {
+    return CategoryApiClient.getFollowedCategories();
+  }
+
+  static async getPopularCategories() {
+    return CategoryApiClient.getPopularCategories();
+  }
+
 }
 
 exports.default = CategoryService;