@tilde-nlp/ngx-translate 1.0.0

package/esm2020/lib/modules/tld-document/services/api/file-api.service.mjs

@@ -0,0 +1,166 @@
+import { HttpEventType, HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Common, ErrorCode } from '../../../tld-common/models';
+import { TranslationStatuss } from '../../models/translation-statuss.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../tld-common/services";
+import * as i3 from "../../../tld-term/services";
+export class TldTranslateFileApiService {
+    constructor(http, config, collectionService, alerts) {
+        this.http = http;
+        this.config = config;
+        this.collectionService = collectionService;
+        this.alerts = alerts;
+        this._segmentLimit = -1;
+        this._sourceDownloadStatusses = [TranslationStatuss.WAITING, TranslationStatuss.SAVING, TranslationStatuss.COMPLETED, TranslationStatuss.TRANSLATING];
+    }
+    translatedDocumentPreview(properties) {
+        const previewMethodName = "GetDocumentPreview";
+        const params = { docId: properties.translationDocId, fileName: properties.fileName };
+        const url = this.config.fileConfig.fileApiUrl + previewMethodName;
+        const headers = this.getAuthHeaders();
+        return this.http.post(url, params, { headers });
+    }
+    download(properties) {
+        const methodName = "Download";
+        const url = this.config.fileConfig.fileApiUrl + methodName;
+        const params = { docId: properties.id, fileName: properties.fileMeta.fileName };
+        const headers = Common.getAuthHeaders(this.config);
+        return this.http.get(url, { params: params, headers: headers, responseType: "blob" });
+    }
+    startTranslation(properties) {
+        const headers = this.getAuthHeaders();
+        const methodName = "StartTranslation";
+        const url = this.config.fileConfig.fileApiUrl + methodName;
+        //translationFile.lastTranslationAuthHeaders = headers;
+        // TODO. Create type for params.
+        const params = {
+            systemId: properties.system.id,
+            appId: this.config.coreConfig.appId,
+            fileName: properties.file.originalFileName,
+            tmpname: properties.file.tmpName,
+            wordLimit: this.config.fileConfig.wordLimit,
+            segmentLimit: this._segmentLimit,
+            ocrPageLimit: this.config.fileConfig.ocrPageLimit
+        };
+        const selectedCollectionId = this.collectionService.selectedIdForTranslation();
+        if (selectedCollectionId) {
+            params.termCorpusId = selectedCollectionId;
+        }
+        return this.http.post(url, params, { headers }).pipe(map((response) => {
+            if (response.success) {
+                const error = { ErrorCode: ErrorCode.CANT_START_FILE_TRANSLATION };
+                this.alerts.unhandeledError(error);
+                throw error;
+            }
+            return response;
+        }));
+    }
+    remove(properties) {
+        if (!properties.file.id) {
+            return of(true);
+        }
+        const methodName = "Delete";
+        const url = this.config.fileConfig.fileApiUrl + methodName;
+        const params = { docId: properties.file.id };
+        const headers = Common.getAuthHeaders(this.config);
+        return this.http.get(url, { params: params, headers: headers });
+    }
+    sourceFilePreview(file) {
+        const methodName = "Upload";
+        const url = this.config.fileConfig.fileApiUrl + methodName;
+        const headers = this.getAuthHeaders();
+        delete headers['Content-Type'];
+        const formData = new FormData();
+        formData.append("file", file.file);
+        return this.http.post(url, formData, { headers: new HttpHeaders(headers), reportProgress: true, observe: "events" })
+            .pipe(map((response) => {
+            const returnvalue = {};
+            if (response.type === HttpEventType.Response) {
+                const body = response.body;
+                if (!body.success) {
+                    console.error(body.error);
+                    throw "Failed to load translation preview";
+                }
+                returnvalue.isFilePreviewLoaded = body.success;
+                returnvalue.tmpName = body.filename;
+                returnvalue.sourcePreviewHasHtml = !body.preview.includes("class=\"no-preview");
+                returnvalue.sourcePreview = body.preview;
+                returnvalue.wordCount = body.wordcount;
+            }
+            else if (response.type === HttpEventType.UploadProgress) {
+                returnvalue.percentDone = Math.round(100 * response.loaded / response.total);
+            }
+            return returnvalue;
+        }));
+    }
+    getStatus(properties) {
+        const methodName = "GetStatus";
+        const url = this.config.fileConfig.fileApiUrl + methodName;
+        return this.http.post(url, { docId: properties.file.id }, { headers: this.getAuthHeaders() }).pipe(map((response) => {
+            if (typeof (response) == 'string') {
+                const error = { ErrorCode: response };
+                this.alerts.unhandeledError(error);
+                throw error;
+            }
+            const returnvalue = {
+                name: response.filename,
+                progress: response.completed,
+                translationStatuss: response.status.toUpperCase(),
+                extensions: this.getExtensionArray(response.translations, response.filename)
+            };
+            if (this._sourceDownloadStatusses.includes(returnvalue.translationStatuss)
+                && this.config.fileConfig.sourceDownloadExtensions?.includes(properties.file.originalExtension)) {
+                returnvalue.sourceDownloadAvailable = true;
+            }
+            return returnvalue;
+        }));
+    }
+    getExtensionArray(translations, fileName) {
+        if (!translations || !fileName) {
+            return [];
+        }
+        const array = [];
+        for (const key in translations) {
+            if (key == "tmx") {
+                if (!((this.config.coreConfig.isAuth && this.config.fileConfig.allowTmxAuth)
+                    || (!this.config.coreConfig.isAuth && this.config.fileConfig.allowTmxUnauth))) {
+                    continue;
+                }
+            }
+            array.push({ extension: key, fileName: translations[key] });
+        }
+        const fileExtension = fileName.slice(fileName.lastIndexOf(".") + 1).toLowerCase();
+        const extensionOrderArray = this.config.fileConfig.targetDownloadExtensionOrder;
+        const defaultOrder = [fileExtension, "tmx"];
+        const correctOrder = extensionOrderArray && extensionOrderArray[fileExtension] ? extensionOrderArray[fileExtension] : defaultOrder;
+        array.sort((a, b) => {
+            let aIx = correctOrder.indexOf(a.extension);
+            let bIx = correctOrder.indexOf(b.extension);
+            // elements that doesn't exist in config, should be in last position.
+            if (aIx < 0) {
+                aIx = 100;
+            }
+            if (bIx < 0) {
+                bIx = 100;
+            }
+            return aIx - bIx;
+        });
+        return array;
+    }
+    getAuthHeaders() {
+        return Common.getAuthHeaders(this.config);
+    }
+}
+TldTranslateFileApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateFileApiService, deps: [{ token: i1.HttpClient }, { token: i2.TldTranslateConfigService }, { token: i3.TldTermCollectionsService }, { token: i2.TldAlertService }], target: i0.ɵɵFactoryTarget.Injectable });
+TldTranslateFileApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateFileApiService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateFileApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.TldTranslateConfigService }, { type: i3.TldTermCollectionsService }, { type: i2.TldAlertService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-api.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tld-translate/src/lib/modules/tld-document/services/api/file-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpEvent, HttpEventType, HttpHeaders } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable, of } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { Common, ErrorCode, IDownloadFileParams, IFileApiService, IGetFileStatusParams, IGetFileTranslationStatusResponse, IRemoveFileParams, ISourceFilePreviewResponse, IStartFileTranslationParams, ITldError, ITranslatedDocumentPreviewParams } from '../../../tld-common/models';\r\nimport { IFileMeta } from '../../../tld-common/models/services/file-api/file-meta.model';\r\nimport { TldAlertService, TldTranslateConfigService } from '../../../tld-common/services';\r\nimport { TldTermCollectionsService } from '../../../tld-term/services';\r\nimport { ITranslationFile } from '../../models/translate-file.model';\r\nimport { TranslationStatuss } from '../../models/translation-statuss.model';\r\nimport { IFilePreviewV1ProgressResponse } from './models/file-preview-v1-progress-response.model';\r\nimport { IFilePreviewV1ResponseBody } from './models/file-preview-v1-response-body.model';\r\nimport { IGetFileTranslationStatusV1Response } from './models/get-file-translation-status-v1-response.model';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class TldTranslateFileApiService implements IFileApiService {\r\n\r\n  constructor(private readonly http: HttpClient,\r\n    private readonly config: TldTranslateConfigService,\r\n    private readonly collectionService: TldTermCollectionsService,\r\n    private readonly alerts: TldAlertService) { }\r\n\r\n  private readonly _segmentLimit = -1;\r\n  private readonly _sourceDownloadStatusses = [TranslationStatuss.WAITING, TranslationStatuss.SAVING, TranslationStatuss.COMPLETED, TranslationStatuss.TRANSLATING];\r\n\r\n  translatedDocumentPreview(properties: ITranslatedDocumentPreviewParams) {\r\n    const previewMethodName = \"GetDocumentPreview\";\r\n    const params = { docId: properties.translationDocId, fileName: properties.fileName };\r\n    const url = this.config.fileConfig.fileApiUrl + previewMethodName;\r\n    const headers = this.getAuthHeaders();\r\n    return this.http.post(url, params, { headers });\r\n  }\r\n\r\n  download(properties: IDownloadFileParams) {\r\n    const methodName = \"Download\";\r\n    const url = this.config.fileConfig.fileApiUrl + methodName;\r\n    const params = { docId: properties.id, fileName: properties.fileMeta.fileName };\r\n    const headers = Common.getAuthHeaders(this.config);\r\n    return this.http.get(url, { params: params, headers: headers, responseType: \"blob\" });\r\n  }\r\n\r\n  startTranslation(properties: IStartFileTranslationParams): Observable<string> {\r\n    const headers = this.getAuthHeaders();\r\n    const methodName = \"StartTranslation\";\r\n    const url = this.config.fileConfig.fileApiUrl + methodName;\r\n\r\n    //translationFile.lastTranslationAuthHeaders = headers;\r\n    // TODO. Create type for params.\r\n    const params: any = {\r\n      systemId: properties.system.id,\r\n      appId: this.config.coreConfig.appId,\r\n      fileName: properties.file.originalFileName,\r\n      tmpname: properties.file.tmpName,\r\n      wordLimit: this.config.fileConfig.wordLimit,\r\n      segmentLimit: this._segmentLimit,\r\n      ocrPageLimit: this.config.fileConfig.ocrPageLimit\r\n    };\r\n\r\n\r\n    const selectedCollectionId = this.collectionService.selectedIdForTranslation();\r\n    if (selectedCollectionId) {\r\n      params.termCorpusId = selectedCollectionId;\r\n    }\r\n\r\n    return this.http.post(url, params, { headers }).pipe(\r\n      map((response: any) => {\r\n        if (response.success) {\r\n          const error = { ErrorCode: ErrorCode.CANT_START_FILE_TRANSLATION } as ITldError;\r\n          this.alerts.unhandeledError(error);\r\n          throw error;\r\n        }\r\n        return response as string;\r\n      })\r\n    );\r\n  }\r\n\r\n  remove(properties: IRemoveFileParams) {\r\n    if (!properties.file.id) {\r\n      return of(true);\r\n    }\r\n    const methodName = \"Delete\";\r\n    const url = this.config.fileConfig.fileApiUrl + methodName;\r\n    const params = { docId: properties.file.id };\r\n    const headers = Common.getAuthHeaders(this.config);\r\n    return this.http.get(url, { params: params, headers: headers });\r\n  }\r\n\r\n  sourceFilePreview(file: ITranslationFile): Observable<ISourceFilePreviewResponse> {\r\n    const methodName = \"Upload\";\r\n    const url = this.config.fileConfig.fileApiUrl + methodName;\r\n\r\n    const headers = this.getAuthHeaders();\r\n    delete headers['Content-Type'];\r\n\r\n    const formData: FormData = new FormData();\r\n    formData.append(\"file\", file.file);\r\n    return this.http.post<IFilePreviewV1ProgressResponse | IFilePreviewV1ResponseBody>\r\n      (url, formData, { headers: new HttpHeaders(headers), reportProgress: true, observe: \"events\" })\r\n      .pipe(map((response: HttpEvent<IFilePreviewV1ProgressResponse> | HttpEvent<IFilePreviewV1ResponseBody>) => {\r\n        const returnvalue: ISourceFilePreviewResponse = {}\r\n        if (response.type === HttpEventType.Response) {\r\n          const body = response.body as IFilePreviewV1ResponseBody;\r\n          if (!body.success) {\r\n            console.error(body.error);\r\n            throw \"Failed to load translation preview\";\r\n          }\r\n          returnvalue.isFilePreviewLoaded = body.success;\r\n          returnvalue.tmpName = body.filename;\r\n          returnvalue.sourcePreviewHasHtml = !body.preview.includes(\"class=\\\"no-preview\");\r\n          returnvalue.sourcePreview = body.preview;\r\n          returnvalue.wordCount = body.wordcount;\r\n        }\r\n        else if (response.type === HttpEventType.UploadProgress) {\r\n          returnvalue.percentDone = Math.round(100 * response.loaded / response.total);\r\n        }\r\n        return returnvalue;\r\n      }));\r\n  }\r\n\r\n  getStatus(properties: IGetFileStatusParams): Observable<IGetFileTranslationStatusResponse> {\r\n    const methodName = \"GetStatus\";\r\n    const url = this.config.fileConfig.fileApiUrl + methodName;\r\n    return this.http.post<IGetFileTranslationStatusV1Response>(url, { docId: properties.file.id }, { headers: this.getAuthHeaders() }).pipe(\r\n      map((response) => {\r\n        if (typeof (response) == 'string') {\r\n          const error: ITldError = { ErrorCode: response };\r\n          this.alerts.unhandeledError(error);\r\n          throw error;\r\n        }\r\n        const returnvalue: IGetFileTranslationStatusResponse = {\r\n          name: response.filename,\r\n          progress: response.completed,\r\n          translationStatuss: response.status.toUpperCase() as TranslationStatuss,\r\n          extensions: this.getExtensionArray(response.translations, response.filename)\r\n        };\r\n        if (this._sourceDownloadStatusses.includes(returnvalue.translationStatuss)\r\n          && this.config.fileConfig.sourceDownloadExtensions?.includes(properties.file.originalExtension)) {\r\n          returnvalue.sourceDownloadAvailable = true;\r\n        }\r\n        return returnvalue;\r\n      })\r\n    );\r\n  }\r\n\r\n  private getExtensionArray(translations: { [key: string]: string }, fileName: string) {\r\n    if (!translations || !fileName) {\r\n      return [];\r\n    }\r\n    const array: IFileMeta[] = [];\r\n    for (const key in translations) {\r\n      if (key == \"tmx\") {\r\n        if (!((this.config.coreConfig.isAuth && this.config.fileConfig.allowTmxAuth)\r\n          || (!this.config.coreConfig.isAuth && this.config.fileConfig.allowTmxUnauth))) {\r\n          continue;\r\n        }\r\n      }\r\n      array.push({ extension: key, fileName: translations[key] });\r\n    }\r\n    const fileExtension = fileName.slice(fileName.lastIndexOf(\".\") + 1).toLowerCase();\r\n\r\n    const extensionOrderArray = this.config.fileConfig.targetDownloadExtensionOrder;\r\n    const defaultOrder = [fileExtension, \"tmx\"];\r\n    const correctOrder = extensionOrderArray && extensionOrderArray[fileExtension] ? extensionOrderArray[fileExtension] : defaultOrder;\r\n    array.sort((a, b) => {\r\n      let aIx = correctOrder.indexOf(a.extension);\r\n      let bIx = correctOrder.indexOf(b.extension);\r\n\r\n      // elements that doesn't exist in config, should be in last position.\r\n      if (aIx < 0) {\r\n        aIx = 100;\r\n      }\r\n      if (bIx < 0) {\r\n        bIx = 100;\r\n      }\r\n\r\n      return aIx - bIx;\r\n    })\r\n    return array;\r\n  }\r\n\r\n  private getAuthHeaders() {\r\n    return Common.getAuthHeaders(this.config);\r\n  }\r\n}\r\n"]}

package/esm2020/lib/modules/tld-document/services/api/models/file-preview-v1-progress-response.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1wcmV2aWV3LXYxLXByb2dyZXNzLXJlc3BvbnNlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdGxkLXRyYW5zbGF0ZS9zcmMvbGliL21vZHVsZXMvdGxkLWRvY3VtZW50L3NlcnZpY2VzL2FwaS9tb2RlbHMvZmlsZS1wcmV2aWV3LXYxLXByb2dyZXNzLXJlc3BvbnNlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwRXZlbnRUeXBlIH0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vbi9odHRwXCI7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIElGaWxlUHJldmlld1YxUHJvZ3Jlc3NSZXNwb25zZSB7XHJcbiAgICB0eXBlOiBIdHRwRXZlbnRUeXBlLFxyXG4gICAgbG9hZGVkOiBudW1iZXI7XHJcbiAgICB0b3RhbDogbnVtYmVyO1xyXG59Il19

package/esm2020/lib/modules/tld-document/services/api/models/file-preview-v1-response-body.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1wcmV2aWV3LXYxLXJlc3BvbnNlLWJvZHkubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtZG9jdW1lbnQvc2VydmljZXMvYXBpL21vZGVscy9maWxlLXByZXZpZXctdjEtcmVzcG9uc2UtYm9keS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBJRmlsZVByZXZpZXdWMVJlc3BvbnNlQm9keXtcclxuICAgIGRldExhbmc6IHN0cmluZztcclxuICAgIGZpbGVuYW1lOiBzdHJpbmc7XHJcbiAgICBwcmV2aWV3OiBzdHJpbmc7XHJcbiAgICBzdWNjZXNzOiBib29sZWFuO1xyXG4gICAgd29yZGNvdW50OiBudW1iZXI7XHJcbiAgICBlcnJvcjogYW55O1xyXG59Il19

package/esm2020/lib/modules/tld-document/services/api/models/get-file-translation-status-v1-response.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWZpbGUtdHJhbnNsYXRpb24tc3RhdHVzLXYxLXJlc3BvbnNlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdGxkLXRyYW5zbGF0ZS9zcmMvbGliL21vZHVsZXMvdGxkLWRvY3VtZW50L3NlcnZpY2VzL2FwaS9tb2RlbHMvZ2V0LWZpbGUtdHJhbnNsYXRpb24tc3RhdHVzLXYxLXJlc3BvbnNlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUcmFuc2xhdGlvblN0YXR1c3MgfSBmcm9tICcuLi8uLi8uLi9tb2RlbHMnO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBJR2V0RmlsZVRyYW5zbGF0aW9uU3RhdHVzVjFSZXNwb25zZSB7XHJcbiAgc3RhdHVzOiBUcmFuc2xhdGlvblN0YXR1c3M7XHJcbiAgY29tcGxldGVkOiBudW1iZXI7XHJcbiAgZmlsZW5hbWU6IHN0cmluZztcclxuICB3YXJuaW5nczogc3RyaW5nO1xyXG4gIHJlbG9hZDogYm9vbGVhbjtcclxuICB0cmFuc2xhdGlvbnM6IHsgW2tleTogc3RyaW5nXTogc3RyaW5nIH07XHJcbn1cclxuIl19

package/esm2020/lib/modules/tld-document/services/api-v2/file-api-v2.service.mjs

@@ -0,0 +1,87 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Common } from '../../../tld-common/models';
+import { FileV2Category } from './models/file-category-v2.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../tld-common/services";
+export class FileApiV2Service {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+    }
+    get url() {
+        return this.config.apiV2Config.fileTranslationUrl;
+    }
+    translatedDocumentPreview(properties) {
+        properties;
+        return of({ success: true });
+    }
+    download(properties) {
+        const headers = Common.GetApiV2AuthHeaders(this.config);
+        return this.http.get(`${this.url}/${properties.id}/${properties.fileMeta.id}`, { responseType: "blob", headers });
+    }
+    startTranslation(properties) {
+        const formData = new FormData();
+        formData.append("file", properties.file.file);
+        formData.append("fileName", properties.file.originalFileName);
+        formData.append("sourceLanguage", properties.system.sourceLanguage);
+        formData.append("targetLanguage", properties.system.targetLanguage);
+        if (properties.system.domain) {
+            formData.append("domain", properties.system.domain);
+        }
+        const headers = Common.GetApiV2AuthHeaders(this.config);
+        return this.http.post(this.url, formData, { headers }).pipe(map(response => response.id));
+    }
+    remove(properties) {
+        if (properties.file.translationStartedOnServer) {
+            const headers = Common.GetApiV2AuthHeaders(this.config);
+            return this.http.delete(`${this.url}/${properties.file.id}`, { headers });
+        }
+        return of();
+    }
+    sourceFilePreview(file) {
+        const extension = file.originalExtension.toLowerCase();
+        const sourcePreview = `<div id="docPreviewContent" class="no-preview type-${extension}"><div class="type">${extension.toUpperCase()}</div></div>`;
+        return of({
+            isFilePreviewLoaded: true,
+            sourcePreviewHasHtml: false,
+            tmpName: file.originalFileName,
+            name: file.originalFileName,
+            sourcePreview: sourcePreview
+        });
+    }
+    getStatus(properties) {
+        const headers = Common.GetApiV2AuthHeaders(this.config);
+        return this.http.get(`${this.url}/${properties.file.id}`, { headers }).pipe(map((response) => {
+            const extensions = [];
+            response.files.forEach((file) => {
+                if (file.category.toUpperCase() === FileV2Category.TRANSLATED) {
+                    const fileName = `${properties.file.originalFileName.slice(0, properties.file.originalFileName.lastIndexOf("."))}${file.extension}`;
+                    extensions.push({ extension: file.extension, fileName: fileName, id: file.id });
+                }
+            });
+            const returnValue = {
+                name: response.fileName,
+                progress: Math.floor(response.translatedSegments / response.segments * 100),
+                translationStatuss: response.status.toUpperCase(),
+                sourceDownloadAvailable: false,
+                extensions: extensions
+            };
+            if (response.substatus) {
+                returnValue.substatus = Common.pascalCaseToEnum(response.substatus);
+            }
+            return returnValue;
+        }));
+    }
+}
+FileApiV2Service.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FileApiV2Service, deps: [{ token: i1.HttpClient }, { token: i2.TldTranslateConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+FileApiV2Service.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FileApiV2Service, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FileApiV2Service, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.TldTranslateConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-api-v2.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tld-translate/src/lib/modules/tld-document/services/api-v2/file-api-v2.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable, of } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { Common, FileTranslationSubstatus, IDownloadFileParams, IFileApiService, IFileMeta, IGetFileStatusParams, IGetFileTranslationStatusResponse, IRemoveFileParams, ISourceFilePreviewResponse, IStartFileTranslationParams, ITranslatedDocumentPreviewParams } from '../../../tld-common/models';\r\nimport { TldTranslateConfigService } from '../../../tld-common/services';\r\nimport { ITranslationFile } from '../../models/translate-file.model';\r\nimport { TranslationStatuss } from '../../models/translation-statuss.model';\r\nimport { FileV2Category } from './models/file-category-v2.model';\r\nimport { IFileTranslationStatusV2Response } from './models/file-translation-status-v2-response.model';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class FileApiV2Service implements IFileApiService {\r\n\r\n  private get url() {\r\n    return this.config.apiV2Config.fileTranslationUrl;\r\n  }\r\n\r\n  constructor(private readonly http: HttpClient,\r\n    private readonly config: TldTranslateConfigService) { }\r\n\r\n\r\n  translatedDocumentPreview(properties: ITranslatedDocumentPreviewParams) {\r\n    properties;\r\n    return of({ success: true });\r\n  }\r\n\r\n  download(properties: IDownloadFileParams) {\r\n    const headers = Common.GetApiV2AuthHeaders(this.config);\r\n    return this.http.get(`${this.url}/${properties.id}/${properties.fileMeta.id}`, { responseType: \"blob\", headers });\r\n  }\r\n\r\n  startTranslation(properties: IStartFileTranslationParams): Observable<string> {\r\n    const formData: FormData = new FormData();\r\n    formData.append(\"file\", properties.file.file);\r\n    formData.append(\"fileName\", properties.file.originalFileName);\r\n    formData.append(\"sourceLanguage\", properties.system.sourceLanguage);\r\n    formData.append(\"targetLanguage\", properties.system.targetLanguage);\r\n\r\n    if (properties.system.domain) {\r\n      formData.append(\"domain\", properties.system.domain);\r\n    }\r\n\r\n    const headers = Common.GetApiV2AuthHeaders(this.config);\r\n\r\n\r\n    return this.http.post<IFileTranslationStatusV2Response>(this.url, formData, { headers }).pipe(\r\n      map(response => response.id)\r\n    );\r\n  }\r\n\r\n  remove(properties: IRemoveFileParams): Observable<any> {\r\n    if (properties.file.translationStartedOnServer) {\r\n      const headers = Common.GetApiV2AuthHeaders(this.config);\r\n      return this.http.delete(`${this.url}/${properties.file.id}`, { headers });\r\n    }\r\n    return of();\r\n  }\r\n\r\n  sourceFilePreview(file: ITranslationFile): Observable<ISourceFilePreviewResponse> {\r\n    const extension = file.originalExtension.toLowerCase();\r\n    const sourcePreview = `<div id=\"docPreviewContent\" class=\"no-preview type-${extension}\"><div class=\"type\">${extension.toUpperCase()}</div></div>`;\r\n    return of({\r\n      isFilePreviewLoaded: true,\r\n      sourcePreviewHasHtml: false,\r\n      tmpName: file.originalFileName,\r\n      name: file.originalFileName,\r\n      sourcePreview: sourcePreview\r\n    })\r\n  }\r\n\r\n  getStatus(properties: IGetFileStatusParams): Observable<IGetFileTranslationStatusResponse> {\r\n    const headers = Common.GetApiV2AuthHeaders(this.config);\r\n\r\n    return this.http.get<IFileTranslationStatusV2Response>(`${this.url}/${properties.file.id}`, { headers }).pipe(\r\n      map((response) => {\r\n        const extensions: IFileMeta[] = [];\r\n        response.files.forEach((file) => {\r\n          if (file.category.toUpperCase() === FileV2Category.TRANSLATED) {\r\n            const fileName = `${properties.file.originalFileName.slice(0, properties.file.originalFileName.lastIndexOf(\".\"))}${file.extension}`;\r\n            extensions.push({ extension: file.extension, fileName: fileName, id: file.id });\r\n          }\r\n        })\r\n        const returnValue: IGetFileTranslationStatusResponse = {\r\n          name: response.fileName,\r\n          progress: Math.floor(response.translatedSegments / response.segments * 100),\r\n          translationStatuss: response.status.toUpperCase() as TranslationStatuss,\r\n          sourceDownloadAvailable: false,\r\n          extensions: extensions\r\n        };\r\n\r\n        if (response.substatus) {\r\n          returnValue.substatus = Common.pascalCaseToEnum(response.substatus) as FileTranslationSubstatus;\r\n        }\r\n        return returnValue;\r\n      })\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2020/lib/modules/tld-document/services/api-v2/models/file-category-v2.model.mjs

@@ -0,0 +1,6 @@
+export var FileV2Category;
+(function (FileV2Category) {
+    FileV2Category["SOURCE"] = "SOURCE";
+    FileV2Category["TRANSLATED"] = "TRANSLATED";
+})(FileV2Category || (FileV2Category = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1jYXRlZ29yeS12Mi5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RsZC10cmFuc2xhdGUvc3JjL2xpYi9tb2R1bGVzL3RsZC1kb2N1bWVudC9zZXJ2aWNlcy9hcGktdjIvbW9kZWxzL2ZpbGUtY2F0ZWdvcnktdjIubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksY0FHWDtBQUhELFdBQVksY0FBYztJQUN0QixtQ0FBaUIsQ0FBQTtJQUNqQiwyQ0FBeUIsQ0FBQTtBQUM3QixDQUFDLEVBSFcsY0FBYyxLQUFkLGNBQWMsUUFHekIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBGaWxlVjJDYXRlZ29yeXtcclxuICAgIFNPVVJDRSA9IFwiU09VUkNFXCIsXHJcbiAgICBUUkFOU0xBVEVEID0gXCJUUkFOU0xBVEVEXCJcclxufSJdfQ==

package/esm2020/lib/modules/tld-document/services/api-v2/models/file-translation-status-v2-response.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS10cmFuc2xhdGlvbi1zdGF0dXMtdjItcmVzcG9uc2UubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtZG9jdW1lbnQvc2VydmljZXMvYXBpLXYyL21vZGVscy9maWxlLXRyYW5zbGF0aW9uLXN0YXR1cy12Mi1yZXNwb25zZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiXHJcbmV4cG9ydCBpbnRlcmZhY2UgSUZpbGVUcmFuc2xhdGlvblN0YXR1c1YyUmVzcG9uc2Uge1xyXG4gICAgaWQ6IHN0cmluZyxcclxuICAgIGNyZWF0ZWRBdDogc3RyaW5nLFxyXG4gICAgZmlsZU5hbWU6IHN0cmluZyxcclxuICAgIHNyY0xhbmc6IHN0cmluZyxcclxuICAgIHRyZ0xhbmc6IHN0cmluZyxcclxuICAgIGRvbWFpbjogc3RyaW5nLFxyXG4gICAgc3RhdHVzOiBzdHJpbmcsXHJcbiAgICBzdWJzdGF0dXM6IHN0cmluZyxcclxuICAgIHNlZ21lbnRzOiBudW1iZXIsXHJcbiAgICB0cmFuc2xhdGVkU2VnbWVudHM6IG51bWJlcixcclxuICAgIGZpbGVzOiBbXHJcbiAgICAgICAge1xyXG4gICAgICAgICAgICBpZDogc3RyaW5nLFxyXG4gICAgICAgICAgICBjYXRlZ29yeTogc3RyaW5nLFxyXG4gICAgICAgICAgICBleHRlbnNpb246IHN0cmluZyxcclxuICAgICAgICAgICAgc2l6ZTogMFxyXG4gICAgICAgIH1cclxuICAgIF1cclxufSJdfQ==

package/esm2020/lib/modules/tld-document/services/index.mjs

@@ -0,0 +1,3 @@
+export * from './api/file-api.service';
+export * from './tld-translate-file.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtZG9jdW1lbnQvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hcGkvZmlsZS1hcGkuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdGxkLXRyYW5zbGF0ZS1maWxlLnNlcnZpY2UnOyJdfQ==