@crowdin/app-project-module 0.17.6 → 0.17.8

package/README.md

@@ -19,14 +19,6 @@ In both options you will need to provide Crowdin App configuration file. Please
 - `getUserSettings` to get settings that users manage in the integration module
 - `establishCrowdinConnection` method that accept jwt token that you may forward from module UI and it will return back Crowdin client instance and the context.
 
-## Status
-
-[![npm](https://img.shields.io/npm/v/@crowdin/app-project-module?logo=npm&cacheSeconds=1800)](https://www.npmjs.com/package/@crowdin/app-project-module)
-[![Build Status](https://dev.azure.com/crowdin/app-project-module/_apis/build/status/Basic?branchName=master)](https://dev.azure.com/crowdin/app-project-module/_build/latest?definitionId=39&branchName=master)
-[![npm](https://img.shields.io/npm/dt/@crowdin/app-project-module?cacheSeconds=1800)](https://www.npmjs.com/package/@crowdin/app-project-module)
-<!-- [![GitHub issues](https://img.shields.io/github/issues/crowdin/app-project-module?cacheSeconds=3600)](https://github.com/crowdin/app-project-module/issues)
-[![License](https://img.shields.io/github/license/crowdin/app-project-module?cacheSeconds=3600)](https://github.com/crowdin/app-project-module/blob/master/LICENSE) -->
-
 ## Table of Contents
 
 - [Installation](#installation)
@@ -81,7 +73,11 @@ const configuration = {
     description: 'Sample App description',
     dbFolder: __dirname,
     imagePath: __dirname + '/' + 'logo.png',
-    // crowdinBaseUrl: 'https://local.crowdin.dev/api/v2',
+    crowdinUrls: { // custom urls to override
+        // apiUrl: 'https://local.crowdin.dev/api/v2'
+        // accountUrl: 'https://local.crowdin.dev/oauth/token' // (default https://accounts.crowdin.com/oauth/token)
+        // subscriptionUrl: 'https://local.crowdin.dev' // (default https://crowdin.com or https://org.api.crowdin.com)
+    },
     projectIntegration: {
         withRootFolder: true,
         withCronSync: {

package/out/handlers/crowdin-file-progress.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config } from '../models';
+export default function handle(config: Config): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/crowdin-file-progress.js

@@ -0,0 +1,22 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+function handle(config) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const fileId = Number(req.params.fileId);
+        (0, util_1.log)(`Loading translation progress for file ${fileId}`, config.logger);
+        const progress = yield req.crowdinApiClient.translationStatusApi.getFileProgress(req.crowdinContext.jwtPayload.context.project_id, fileId);
+        (0, util_1.log)(`Translation progress for file ${fileId} ${JSON.stringify(progress.data, null, 2)}`, config.logger);
+        res.send({ [fileId]: progress.data.map(e => e.data) });
+    }), config.onError);
+}
+exports.default = handle;

package/out/handlers/crowdin-files.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config, IntegrationLogic } from '../models';
+export default function handle(config: Config, integration: IntegrationLogic): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/crowdin-files.js

@@ -0,0 +1,31 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const defaults_1 = require("../util/defaults");
+function handle(config, integration) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        (0, util_1.log)('Loading crowdin files', config.logger);
+        if (integration.getCrowdinFiles) {
+            const rootFolder = yield (0, defaults_1.getRootFolder)(config, integration, req.crowdinApiClient, req.crowdinContext.jwtPayload.context.project_id);
+            (0, util_1.log)(`Loading files ${rootFolder ? `from folder ${rootFolder.id}` : 'from root'}`, config.logger);
+            const files = integration.getCrowdinFiles
+                ? yield integration.getCrowdinFiles(req.crowdinContext.jwtPayload.context.project_id, req.crowdinApiClient, rootFolder, req.integrationSettings)
+                : [];
+            (0, util_1.log)(`Returning files ${JSON.stringify(files, null, 2)}`, config.logger);
+            res.send(files);
+        }
+        else {
+            res.send([]);
+        }
+    }), config.onError);
+}
+exports.default = handle;

package/out/handlers/crowdin-project.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config } from '../models';
+export default function handle(config: Config): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/crowdin-project.js

@@ -0,0 +1,22 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+function handle(config) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const projectId = req.crowdinContext.jwtPayload.context.project_id;
+        (0, util_1.log)(`Loading crowdin project ${projectId}`, config.logger);
+        const project = yield req.crowdinApiClient.projectsGroupsApi.getProject(projectId);
+        (0, util_1.log)(`Loaded crowdin project ${JSON.stringify(project, null, 2)}`, config.logger);
+        res.send(project.data);
+    }), config.onError);
+}
+exports.default = handle;

package/out/handlers/crowdin-update.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config, IntegrationLogic } from '../models';
+export default function handle(config: Config, integration: IntegrationLogic): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/crowdin-update.js

@@ -0,0 +1,26 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const defaults_1 = require("../util/defaults");
+function handle(config, integration) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const projectId = req.crowdinContext.jwtPayload.context.project_id;
+        (0, util_1.log)(`Upading crowdin project ${projectId}`, config.logger);
+        const rootFolder = yield (0, defaults_1.getRootFolder)(config, integration, req.crowdinApiClient, projectId);
+        if (rootFolder) {
+            (0, util_1.log)(`Upading crowdin files under folder ${rootFolder.id}`, config.logger);
+        }
+        yield integration.updateCrowdin(projectId, req.crowdinApiClient, req.integrationCredentials, req.body, rootFolder, req.integrationSettings);
+        res.status(204).end();
+    }), config.onError);
+}
+exports.default = handle;

package/out/handlers/custom-file-format/download.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Request, Response } from 'express';
+import { Config } from '../../models';
+export default function handle(config: Config, folder: string): (req: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/custom-file-format/download.js

@@ -0,0 +1,32 @@
+"use strict";
+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 });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("../../util");
+function handle(config, folder) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const filePath = path_1.default.join(folder, 'custom-file-format', req.query.file);
+        (0, util_1.log)(`Downloading file ${filePath}`, config.logger);
+        res.download(filePath, function (err) {
+            if (err) {
+                console.error(err);
+            }
+            else {
+                fs_1.default.unlinkSync(filePath);
+            }
+        });
+    }), config.onError);
+}
+exports.default = handle;

package/out/handlers/custom-file-format/process.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config, CustomFileFormatLogic } from '../../models';
+export default function handle(baseConfig: Config, baseUrl: string, folder: string, config: CustomFileFormatLogic): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/custom-file-format/process.js

@@ -0,0 +1,139 @@
+"use strict";
+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 });
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const models_1 = require("../../models");
+const util_1 = require("../../util");
+const MAX_BODY_SIZE = 5 * 1024 * 1024; //5mb
+function storeFile(fileContent, folder) {
+    const fileName = `file${Date.now()}`;
+    return new Promise((res, rej) => fs_1.default.writeFile(path_1.default.join(folder, 'custom-file-format', fileName), fileContent, err => {
+        if (err) {
+            rej(err);
+        }
+        else {
+            res(fileName);
+        }
+    }));
+}
+function handleBuildFile(baseUrl, dataFolder, config, req, client, context, projectId, file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = {};
+        if (!req.strings && !req.stringsUrl) {
+            throw new Error('Bad payload received: No strings found');
+        }
+        let strings;
+        if (req.strings) {
+            strings = req.strings;
+        }
+        else {
+            strings = (yield axios_1.default.get(req.stringsUrl)).data;
+        }
+        let res;
+        if ((req.file.id || !file) && config.exportStrings) {
+            res = yield config.exportStrings(req, strings, client, context, projectId);
+        }
+        else if (file && config.buildFile) {
+            res = yield config.buildFile(file, req, strings, client, context, projectId);
+        }
+        else {
+            return { response };
+        }
+        const contentFileEncoded = Buffer.from(res.contentFile).toString('base64');
+        if (Buffer.byteLength(contentFileEncoded, 'utf8') < MAX_BODY_SIZE) {
+            response.content = contentFileEncoded;
+        }
+        else {
+            const storedFile = yield storeFile(res.contentFile, dataFolder);
+            response.contentUrl = `${baseUrl}?file=${storedFile}`;
+        }
+        return { response, error: res.error };
+    });
+}
+function handleParseFile(baseUrl, dataFolder, config, req, client, context, projectId, file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = {};
+        if (!config.parseFile || !file) {
+            return { response };
+        }
+        const res = yield config.parseFile(file, req, client, context, projectId);
+        if (res.previewFile) {
+            const previewFileEncoded = Buffer.from(res.previewFile).toString('base64');
+            if (Buffer.byteLength(previewFileEncoded, 'utf8') < MAX_BODY_SIZE) {
+                response.preview = previewFileEncoded;
+            }
+            else {
+                const storedFile = yield storeFile(res.previewFile, dataFolder);
+                response.previewUrl = `${baseUrl}?file=${storedFile}`;
+            }
+        }
+        if (res.strings) {
+            let strings = res.strings;
+            if (config.autoUploadTranslations) {
+                strings = strings.map(string => {
+                    const translations = {};
+                    req.targetLanguages
+                        .map(targetLanguage => targetLanguage.id)
+                        .forEach(targetLanguage => (translations[targetLanguage] = { text: string.text }));
+                    return Object.assign(Object.assign({}, string), { translations });
+                });
+            }
+            const stringsJson = JSON.stringify(strings);
+            if (Buffer.byteLength(stringsJson, 'utf8') < MAX_BODY_SIZE) {
+                response.strings = strings;
+            }
+            else {
+                const storedFile = yield storeFile(stringsJson, dataFolder);
+                response.stringsUrl = `${baseUrl}?file=${storedFile}`;
+            }
+        }
+        return { response, error: res.error };
+    });
+}
+function handle(baseConfig, baseUrl, folder, config) {
+    if (!fs_1.default.existsSync(path_1.default.join(folder, 'custom-file-format'))) {
+        fs_1.default.mkdirSync(path_1.default.join(folder, 'custom-file-format'), { recursive: true });
+    }
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const baseFilesUrl = `${baseUrl}/file/download`;
+        const body = req.body;
+        (0, util_1.log)(`Recieved request to process file ${JSON.stringify(body, null, 2)}`, baseConfig.logger);
+        let file;
+        if (body.file.content) {
+            file = Buffer.from(body.file.content, 'base64').toString();
+        }
+        else if (body.file.contentUrl) {
+            file = (yield axios_1.default.get(body.file.contentUrl)).data;
+        }
+        let response = {};
+        let error;
+        switch (body.jobType) {
+            case models_1.ProcessFileJobType.BUILD_FILE:
+                const buildFileResult = yield handleBuildFile(baseFilesUrl, folder, config, body, req.crowdinApiClient, req.crowdinContext, req.crowdinContext.jwtPayload.context.project_id, file);
+                response = buildFileResult.response;
+                error = buildFileResult.error;
+                break;
+            case models_1.ProcessFileJobType.PARSE_FILE:
+                const parseFileResult = yield handleParseFile(baseFilesUrl, folder, config, body, req.crowdinApiClient, req.crowdinContext, req.crowdinContext.jwtPayload.context.project_id, file);
+                response = parseFileResult.response;
+                error = parseFileResult.error;
+                break;
+        }
+        (0, util_1.log)(`Returning response from process file action ${JSON.stringify(response, null, 2)}`, baseConfig.logger);
+        res.send({ data: response, error: error ? { message: error } : undefined });
+    }), baseConfig.onError);
+}
+exports.default = handle;

package/out/handlers/custom-mt/translate.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config, CustomMTLogic } from '../../models';
+export default function handle(baseConfig: Config, config: CustomMTLogic): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/custom-mt/translate.js

@@ -0,0 +1,42 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../../util");
+function handle(baseConfig, config) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const source = req.query.source;
+        const target = req.query.target;
+        const body = req.body;
+        (0, util_1.log)('Recieved request for custom mt', baseConfig.logger);
+        (0, util_1.log)(`Source language ${source}, target language ${target}`, baseConfig.logger);
+        (0, util_1.log)(`Payload ${JSON.stringify(body, null, 2)}`, baseConfig.logger);
+        const projectId = Number(req.query.project_id);
+        try {
+            if (source === 'en' && target === 'de' && body.strings && body.strings[0] === 'validation') {
+                if (config.validate) {
+                    yield config.validate(req.crowdinApiClient);
+                }
+                res.send({ data: { translations: [] } });
+            }
+            else {
+                const translations = yield config.translate(req.crowdinApiClient, req.crowdinContext, projectId, source, target, body.strings);
+                res.send({ data: { translations } });
+            }
+        }
+        catch (e) {
+            const message = (0, util_1.getMessage)(e);
+            res.send({
+                error: { message },
+            });
+        }
+    }), baseConfig.onError);
+}
+exports.default = handle;

package/out/handlers/install.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Request, Response } from 'express';
+import { Config } from '../models';
+export default function handle(config: Config): (req: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/install.js

@@ -0,0 +1,46 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crowdin_apps_functions_1 = require("@crowdin/crowdin-apps-functions");
+const models_1 = require("../models");
+const storage_1 = require("../storage");
+const util_1 = require("../util");
+function handle(config) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const event = req.body;
+        (0, util_1.log)(`Recieved install request ${JSON.stringify(event, null, 2)}`, config.logger);
+        const token = yield (0, crowdin_apps_functions_1.generateOAuthToken)(config.clientId, config.clientSecret, event.code, (_a = config.crowdinUrls) === null || _a === void 0 ? void 0 : _a.accountUrl);
+        const credentials = {
+            id: (event.domain || event.organizationId).toString(),
+            appSecret: event.appSecret,
+            domain: event.domain,
+            userId: event.userId,
+            organizationId: event.organizationId,
+            baseUrl: event.baseUrl,
+            accessToken: (0, util_1.encryptData)(config, token.accessToken),
+            refreshToken: (0, util_1.encryptData)(config, token.refreshToken),
+            expire: (new Date().getTime() / 1000 + token.expiresIn).toString(),
+            type: event.domain ? models_1.AccountType.ENTERPRISE : models_1.AccountType.NORMAL,
+        };
+        const existingCredentials = yield (0, storage_1.getCrowdinCredentials)(credentials.id);
+        if (!!existingCredentials) {
+            yield (0, storage_1.updateCrowdinCredentials)(credentials);
+            (0, util_1.log)('An existing App has been reinstalled', config.logger);
+        }
+        else {
+            yield (0, storage_1.saveCrowdinCredentials)(credentials);
+            (0, util_1.log)('A new App has been installed', config.logger);
+        }
+        res.status(204).end();
+    }), config.onError);
+}
+exports.default = handle;

package/out/handlers/integration-data.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config, IntegrationLogic } from '../models';
+export default function handle(config: Config, integration: IntegrationLogic): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/integration-data.js

@@ -0,0 +1,21 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+function handle(config, integration) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        (0, util_1.log)('Recieved request to get integration data', config.logger);
+        const files = yield integration.getIntegrationFiles(req.integrationCredentials, req.integrationSettings);
+        (0, util_1.log)(`Integration data response ${JSON.stringify(files, null, 2)}`, config.logger);
+        res.send(files);
+    }), config.onError);
+}
+exports.default = handle;

package/out/handlers/integration-login.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config, IntegrationLogic } from '../models';
+export default function handle(config: Config, integration: IntegrationLogic): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/integration-login.js

@@ -0,0 +1,30 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const storage_1 = require("../storage");
+const util_1 = require("../util");
+function handle(config, integration) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        (0, util_1.log)('Recieved integration login request', config.logger);
+        if (integration.checkConnection) {
+            (0, util_1.log)('Checking the integration credentials', config.logger);
+            yield integration.checkConnection(req.body.credentials);
+        }
+        const existing = yield (0, storage_1.getIntegrationCredentials)(req.crowdinContext.clientId);
+        if (!!existing) {
+            (0, util_1.log)('Deleting old credentials', config.logger);
+            yield (0, storage_1.deleteIntegrationCredentials)(req.crowdinContext.clientId);
+        }
+        yield (0, storage_1.saveIntegrationCredentials)(req.crowdinContext.clientId, (0, util_1.encryptData)(config, JSON.stringify(req.body.credentials)), req.crowdinContext.crowdinId);
+        res.status(204).end();
+    }), config.onError);
+}
+exports.default = handle;

package/out/handlers/integration-logout.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config } from '../models';
+export default function handle(config: Config): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/integration-logout.js

@@ -0,0 +1,23 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const storage_1 = require("../storage");
+const util_1 = require("../util");
+const connection_1 = require("../util/connection");
+function handle(config) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        (0, util_1.log)('Recieved integration logout request', config.logger);
+        yield (0, storage_1.deleteIntegrationCredentials)(req.crowdinContext.clientId);
+        (0, connection_1.clearCache)(req.crowdinContext.crowdinId);
+        res.status(204).end();
+    }), config.onError);
+}
+exports.default = handle;

package/out/handlers/integration-update.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config, IntegrationLogic } from '../models';
+export default function handle(config: Config, integration: IntegrationLogic): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/handlers/integration-update.js

@@ -0,0 +1,25 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const defaults_1 = require("../util/defaults");
+function handle(config, integration) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        (0, util_1.log)('Upading integratino data', config.logger);
+        const rootFolder = yield (0, defaults_1.getRootFolder)(config, integration, req.crowdinApiClient, req.crowdinContext.jwtPayload.context.project_id);
+        if (rootFolder) {
+            (0, util_1.log)(`Upading integration data for crowding root folder ${rootFolder.id}`, config.logger);
+        }
+        yield integration.updateIntegration(req.crowdinContext.jwtPayload.context.project_id, req.crowdinApiClient, req.integrationCredentials, req.body, rootFolder, req.integrationSettings);
+        res.status(204).end();
+    }), config.onError);
+}
+exports.default = handle;

package/out/handlers/main.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config, IntegrationLogic } from '../models';
+export default function handle(config: Config, integration: IntegrationLogic): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;