@selfcommunity/api-services 0.1.4 → 0.1.5

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

@@ -0,0 +1,219 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.LoyaltyApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class LoyaltyApiClient {
+  static getPrizes() {
+    return _client.default.request({
+      url: _Endpoints.default.GetPrizes.url({}),
+      method: _Endpoints.default.GetPrizes.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve prizes (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve prizes.');
+      return Promise.reject(error);
+    });
+  }
+
+  static createPrize() {
+    return _client.default.request({
+      url: _Endpoints.default.CreatePrize.url({}),
+      method: _Endpoints.default.CreatePrize.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 getSpecificPrize(id) {
+    return _client.default.request({
+      url: _Endpoints.default.GetSpecificPrize.url({
+        id
+      }),
+      method: _Endpoints.default.GetSpecificPrize.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 updatePrize(id) {
+    return _client.default.request({
+      url: _Endpoints.default.UpdatePrize.url({
+        id
+      }),
+      method: _Endpoints.default.UpdatePrize.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 patchPrize(id) {
+    return _client.default.request({
+      url: _Endpoints.default.PatchPrize.url({
+        id
+      }),
+      method: _Endpoints.default.PatchPrize.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 getPrizeRequests() {
+    return _client.default.request({
+      url: _Endpoints.default.GetPrizeRequests.url({}),
+      method: _Endpoints.default.GetPrizeRequests.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve prize requests (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve prize requests.');
+      return Promise.reject(error);
+    });
+  }
+
+  static createPrizeRequest() {
+    return _client.default.request({
+      url: _Endpoints.default.CreatePrizeRequest.url({}),
+      method: _Endpoints.default.CreatePrizeRequest.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 getSpecificPrizeRequest(id) {
+    return _client.default.request({
+      url: _Endpoints.default.GetSpecificPrizeRequest.url({
+        id
+      }),
+      method: _Endpoints.default.GetSpecificPrizeRequest.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve prize request (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve prize request.');
+      return Promise.reject(error);
+    });
+  }
+
+  static patchPrizeRequest(id) {
+    return _client.default.request({
+      url: _Endpoints.default.PatchPrizeRequest.url({
+        id
+      }),
+      method: _Endpoints.default.PatchPrizeRequest.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.LoyaltyApiClient = LoyaltyApiClient;
+
+class LoyaltyService {
+  static async getPrizes() {
+    return LoyaltyApiClient.getPrizes();
+  }
+
+  static async createPrize() {
+    return LoyaltyApiClient.createPrize();
+  }
+
+  static async getSpecificPrize(id) {
+    return LoyaltyApiClient.getSpecificPrize(id);
+  }
+
+  static async updatePrize(id) {
+    return LoyaltyApiClient.updatePrize(id);
+  }
+
+  static async patchPrize(id) {
+    return LoyaltyApiClient.patchPrize(id);
+  }
+
+  static async getPrizeRequests() {
+    return LoyaltyApiClient.getPrizeRequests();
+  }
+
+  static async createPrizeRequest() {
+    return LoyaltyApiClient.createPrizeRequest();
+  }
+
+  static async getSpecificPrizeRequest(id) {
+    return LoyaltyApiClient.getSpecificPrizeRequest(id);
+  }
+
+  static async patchPrizeRequest(id) {
+    return LoyaltyApiClient.patchPrizeRequest(id);
+  }
+
+}
+
+exports.default = LoyaltyService;

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

@@ -0,0 +1,175 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.MediaApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class MediaApiClient {
+  static chunkUploadMedia() {
+    return _client.default.request({
+      url: _Endpoints.default.ComposerChunkUploadMedia.url({}),
+      method: _Endpoints.default.ComposerChunkUploadMedia.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 chunkUploadMediaComplete() {
+    return _client.default.request({
+      url: _Endpoints.default.ComposerChunkUploadMediaComplete.url({}),
+      method: _Endpoints.default.ComposerChunkUploadMediaComplete.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 createMedia() {
+    return _client.default.request({
+      url: _Endpoints.default.ComposerMediaCreate.url({}),
+      method: _Endpoints.default.ComposerMediaCreate.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 clickMedia(id) {
+    return _client.default.request({
+      url: _Endpoints.default.MediaClickTracker.url({
+        id
+      }),
+      method: _Endpoints.default.MediaClickTracker.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 getSpecificMedia(id) {
+    return _client.default.request({
+      url: _Endpoints.default.GetMedia.url({
+        id
+      }),
+      method: _Endpoints.default.GetMedia.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve media (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve media.');
+      return Promise.reject(error);
+    });
+  }
+
+  static updateMedia(id) {
+    return _client.default.request({
+      url: _Endpoints.default.UpdateMedia.url({
+        id
+      }),
+      method: _Endpoints.default.UpdateMedia.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 deleteMedia(id) {
+    return _client.default.request({
+      url: _Endpoints.default.DeleteMedia.url({
+        id
+      }),
+      method: _Endpoints.default.DeleteMedia.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.MediaApiClient = MediaApiClient;
+
+class MediaService {
+  static async chunkUploadMedia() {
+    return MediaApiClient.chunkUploadMedia();
+  }
+
+  static async chunkUploadMediaComplete() {
+    return MediaApiClient.chunkUploadMediaComplete();
+  }
+
+  static async createMedia() {
+    return MediaApiClient.createMedia();
+  }
+
+  static async clickMedia(id) {
+    return MediaApiClient.clickMedia(id);
+  }
+
+  static async getSpecificMedia(id) {
+    return MediaApiClient.getSpecificMedia(id);
+  }
+
+  static async updateMedia(id) {
+    return MediaApiClient.updateMedia(id);
+  }
+
+  static async deleteMedia(id) {
+    return MediaApiClient.deleteMedia(id);
+  }
+
+}
+
+exports.default = MediaService;

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

@@ -0,0 +1,156 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.ModerationApiClient = void 0;
+
+var _client = _interopRequireDefault(require("../../client"));
+
+var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ModerationApiClient {
+  static getUsersForModeration() {
+    return _client.default.request({
+      url: _Endpoints.default.UsersForModeration.url({}),
+      method: _Endpoints.default.UsersForModeration.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);
+    });
+  }
+
+  static moderateASpecificUser(id) {
+    return _client.default.request({
+      url: _Endpoints.default.ModerateUser.url({
+        id
+      }),
+      method: _Endpoints.default.ModerateUser.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 getAllFlaggedContributions() {
+    return _client.default.request({
+      url: _Endpoints.default.FlaggedContributions.url({}),
+      method: _Endpoints.default.FlaggedContributions.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve contributions (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve contributions.');
+      return Promise.reject(error);
+    });
+  }
+
+  static getSpecificContributionFlag(id, contribution_type) {
+    return _client.default.request({
+      url: _Endpoints.default.FlagsForSpecificContribution.url({
+        id,
+        contribution_type
+      }),
+      method: _Endpoints.default.FlagsForSpecificContribution.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 moderateAContribution(id) {
+    return _client.default.request({
+      url: _Endpoints.default.ModerateContribution.url({
+        id
+      }),
+      method: _Endpoints.default.ModerateContribution.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 getContributionModerationStatus(id, contribution_type) {
+    return _client.default.request({
+      url: _Endpoints.default.ModerateContributionStatus.url({
+        id,
+        contribution_type
+      }),
+      method: _Endpoints.default.ModerateContributionStatus.method
+    }).then(res => {
+      if (res.status >= 300) {
+        console.log(`Unable to retrieve moderation status for this contribute (Response code: ${res.status}).`);
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res);
+    }).catch(error => {
+      console.log('Unable to retrieve moderation status for this contribute.');
+      return Promise.reject(error);
+    });
+  }
+
+}
+
+exports.ModerationApiClient = ModerationApiClient;
+
+class ModerationService {
+  static async getUsersForModeration() {
+    return ModerationApiClient.getUsersForModeration();
+  }
+
+  static async moderateASpecificUser(id) {
+    return ModerationApiClient.moderateASpecificUser(id);
+  }
+
+  static async getAllFlaggedContributions() {
+    return ModerationApiClient.getAllFlaggedContributions();
+  }
+
+  static async getSpecificContributionFlag(id, contribution_type) {
+    return ModerationApiClient.getSpecificContributionFlag(id, contribution_type);
+  }
+
+  static async moderateAContribution(id) {
+    return ModerationApiClient.moderateAContribution(id);
+  }
+
+  static async getContributionModerationStatus(id, contribution_type) {
+    return ModerationApiClient.getContributionModerationStatus(id, contribution_type);
+  }
+
+}
+
+exports.default = ModerationService;