DEVORTEX-5439 add webhooks api

api/webhooks/dto/subscription-dto.ts

@@ -0,0 +1,18 @@
+import { SubscriptionEvent } from "../params/subscription-event";
+import { SubscriptionRequestHeader } from "../params/subscription-request-header";
+
+interface SubscriptionDto {
+    subscriptionUid: string;
+    subscriptionName: string;
+    subscriptionUrl: string;
+    accountUid: string;
+    enabled: boolean;
+    userUid: string;
+    description: string | null;
+    createdDate: string;
+    requestHeaders: SubscriptionRequestHeader[];
+    events: SubscriptionEvent[];
+    projectUids: string[];
+}
+
+export { SubscriptionDto };

api/webhooks/dto/subscription-secret-dto.ts

@@ -0,0 +1,5 @@
+interface SubscriptionSecretDto {
+    payloadSecret: string;
+}
+
+export { SubscriptionSecretDto };

api/webhooks/dto/subscription-statistics-dto.ts

@@ -0,0 +1,8 @@
+interface SubscriptionStatisticsDto {
+    failEvents: number;
+    pendingEvents: number;
+    sendingEvents: number;
+    successEvents: number;
+}
+
+export { SubscriptionStatisticsDto };

api/webhooks/dto/webhook-event-type.dto.ts

@@ -0,0 +1,7 @@
+class WebhookEventTypeDto {
+    eventType: string;
+    description: string;
+    schema: Record<string, any>;
+}
+
+export { WebhookEventTypeDto };

api/webhooks/index.ts

@@ -0,0 +1,10 @@
+export { SmartlingWebhooksApi } from "./smartling-webhooks-api";
+export { SubscriptionDto } from "./dto/subscription-dto";
+export { SubscriptionSecretDto } from "./dto/subscription-secret-dto";
+export { WebhookEventTypeDto } from "./dto/webhook-event-type.dto";
+export { SubscriptionEvent } from "./params/subscription-event";
+export { CreateSubscriptionParameters } from "./params/create-subscription-parameters";
+export { UpdateSubscriptionParameters } from "./params/update-subscription-parameters";
+export { SubscriptionRequestHeader } from "./params/subscription-request-header";
+export { UpdateSubscriptionSecretParameters } from "./params/update-subscription-secret-parameters";
+export { GetSubscriptionEventsParameters } from "./params/get-subscription-events-parameters";

api/webhooks/params/create-subscription-parameters.ts

@@ -0,0 +1,9 @@
+import { CreateUpdateSubscriptionParameters } from "./create-update-subscription-parameters";
+
+export class CreateSubscriptionParameters extends CreateUpdateSubscriptionParameters {
+    setPayloadSecret(payloadSecret: string) {
+        this.set("payloadSecret", payloadSecret);
+
+        return this;
+    }
+}

api/webhooks/params/create-update-subscription-parameters.ts

@@ -0,0 +1,70 @@
+import { BaseParameters } from "../../parameters";
+import { SmartlingException } from "../../exception";
+import { SubscriptionEvent } from "./subscription-event";
+import { SubscriptionRequestHeader } from "./subscription-request-header";
+
+const MAX_EVENTS_SIZE = 1000;
+const MAX_SUBSCRIPTION_HEADERS_SIZE = 20;
+const MAX_PROJECT_UIDS_SIZE = 10;
+
+export abstract class CreateUpdateSubscriptionParameters extends BaseParameters {
+    constructor(
+        subscriptionName: string,
+        subscriptionUrl: string,
+        events: SubscriptionEvent[]
+    ) {
+        super();
+
+        if (!subscriptionName) {
+            throw new SmartlingException("Subscription name is required.");
+        }
+
+        if (!subscriptionUrl) {
+            throw new SmartlingException("Subscription url is required.");
+        }
+
+        if (!events.length) {
+            throw new SmartlingException("At least one event is required.");
+        }
+
+        if (events.length > MAX_EVENTS_SIZE) {
+            throw new SmartlingException(`The request contains too many events: ${events.length}. Maximum allowed events number is ${MAX_EVENTS_SIZE}.`);
+        }
+
+        this.set("subscriptionName", subscriptionName);
+        this.set("subscriptionUrl", subscriptionUrl);
+        this.set("events", events);
+    }
+
+    setDescription(description: string): this {
+        this.set("description", description);
+
+        return this;
+    }
+
+    setRequestHeaders(requestHeaders: SubscriptionRequestHeader[]) {
+        if (!requestHeaders.length) {
+            throw new SmartlingException("At least one subscription header is required.");
+        }
+
+        if (requestHeaders.length > MAX_SUBSCRIPTION_HEADERS_SIZE) {
+            throw new SmartlingException(`The request contains too many subscription headers: ${requestHeaders.length}. Maximum allowed subscription headers number is ${MAX_SUBSCRIPTION_HEADERS_SIZE}.`);
+        }
+
+        this.set("requestHeaders", requestHeaders);
+        return this;
+    }
+
+    setProjectUids(projectUids: string[]) {
+        if (!projectUids.length) {
+            throw new SmartlingException("At least one project uid is required.");
+        }
+
+        if (projectUids.length > MAX_PROJECT_UIDS_SIZE) {
+            throw new SmartlingException(`The request contains too many project uids: ${projectUids.length}. Maximum allowed project uids number is ${MAX_PROJECT_UIDS_SIZE}.`);
+        }
+        this.set("projectUids", projectUids);
+
+        return this;
+    }
+}

api/webhooks/params/get-subscription-events-parameters.ts

@@ -0,0 +1,11 @@
+import { BaseParameters } from "../../parameters";
+
+export class GetSubscriptionEventsParameters extends BaseParameters {
+    setLimit(limit: number) {
+        if (limit > 0) {
+            this.set("limit", limit);
+        }
+
+        return this;
+    }
+}

api/webhooks/params/subscription-event.ts

@@ -0,0 +1,6 @@
+interface SubscriptionEvent {
+    type: string;
+    schemaVersion: string;
+}
+
+export { SubscriptionEvent };

api/webhooks/params/subscription-request-header.ts

@@ -0,0 +1,6 @@
+interface SubscriptionRequestHeader {
+    headerName: string;
+    headerValue: string;
+}
+
+export { SubscriptionRequestHeader };

api/webhooks/params/update-subscription-parameters.ts

@@ -0,0 +1,19 @@
+import { CreateUpdateSubscriptionParameters } from "./create-update-subscription-parameters";
+import { SubscriptionEvent } from "./subscription-event";
+
+export class UpdateSubscriptionParameters extends CreateUpdateSubscriptionParameters {
+    constructor(
+        subscriptionName: string,
+        subscriptionUrl: string,
+        events: SubscriptionEvent[],
+        enabled: boolean
+    ) {
+        super(
+            subscriptionName,
+            subscriptionUrl,
+            events
+        );
+
+        this.set("enabled", enabled);
+    }
+}

api/webhooks/params/update-subscription-secret-parameters.ts

@@ -0,0 +1,14 @@
+import { BaseParameters } from "../../parameters";
+import { SmartlingException } from "../../exception";
+
+export class UpdateSubscriptionSecretParameters extends BaseParameters {
+    constructor(payloadSecret: string) {
+        super();
+
+        if (!payloadSecret) {
+            throw new SmartlingException("Payload secret is required.");
+        }
+
+        this.set("payloadSecret", payloadSecret);
+    }
+}

api/webhooks/smartling-webhooks-api.ts

@@ -0,0 +1,148 @@
+import { SmartlingBaseApi } from "../base";
+import { SmartlingAuthApi } from "../auth";
+import { Logger } from "../logger";
+import { SmartlingListResponse } from "../http/smartling-list-response";
+import { SubscriptionDto } from "./dto/subscription-dto";
+import { SubscriptionSecretDto } from "./dto/subscription-secret-dto";
+import { SubscriptionStatisticsDto } from "./dto/subscription-statistics-dto";
+import { WebhookEventTypeDto } from "./dto/webhook-event-type.dto";
+import { CreateSubscriptionParameters } from "./params/create-subscription-parameters";
+import { UpdateSubscriptionParameters } from "./params/update-subscription-parameters";
+import { UpdateSubscriptionSecretParameters } from "./params/update-subscription-secret-parameters";
+
+export class SmartlingWebhooksApi extends SmartlingBaseApi {
+    constructor(smartlingApiBaseUrl: string, authApi: SmartlingAuthApi, logger: Logger) {
+        super(logger);
+        this.authApi = authApi;
+        this.entrypoint = `${smartlingApiBaseUrl}/webhooks-api/v2`;
+    }
+
+    getSubscriptions(
+        accountUid: string
+    ): Promise<SmartlingListResponse<SubscriptionDto>> {
+        return this.makeRequest(
+            "get",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions`
+        );
+    }
+
+    getSubscription(
+        accountUid: string,
+        subscriptionUid: string
+    ): Promise<SubscriptionDto> {
+        return this.makeRequest(
+            "get",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions/${subscriptionUid}`
+        );
+    }
+
+    createSubscription(
+        accountUid: string,
+        params: CreateSubscriptionParameters
+    ): Promise<SubscriptionDto> {
+        return this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions`,
+            JSON.stringify(params.export())
+        );
+    }
+
+    updateSubscription(
+        accountUid: string,
+        subscriptionUid: string,
+        params: UpdateSubscriptionParameters
+    ): Promise<SubscriptionDto> {
+        return this.makeRequest(
+            "put",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions/${subscriptionUid}`,
+            JSON.stringify(params.export())
+        );
+    }
+
+    deleteSubscription(
+        accountUid: string,
+        subscriptionUid: string
+    ): Promise<void> {
+        return this.makeRequest(
+            "delete",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions/${subscriptionUid}`
+        );
+    }
+
+    enableSubscription(
+        accountUid: string,
+        subscriptionUid: string
+    ): Promise<void> {
+        return this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions/${subscriptionUid}/enable`
+        );
+    }
+
+    disableSubscription(
+        accountUid: string,
+        subscriptionUid: string
+    ): Promise<void> {
+        return this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions/${subscriptionUid}/disable`
+        );
+    }
+
+    testSubscription(
+        accountUid: string,
+        subscriptionUid: string
+    ): Promise<void> {
+        return this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions/${subscriptionUid}/test`
+        );
+    }
+
+    getSubscriptionSecret(
+        accountUid: string,
+        subscriptionUid: string
+    ): Promise<SubscriptionSecretDto> {
+        return this.makeRequest(
+            "get",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions/${subscriptionUid}/secret`
+        );
+    }
+
+    updateSubscriptionSecret(
+        accountUid: string,
+        subscriptionUid: string,
+        params: UpdateSubscriptionSecretParameters
+    ): Promise<SubscriptionSecretDto> {
+        return this.makeRequest(
+            "put",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions/${subscriptionUid}/secret`,
+            JSON.stringify(params.export())
+        );
+    }
+
+    getSubscriptionStatistics(
+        accountUid: string,
+        subscriptionUid: string
+    ): Promise<SubscriptionStatisticsDto> {
+        return this.makeRequest(
+            "get",
+            `${this.entrypoint}/accounts/${accountUid}/subscriptions/${subscriptionUid}/statistics`
+        );
+    }
+
+    // getSubscriptionEvents() {}
+
+    // getSubscriptionEvent() {}
+
+    // sendSubscriptionEvent() {}
+
+    // getSubscriptionEventAttempts() {}
+
+    getAvailableEventTypes(accountUid: string): Promise<WebhookEventTypeDto[]> {
+        return this.makeRequest(
+            "get",
+            `${this.entrypoint}/accounts/${accountUid}/available-event-types`
+        );
+    }
+}

index.ts

@@ -114,3 +114,4 @@ export * from "./api/mt/index";
 export * from "./api/mt/params/smartling-mt-parameters";
 export * from "./api/mt/params/source-text-item";
 export * from "./api/mt/dto/translation-text-item-dto";
+export * from "./api/webhooks";