@crowdin/app-project-module 0.26.6 → 0.28.0-10

package/out/static/js/main.js

@@ -23,9 +23,19 @@ function parentWindowPostMessage(data) {
 
 window.addEventListener('message', handleMessage);
 
+function isJson(string) {
+  try {
+    JSON.parse(string);
+  } catch (e) {
+    return false;
+  }
+
+  return true;
+}
+
 function handleMessage(event) {
   const eventData =
-    event.data && typeof event.data === 'string' ? JSON.parse(event.data) : {};
+    event.data && typeof event.data === 'string' && isJson(event.data) ? JSON.parse(event.data) : {};
   if (postPromises[eventData.uid]) {
     if (postPromises[eventData.uid].timer) {
       clearTimeout(postPromises[eventData.uid].timer);

package/out/util/cron.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -31,15 +35,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.filesCron = exports.runJob = void 0;
 const crowdinAppFunctions = __importStar(require("@crowdin/crowdin-apps-functions"));
 const _1 = require(".");
+const models_1 = require("../models");
 const storage_1 = require("../storage");
 const connection_1 = require("./connection");
 const defaults_1 = require("./defaults");
-var SyncCondition;
-(function (SyncCondition) {
-    SyncCondition["ALL"] = "0";
-    SyncCondition["TRANSLATED"] = "1";
-    SyncCondition["APPROVED"] = "2";
-})(SyncCondition || (SyncCondition = {}));
 function runJob(config, integration, job) {
     return __awaiter(this, void 0, void 0, function* () {
         (0, _1.log)(`Starting cron job with expression [${job.expression}]`, config.logger);
@@ -97,9 +96,9 @@ function filesCron(config, integration, period) {
             const chunkSize = 10;
             if (syncSettings.provider === 'crowdin') {
                 const crowdinFiles = files;
-                const onlyTranslated = intConfig.condition === SyncCondition.TRANSLATED;
-                const onlyApproved = intConfig.condition === SyncCondition.APPROVED;
-                const all = intConfig.condition === SyncCondition.ALL || intConfig.condition === undefined;
+                const onlyTranslated = +intConfig.condition === models_1.SyncCondition.TRANSLATED;
+                const onlyApproved = +intConfig.condition === models_1.SyncCondition.APPROVED;
+                const all = +intConfig.condition === models_1.SyncCondition.ALL || intConfig.condition === undefined;
                 const filesToProcess = all
                     ? crowdinFiles
                     : yield getOnlyTranslatedOrApprovedFiles(config, projectId, crowdinFiles, crowdinClient, onlyApproved, onlyTranslated);

package/out/util/defaults.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -53,21 +57,20 @@ function getOauthRoute(integration) {
 }
 exports.getOauthRoute = getOauthRoute;
 function applyDefaults(config, integration) {
+    var _a;
     if (!integration.getCrowdinFiles) {
         integration.getCrowdinFiles = (projectId, client, rootFolder) => __awaiter(this, void 0, void 0, function* () {
             const allBranches = (yield client.sourceFilesApi.withFetchAll().listProjectBranches(projectId)).data.map((d) => d.data);
-            let allDirectories;
+            let options = {};
             if (rootFolder) {
-                allDirectories = (yield client.sourceFilesApi.withFetchAll().listProjectDirectories(projectId, {
+                options = {
                     directoryId: rootFolder.id,
                     recursion: 'true',
-                })).data.map((d) => d.data);
-            }
-            else {
-                allDirectories = (yield client.sourceFilesApi.withFetchAll().listProjectDirectories(projectId)).data.map((d) => d.data);
+                };
             }
+            const allDirectories = (yield client.sourceFilesApi.withFetchAll().listProjectDirectories(projectId, options)).data.map((d) => d.data);
             const directoryIds = allDirectories.map((d) => d.id);
-            let files = (yield client.sourceFilesApi.withFetchAll().listProjectFiles(projectId)).data.map((d) => d.data);
+            let files = (yield client.sourceFilesApi.withFetchAll().listProjectFiles(projectId, options)).data.map((d) => d.data);
             files = files.filter((f) => (rootFolder && f.directoryId === rootFolder.id) ||
                 directoryIds.includes(f.directoryId) ||
                 (!rootFolder && !f.directoryId));
@@ -118,6 +121,12 @@ function applyDefaults(config, integration) {
             return res;
         });
     }
+    if (!integration.getFileProgress) {
+        integration.getFileProgress = (projectId, client, fileId) => __awaiter(this, void 0, void 0, function* () {
+            const progress = yield client.translationStatusApi.getFileProgress(projectId, fileId);
+            return { [fileId]: progress.data.map((e) => e.data) };
+        });
+    }
     if (!integration.loginForm) {
         integration.loginForm = {
             fields: [
@@ -129,22 +138,43 @@ function applyDefaults(config, integration) {
             ],
         };
     }
-    if (integration.withCronSync) {
+    if (integration.withCronSync || integration.webhooks) {
         const getUserSettings = integration.getConfiguration;
         integration.getConfiguration = (projectId, crowdinClient, integrationCredentials) => __awaiter(this, void 0, void 0, function* () {
             let fields = [];
             if (getUserSettings) {
                 fields = yield getUserSettings(projectId, crowdinClient, integrationCredentials);
             }
-            return [
+            const defaultSettings = [
                 {
                     label: 'Background synchronization',
                 },
-                {
+            ];
+            const syncType = {
+                key: 'syncType',
+                label: 'Type of synchronization',
+                type: 'select',
+                defaultValue: '0',
+                options: [
+                    {
+                        value: '0',
+                        label: 'None',
+                    },
+                ],
+            };
+            defaultSettings.push(syncType);
+            if (integration.withCronSync) {
+                syncType.options.push({
+                    value: '1',
+                    label: 'Schedule',
+                });
+                defaultSettings.push({
                     key: 'schedule',
                     label: 'Sync schedule',
                     helpText: 'Set the frequency for pushing sources and translations',
                     type: 'select',
+                    defaultValue: '0',
+                    dependencySettings: "[{'#syncType-settings':{'type':'equal','value':['1']} }]",
                     options: [
                         {
                             value: '0',
@@ -171,12 +201,22 @@ function applyDefaults(config, integration) {
                             label: '24 hours',
                         },
                     ],
-                },
+                });
+            }
+            if (integration.webhooks) {
+                syncType.options.push({
+                    value: '2',
+                    label: 'Webhooks',
+                });
+            }
+            return [
+                ...defaultSettings,
                 {
                     key: 'condition',
                     label: 'Files export settings',
                     type: 'select',
                     defaultValue: '0',
+                    dependencySettings: "[{'#syncType-settings':{'type':'equal','value':['1','2']}}]",
                     options: [
                         {
                             value: '0',
@@ -201,6 +241,9 @@ function applyDefaults(config, integration) {
             yield integration.getIntegrationFiles(apiCredentials);
         });
     }
+    if (integration.webhooks && !((_a = integration.webhooks) === null || _a === void 0 ? void 0 : _a.urlParam)) {
+        integration.webhooks.urlParam = 'crowdinData';
+    }
 }
 exports.applyDefaults = applyDefaults;
 function constructOauthUrl(config, integration) {

package/out/util/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/out/util/webhooks.d.ts

@@ -0,0 +1,29 @@
+import Crowdin from '@crowdin/crowdin-api-client';
+import { Config, CrowdinContextInfo, IntegrationLogic, Payload, UpdateIntegrationRequest, WebhookUrlParams } from '../models';
+import { WebhooksModel } from '@crowdin/crowdin-api-client/out/webhooks';
+import { Request } from 'express';
+export declare function encodedUrlParam(config: Config, integration: IntegrationLogic, crowdinContext: CrowdinContextInfo): string;
+export declare function decodedUrlParam(config: Config, data: string): WebhookUrlParams;
+export declare function makeCrowdinWebhookUrl(config: Config, integration: IntegrationLogic, crowdinContext: CrowdinContextInfo): string;
+export declare function registerWebhooks(config: Config, integration: IntegrationLogic, client: Crowdin, crowdinContext: CrowdinContextInfo, apiCredentials: any, appSettings: any): Promise<void>;
+export declare function unregisterWebhooks(config: Config, integration: IntegrationLogic, client: Crowdin, crowdinContext: CrowdinContextInfo, apiCredentials: any, appSettings: any): Promise<void>;
+export declare function getCrowdinProjectWebhook(config: Config, client: Crowdin, projectId: number, name: string): Promise<WebhooksModel.Webhook | undefined>;
+export declare function getAllCrowdinProjectWebhooks(config: Config, client: Crowdin, projectId: number): Promise<WebhooksModel.Webhook[]>;
+export declare function registerCrowdinWebhook(config: Config, url: string, client: Crowdin, crowdinContext: CrowdinContextInfo, events: WebhooksModel.Event[]): Promise<void>;
+export declare function updateCrowdinWebhooks(config: Config, client: Crowdin, projectId: number, webhook: WebhooksModel.Webhook, events: WebhooksModel.Event[], url: string): Promise<void>;
+export declare function unregisterCrowdinWebhooks(config: Config, client: Crowdin, projectId: number, webhook: WebhooksModel.Webhook): Promise<void>;
+export declare function unregisterAllCrowdinWebhooks(config: Config, integration: IntegrationLogic, crowdinId: string): Promise<void>;
+export declare function filterSyncFiles(events: Payload[], syncFileSettings: UpdateIntegrationRequest): UpdateIntegrationRequest;
+export declare function prepareWebhookData(config: Config, integration: IntegrationLogic, webhookUrlParam: string, provider: string): Promise<{
+    projectId: number;
+    crowdinClient: {
+        client: Crowdin;
+        token: string;
+    };
+    preparedIntegrationCredentials: any;
+    rootFolder: import("@crowdin/crowdin-api-client").SourceFilesModel.Directory | undefined;
+    appSettings: any;
+    syncSettings: import("../models").IntegrationSyncSettings | null | undefined;
+}>;
+export declare function updateCrowdinFromWebhookRequest(integration: IntegrationLogic, webhookData: any, req: Request): Promise<void | import("../models").ExtendedResult<void>>;
+export declare function listenQueueMessage(config: Config, integration: IntegrationLogic, queueUrl: string, queueName: string): Promise<void>;

package/out/util/webhooks.js

@@ -0,0 +1,308 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listenQueueMessage = exports.updateCrowdinFromWebhookRequest = exports.prepareWebhookData = exports.filterSyncFiles = exports.unregisterAllCrowdinWebhooks = exports.unregisterCrowdinWebhooks = exports.updateCrowdinWebhooks = exports.registerCrowdinWebhook = exports.getAllCrowdinProjectWebhooks = exports.getCrowdinProjectWebhook = exports.unregisterWebhooks = exports.registerWebhooks = exports.makeCrowdinWebhookUrl = exports.decodedUrlParam = exports.encodedUrlParam = void 0;
+const crowdinAppFunctions = __importStar(require("@crowdin/crowdin-apps-functions"));
+const amqplib_1 = __importDefault(require("amqplib"));
+const models_1 = require("../models");
+const index_1 = require("./index");
+const connection_1 = require("./connection");
+const storage_1 = require("../storage");
+const defaults_1 = require("./defaults");
+const util_1 = require("../util");
+const HookEvents = {
+    ALL: ['file.translated', 'file.approved'],
+    TRANSLATED: ['file.translated'],
+    APPROVED: ['file.approved'],
+};
+function encodedUrlParam(config, integration, crowdinContext) {
+    var _a;
+    const params = {
+        projectId: +crowdinContext.jwtPayload.context.project_id,
+        clientId: crowdinContext.clientId,
+        crowdinId: crowdinContext.crowdinId,
+    };
+    const encryptedParams = (0, index_1.encryptData)(config, JSON.stringify(params));
+    return `${(_a = integration.webhooks) === null || _a === void 0 ? void 0 : _a.urlParam}=${encodeURIComponent(encryptedParams)}`;
+}
+exports.encodedUrlParam = encodedUrlParam;
+function decodedUrlParam(config, data) {
+    const params = (0, index_1.decryptData)(config, data);
+    return JSON.parse(params);
+}
+exports.decodedUrlParam = decodedUrlParam;
+function makeCrowdinWebhookUrl(config, integration, crowdinContext) {
+    var _a;
+    const urlParam = encodedUrlParam(config, integration, crowdinContext);
+    return (`${config.baseUrl}${((_a = integration.webhooks) === null || _a === void 0 ? void 0 : _a.crowdinWebhookUrl) ? integration.webhooks.crowdinWebhookUrl : '/api/crowdin/webhook'}` + `?${urlParam}`);
+}
+exports.makeCrowdinWebhookUrl = makeCrowdinWebhookUrl;
+function registerWebhooks(config, integration, client, crowdinContext, apiCredentials, appSettings) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const isWebhookSync = +appSettings.syncType === models_1.SyncType.WEBHOOKS;
+        const projectId = crowdinContext.jwtPayload.context.project_id;
+        const urlParam = encodedUrlParam(config, integration, crowdinContext);
+        if ((_a = integration.webhooks) === null || _a === void 0 ? void 0 : _a.crowdinWebhooks) {
+            yield integration.webhooks.crowdinWebhooks(client, projectId, isWebhookSync, appSettings);
+        }
+        else {
+            const webhookName = `${config.name} application hook ${crowdinContext.jwtPayload.sub}`;
+            const webhookUrl = makeCrowdinWebhookUrl(config, integration, crowdinContext);
+            const syncCondition = models_1.SyncCondition[+appSettings.condition];
+            const events = HookEvents[syncCondition];
+            const webhook = yield getCrowdinProjectWebhook(config, client, projectId, webhookName);
+            if (isWebhookSync && webhook) {
+                yield updateCrowdinWebhooks(config, client, projectId, webhook, events, webhookUrl);
+            }
+            else if (isWebhookSync && !webhook) {
+                yield registerCrowdinWebhook(config, webhookUrl, client, crowdinContext, events);
+            }
+            else if (!isWebhookSync && webhook) {
+                yield unregisterCrowdinWebhooks(config, client, projectId, webhook);
+            }
+        }
+        if ((_b = integration.webhooks) === null || _b === void 0 ? void 0 : _b.integrationWebhooks) {
+            yield integration.webhooks.integrationWebhooks(apiCredentials, urlParam, isWebhookSync, appSettings);
+        }
+    });
+}
+exports.registerWebhooks = registerWebhooks;
+function unregisterWebhooks(config, integration, client, crowdinContext, apiCredentials, appSettings) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        if ((_a = integration.webhooks) === null || _a === void 0 ? void 0 : _a.crowdinWebhooks) {
+            yield integration.webhooks.crowdinWebhooks(client, crowdinContext.jwtPayload.context.project_id, false);
+        }
+        else {
+            const webhookName = `${config.name} application hook ${crowdinContext.jwtPayload.sub}`;
+            const webhook = yield getCrowdinProjectWebhook(config, client, crowdinContext.jwtPayload.context.project_id, webhookName);
+            if (webhook) {
+                yield unregisterCrowdinWebhooks(config, client, crowdinContext.jwtPayload.context.project_id, webhook);
+            }
+        }
+        if ((_b = integration.webhooks) === null || _b === void 0 ? void 0 : _b.integrationWebhooks) {
+            const urlParam = encodedUrlParam(config, integration, crowdinContext);
+            yield integration.webhooks.integrationWebhooks(apiCredentials, urlParam, false, appSettings);
+        }
+    });
+}
+exports.unregisterWebhooks = unregisterWebhooks;
+function getCrowdinProjectWebhook(config, client, projectId, name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const hooks = (yield client.webhooksApi.withFetchAll().listWebhooks(projectId)).data.map((e) => e.data);
+        return hooks.find((h) => h.name === name);
+    });
+}
+exports.getCrowdinProjectWebhook = getCrowdinProjectWebhook;
+function getAllCrowdinProjectWebhooks(config, client, projectId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const hooks = (yield client.webhooksApi.withFetchAll().listWebhooks(projectId)).data.map((e) => e.data);
+        return hooks.filter((h) => h.name.startsWith(`${config.name} application hook `));
+    });
+}
+exports.getAllCrowdinProjectWebhooks = getAllCrowdinProjectWebhooks;
+function createPayload(events) {
+    const payload = {};
+    for (const event of events) {
+        payload[event] = {
+            event: '{{event}}',
+            projectId: '{{projectId}}',
+            language: '{{targetLanguageId}}',
+            fileId: '{{fileId}}',
+        };
+    }
+    return payload;
+}
+function registerCrowdinWebhook(config, url, client, crowdinContext, events) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const name = `${config.name} application hook ${crowdinContext.jwtPayload.sub}`;
+        const payload = createPayload(events);
+        yield client.webhooksApi.addWebhook(crowdinContext.jwtPayload.context.project_id, {
+            name,
+            url,
+            events,
+            requestType: 'POST',
+            batchingEnabled: true,
+            payload,
+        });
+    });
+}
+exports.registerCrowdinWebhook = registerCrowdinWebhook;
+function updateCrowdinWebhooks(config, client, projectId, webhook, events, url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const payload = createPayload(events);
+        yield client.webhooksApi.editWebhook(projectId, webhook.id, [
+            {
+                value: events,
+                op: 'replace',
+                path: '/events',
+            },
+            {
+                value: payload,
+                op: 'replace',
+                path: '/payload',
+            },
+            {
+                value: url,
+                op: 'replace',
+                path: '/url',
+            },
+        ]);
+    });
+}
+exports.updateCrowdinWebhooks = updateCrowdinWebhooks;
+function unregisterCrowdinWebhooks(config, client, projectId, webhook) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield client.webhooksApi.deleteWebhook(projectId, webhook.id);
+    });
+}
+exports.unregisterCrowdinWebhooks = unregisterCrowdinWebhooks;
+function unregisterAllCrowdinWebhooks(config, integration, crowdinId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (integration.webhooks) {
+            const crowdinCredentials = yield (0, storage_1.getStorage)().getCrowdinCredentials(crowdinId);
+            if (crowdinCredentials) {
+                const credentials = yield (0, storage_1.getStorage)().getAllIntegrationCredentials(crowdinId);
+                const projectIds = credentials.map((c) => crowdinAppFunctions.getProjectId(c.id));
+                const crowdinClient = yield (0, connection_1.prepareCrowdinClient)(config, crowdinCredentials);
+                yield Promise.all(projectIds.map((projectId) => __awaiter(this, void 0, void 0, function* () {
+                    const webhooks = yield getAllCrowdinProjectWebhooks(config, crowdinClient.client, projectId);
+                    yield Promise.all(webhooks.map((hook) => __awaiter(this, void 0, void 0, function* () { return yield unregisterCrowdinWebhooks(config, crowdinClient.client, projectId, hook); })));
+                })));
+            }
+        }
+    });
+}
+exports.unregisterAllCrowdinWebhooks = unregisterAllCrowdinWebhooks;
+function filterSyncFiles(events, syncFileSettings) {
+    const files = {};
+    events.forEach((event) => {
+        const fileId = event.fileId;
+        const language = event.language;
+        if (syncFileSettings[fileId] && syncFileSettings[fileId].includes(language)) {
+            if (files[fileId]) {
+                files[fileId] = [...files[fileId], event.language];
+            }
+            else {
+                files[fileId] = [event.language];
+            }
+        }
+    });
+    return files;
+}
+exports.filterSyncFiles = filterSyncFiles;
+function prepareWebhookData(config, integration, webhookUrlParam, provider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let rootFolder = undefined;
+        let appSettings = null;
+        let syncSettings = null;
+        const { projectId, crowdinId, clientId } = decodedUrlParam(config, webhookUrlParam);
+        const crowdinCredentials = yield (0, storage_1.getStorage)().getCrowdinCredentials(crowdinId);
+        const crowdinClient = yield (0, connection_1.prepareCrowdinClient)(config, crowdinCredentials);
+        const integrationCredentials = yield (0, storage_1.getStorage)().getIntegrationCredentials(clientId);
+        const preparedIntegrationCredentials = yield (0, connection_1.prepareIntegrationCredentials)(config, integration, integrationCredentials);
+        if (integrationCredentials === null || integrationCredentials === void 0 ? void 0 : integrationCredentials.config) {
+            appSettings = JSON.parse(integrationCredentials.config);
+            const isWebhookSync = +appSettings.syncType === models_1.SyncType.WEBHOOKS;
+            if (isWebhookSync) {
+                syncSettings = yield (0, storage_1.getStorage)().getSyncSettings(clientId, crowdinId, 'schedule', provider);
+                rootFolder = yield (0, defaults_1.getRootFolder)(config, integration, crowdinClient.client, projectId);
+            }
+        }
+        return { projectId, crowdinClient, preparedIntegrationCredentials, rootFolder, appSettings, syncSettings };
+    });
+}
+exports.prepareWebhookData = prepareWebhookData;
+function updateCrowdinFromWebhookRequest(integration, webhookData, req) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        let filesToSync = [];
+        const { projectId, crowdinClient, preparedIntegrationCredentials, rootFolder, appSettings, syncSettings } = webhookData;
+        if ((_a = integration.webhooks) === null || _a === void 0 ? void 0 : _a.integrationWebhookInterceptor) {
+            filesToSync = yield ((_b = integration.webhooks) === null || _b === void 0 ? void 0 : _b.integrationWebhookInterceptor(projectId, crowdinClient.client, preparedIntegrationCredentials, rootFolder, appSettings, syncSettings, req));
+        }
+        return yield integration.updateCrowdin(projectId, crowdinClient.client, preparedIntegrationCredentials, filesToSync, rootFolder, appSettings);
+    });
+}
+exports.updateCrowdinFromWebhookRequest = updateCrowdinFromWebhookRequest;
+function listenQueueMessage(config, integration, queueUrl, queueName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const connection = yield amqplib_1.default.connect(queueUrl);
+            connection.once('close', function () {
+                setTimeout(() => {
+                    listenQueueMessage(config, integration, queueUrl, queueName);
+                }, 3000);
+                return;
+            });
+            const channel = yield connection.createChannel();
+            if (channel) {
+                yield channel.assertQueue(queueName, { durable: true });
+                yield channel.prefetch(1);
+                yield channel.consume(queueName, consumer(channel, config, integration), { noAck: false });
+            }
+        }
+        catch (e) {
+            setTimeout(() => {
+                listenQueueMessage(config, integration, queueUrl, queueName);
+            }, 3000);
+        }
+    });
+}
+exports.listenQueueMessage = listenQueueMessage;
+function consumer(channel, config, integration) {
+    return function (msg) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!msg) {
+                return;
+            }
+            try {
+                const data = JSON.parse(msg.content.toString());
+                const urlParam = (_a = integration.webhooks) === null || _a === void 0 ? void 0 : _a.urlParam;
+                const webhookUrlParam = data.query[urlParam];
+                const webhookData = yield prepareWebhookData(config, integration, webhookUrlParam, 'integration');
+                yield updateCrowdinFromWebhookRequest(integration, webhookData, data);
+            }
+            catch (e) {
+                (0, util_1.logError)(e, config.onError);
+            }
+            channel.ack(msg);
+        });
+    };
+}

package/out/views/form.handlebars

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="en">
+{{> head}}
+<body>
+    <div
+        class="i_w"
+        style='max-width:680px; position: relative;'
+    >
+        <crowdin-card
+            is-shadowed
+        >
+            <div id="form"></div>
+            <div id="form-loading">
+                <crowdin-progress-indicator />
+            </div>
+        </crowdin-card>
+    </div>
+    <crowdin-toasts></crowdin-toasts>
+    <script>
+    /*<!--*/
+        var formGetDataUrl = '{{formGetDataUrl}}';
+        var formPostDataUrl = '{{formPostDataUrl}}';
+        var formSchema = {{{formSchema}}};
+        var formUiSchema = {{{formUiSchema}}};
+    /*-->*/
+    </script>
+    <script src="/assets/js/form.js"></script>
+</body>
+</html>