@tilde-nlp/ngx-common 4.0.7 → 4.0.9

package/esm2022/lib/terminology/models/vendor.model.mjs

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

package/esm2022/lib/terminology/services/engine-term-api/engine-term-api.service.mjs

@@ -0,0 +1,51 @@
+import { Injectable } from '@angular/core';
+import { AuthHeadersHelper } from '../../../helpers';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../config/services";
+export class EngineTermApiService {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        this.baseUrl = this.config?.termConfig?.engineTermUrl;
+    }
+    add(engineId, params) {
+        const data = new FormData();
+        data.append("collectionId", params.collectionId);
+        data.append("collectionSource", params.collectionSource);
+        if (params.access.global?.default !== undefined) {
+            data.append("access.Global.Default", params.access.global?.default.toString());
+        }
+        if (params.access.group?.default !== undefined) {
+            data.append("access.Group.Default", params.access.group?.default.toString());
+        }
+        if (params.access.user?.default !== undefined) {
+            data.append("access.User.Default", params.access.user?.default.toString());
+        }
+        return this.http.post(`${this.baseUrl}/${engineId}/terms`, data);
+    }
+    update(engineId, collectionId, params) {
+        return this.http.put(`${this.baseUrl}/${engineId}/terms/${collectionId}`, params);
+    }
+    getList(engineId) {
+        return this.http.get(`${this.baseUrl}/${engineId}/terms`, { params: { engineId }, headers: AuthHeadersHelper.getApiV2AuthHeaders(this.config.termConfig.xApiKey ?? '', this.config.termConfig.appId ?? '') });
+    }
+    remove(engineId, collectionId) {
+        return this.http.delete(`${this.baseUrl}/${engineId}/terms/${collectionId}`);
+    }
+    order(engineId, orderUpdate) {
+        return this.http.post(`${this.baseUrl}/${engineId}/terms/order`, orderUpdate);
+    }
+    sync(engineId, collectionId) {
+        return this.http.post(`${this.baseUrl}/${engineId}/terms/${collectionId}/sync`, {});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EngineTermApiService, deps: [{ token: i1.HttpClient }, { token: i2.TerminologyConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EngineTermApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EngineTermApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.TerminologyConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/terminology/services/engine-term-api/index.mjs

@@ -0,0 +1,2 @@
+export * from './engine-term-api.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY29tbW9uL3NyYy9saWIvdGVybWlub2xvZ3kvc2VydmljZXMvZW5naW5lLXRlcm0tYXBpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2VuZ2luZS10ZXJtLWFwaS5zZXJ2aWNlJzsiXX0=

package/esm2022/lib/terminology/services/index.mjs

@@ -0,0 +1,6 @@
+export * from './terminology/terminology.service';
+export * from './engine-term-api/';
+export * from './terminology-collection/';
+export * from './terminology-api-v1/terminology-api-v1.service';
+export * from './terminology-api-v2/terminology-api-v2.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY29tbW9uL3NyYy9saWIvdGVybWlub2xvZ3kvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLGlEQUFpRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90ZXJtaW5vbG9neS90ZXJtaW5vbG9neS5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9lbmdpbmUtdGVybS1hcGkvJztcclxuZXhwb3J0ICogZnJvbSAnLi90ZXJtaW5vbG9neS1jb2xsZWN0aW9uLyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdGVybWlub2xvZ3ktYXBpLXYxL3Rlcm1pbm9sb2d5LWFwaS12MS5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi90ZXJtaW5vbG9neS1hcGktdjIvdGVybWlub2xvZ3ktYXBpLXYyLnNlcnZpY2UnOyJdfQ==

package/esm2022/lib/terminology/services/system-api-v1/system-api-v1.service.mjs

@@ -0,0 +1,57 @@
+import { Injectable } from "@angular/core";
+import { map } from "rxjs";
+import { TranslationApiVersion } from "../../enums/translation-api-version.model";
+import { SystemMetadataKey } from "../../enums/system-metadata-key.enum";
+import { AuthHeadersHelper } from "../../../helpers";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../config/services";
+export class SystemApiV1Service {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+    }
+    getSystemList() {
+        const headers = AuthHeadersHelper.getAuthHeaders(this.config.termConfig.clientId);
+        const params = {
+            appID: this.config.termConfig.appId,
+        };
+        return this.http.get(this.config?.termConfig?.systemListUrl, { headers, params }).pipe(map((response) => {
+            const systems = [];
+            response.System.forEach((element) => {
+                const system = {
+                    sourceLanguage: element.SourceLanguage.Code,
+                    targetLanguage: element.TargetLanguage.Code,
+                    id: element.ID,
+                    domain: element.Domain,
+                    vendor: this.findMetaDataValue(element, SystemMetadataKey.VENDOR) ?? this.config.termConfig.defaultVendor,
+                    includesTerminology: this.findMetaDataValue(element, SystemMetadataKey.INCLUDE_TERMINOLOGY_WORKFLOW),
+                    status: this.findMetaDataValue(element, SystemMetadataKey.STATUS),
+                    translationApiVersion: TranslationApiVersion.V1,
+                    title: element.Title.Text,
+                };
+                if (this.config.termConfig.allowedSystemStatuses && this.config.termConfig.allowedSystemStatuses.indexOf(system.status) !== -1) {
+                    systems.push(system);
+                }
+            });
+            return systems;
+        }));
+    }
+    findMetaDataValue(system, metadataKey) {
+        for (const metadata of system.Metadata) {
+            if (metadata.Key === metadataKey) {
+                return metadata.Value;
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SystemApiV1Service, deps: [{ token: i1.HttpClient }, { token: i2.TerminologyConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SystemApiV1Service, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SystemApiV1Service, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.TerminologyConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/terminology/services/system-api-v2/system-api-v2.service.mjs

@@ -0,0 +1,63 @@
+import { Injectable } from "@angular/core";
+import { map } from "rxjs";
+import { TranslationApiVersion } from "../../enums/translation-api-version.model";
+import { AuthHeadersHelper } from "../../../helpers";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../config/services";
+export class SystemApiV2Service {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+    }
+    getSystemList() {
+        const headers = AuthHeadersHelper.getApiV2AuthHeaders(this.config.termConfig.xApiKey ?? '', this.config.termConfig.appId ?? '');
+        return this.http.get(this.config.termConfig.systemListUrl, { headers }).pipe(map((response) => {
+            const systems = [];
+            const uniqueDirections = [];
+            const autoDomainSystems = [];
+            response.languageDirections.forEach((system) => {
+                const languageDirections = `${system.srcLang}-${system.trgLang}`;
+                const newSystem = {
+                    domain: system.domain,
+                    id: system.id,
+                    sourceLanguage: system.srcLang,
+                    targetLanguage: system.trgLang,
+                    translationApiVersion: TranslationApiVersion.V2,
+                    vendor: system.vendor,
+                    // hardcoded since there is no param yet for determinig which systems support terms.
+                    includesTerminology: system.supportsTermCollections,
+                };
+                systems.push(newSystem);
+                if (this.config.termConfig?.autoDomainDetection && !uniqueDirections.includes(languageDirections)) {
+                    uniqueDirections.push(languageDirections);
+                    const autoDomainSystem = this.createSystemFromLanguageDirection(system);
+                    autoDomainSystem.domain = null;
+                    autoDomainSystem.id = languageDirections;
+                    autoDomainSystems.push(autoDomainSystem);
+                }
+            });
+            return autoDomainSystems.concat(systems);
+        }));
+    }
+    createSystemFromLanguageDirection(direction) {
+        const systemBase = {
+            sourceLanguage: direction.srcLang,
+            targetLanguage: direction.trgLang,
+            domain: direction.domain,
+            translationApiVersion: TranslationApiVersion.V2,
+            id: `${direction.srcLang}-${direction.trgLang}-${direction.domain}`,
+            vendor: direction.vendor,
+        };
+        return systemBase;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SystemApiV2Service, deps: [{ token: i1.HttpClient }, { token: i2.TerminologyConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SystemApiV2Service, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SystemApiV2Service, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.TerminologyConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/terminology/services/terminology/terminology.service.mjs

@@ -0,0 +1,309 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, Subject, forkJoin, of, tap } from 'rxjs';
+import { CombinedCollection } from '../../models';
+import { TERMINOLOGY_API_TOKEN } from '../../injection-tokens/terminology-api.token';
+import { EngineTermCollectionSource, MtCollectionStatus } from '../../enums';
+import * as i0 from "@angular/core";
+import * as i1 from "../../config/services";
+import * as i2 from "../../../services";
+import * as i3 from "../terminology-collection/terminology-collection.service";
+export class TerminologyService {
+    get isAuthenticated() { return this.config.termConfig.isAuth; }
+    get canCreateCollections() { return this.config.termConfig.canCreateCollection; }
+    get hasEditPermissions() {
+        return (this.config?.termConfig.isAuth &&
+            this.canCreateCollections &&
+            this.config.termConfig.isTermPortalSupported);
+    }
+    constructor(config, alert, termCollectionApi, mtApi) {
+        this.config = config;
+        this.alert = alert;
+        this.termCollectionApi = termCollectionApi;
+        this.mtApi = mtApi;
+        this.engines = {};
+        this.engineSubject = new BehaviorSubject(this.engines);
+        this.updatedEnginesSubject = new Subject();
+        this.LOCAL_STORAGE_KEY = 'systemLastCollections';
+    }
+    hasAnyCollections(systemId) { return this.engines[systemId]?.collections.size > 0; }
+    getEnginesWithSelectedCollectionChange() {
+        return this.updatedEnginesSubject.asObservable();
+    }
+    setEngine(engineId, languages = null, setSelectedFromLocalStorage = false, termCollections = true, mtCollections = true, selectedCollection) {
+        const engineExists = this.engines[engineId] ?? null;
+        if (!engineExists) {
+            const newEngine = {
+                selected: selectedCollection || null,
+                isImporting: false,
+                isAnyImporting: false,
+                hasAnyCollections: false,
+                isRefreshingCollections: false,
+                collections: new Set,
+                refreshMtCollections: mtCollections,
+                refreshTermCollections: termCollections,
+                engineLanguages: languages || [],
+                isSoftAutoRefreshOn: false,
+                hardAutoRefresh: false,
+                refreshTimeout: 0
+            };
+            this.engines[engineId] = newEngine;
+        }
+        return this.loadCollections(engineId, setSelectedFromLocalStorage);
+    }
+    setSelectedCollection(engineId, collection) {
+        this.engines[engineId].selected = collection;
+        this.storeSelectedInLocalStorage(engineId);
+    }
+    loadCollections(engineId, setSelectedFromLocalStorage) {
+        // clear timeout since this refresh replaces scheduled
+        this.clearTimeout(engineId);
+        this.engines[engineId] = { ...this.engines[engineId], isRefreshingCollections: true };
+        let termResponse;
+        let mtApiResponse;
+        const observables = [];
+        if (this.engines[engineId].refreshTermCollections) {
+            observables.push(this.termCollectionApi
+                .getCollectionList()
+                .pipe(tap((response) => (termResponse = response))));
+        }
+        if (this.engines[engineId].refreshMtCollections) {
+            observables.push(this.mtApi
+                .getList(engineId)
+                .pipe(tap((response) => (mtApiResponse = response))));
+        }
+        forkJoin(observables).subscribe({
+            // do not need response becaue responses are saved in pipe methods
+            next: () => {
+                this.engines[engineId].isAnyImporting = false;
+                // note that termResponse and mtapiresponse gets changed during remove method
+                this.removeDeleted(termResponse, mtApiResponse, engineId);
+                const joined = [];
+                if (mtApiResponse) {
+                    joined.push(...mtApiResponse);
+                }
+                if (termResponse) {
+                    joined.push(...termResponse);
+                }
+                this.addCollections(joined, engineId);
+                if (setSelectedFromLocalStorage) {
+                    this.setSelectedFromLocalStorage(engineId);
+                }
+                this.engines[engineId].isRefreshingCollections = false;
+                this.scheduleRefresh(engineId, null);
+            },
+            error: (error) => {
+                this.engines[engineId].isRefreshingCollections = false;
+                // it is enough to show error only in console. No special thing is necessary.
+                console.error(error);
+            },
+        });
+        return this.engineSubject.asObservable();
+    }
+    getCollections() {
+        return this.engineSubject.asObservable();
+    }
+    startAutoRefresh(engineId, languages = null, setSelectedFromLocalStorage = false, termCollections = true, mtCollections = true) {
+        const engine = this.engines[engineId] ?? {};
+        engine.hardAutoRefresh = true;
+        return this.setEngine(engineId, languages ?? this.engines[engineId]?.engineLanguages, setSelectedFromLocalStorage, termCollections, mtCollections);
+    }
+    stopAutoRefresh(engineId) {
+        this.clearTimeout(engineId);
+        this.engines[engineId].isSoftAutoRefreshOn = false;
+        this.engines[engineId].hardAutoRefresh = false;
+    }
+    create(sourceLanguage, targetLanguage, collectionName, engineId, redirectToEdit = true) {
+        return this.termCollectionApi
+            .createCollection([sourceLanguage, targetLanguage], collectionName)
+            .pipe(tap((collection) => {
+            if (redirectToEdit) {
+                window.open(this.termCollectionApi.getEditLink(collection.termCollection?.id ?? '', sourceLanguage, targetLanguage), '_blank');
+            }
+            this.engines[engineId]?.collections?.add(collection);
+            this.loadCollections(engineId);
+        }));
+    }
+    selectedIdForTranslation(engineId) {
+        const selected = this.engines[engineId]?.selected;
+        if (selected?.mtCollection &&
+            (selected.mtCollection.lastUpdated ||
+                selected.mtCollection.status === MtCollectionStatus.READY)) {
+            return selected.mtCollection.id;
+        }
+        return null;
+    }
+    updateIfNecessary(collection, engineId, isEdited = false) {
+        // collection is not imported and should be attached to engine
+        if (collection.isEdited() || isEdited) {
+            return this.mtApi.add(engineId, collection).pipe(tap((updatedCollection) => {
+                collection.update(updatedCollection);
+            }));
+        }
+        else {
+            return of(collection);
+        }
+    }
+    handleAddToEngineError(error, engineId) {
+        this.alert.unhandeledError(error);
+        this.engines[engineId].selected = null;
+    }
+    sync(collection, engineId) {
+        return this.mtApi.sync(engineId, collection).pipe(tap((updatedCollection) => {
+            collection.update(updatedCollection);
+        }));
+    }
+    removeMtCollection(collection, engineId) {
+        return this.mtApi.remove(engineId, collection).pipe(tap((response) => {
+            collection.update(response);
+        }));
+    }
+    addToEngineValidation(collection) {
+        if (!collection || !collection.termCollection) {
+            console.error("Trying to attach collection that has no tilde term id.");
+            return false;
+        }
+        return true;
+    }
+    clearTimeout(engineId) {
+        if (this.engines[engineId]?.refreshTimeout) {
+            clearTimeout(this.engines[engineId].refreshTimeout);
+            this.engines[engineId].refreshTimeout = null;
+        }
+    }
+    setSelectedFromLocalStorage(engineId) {
+        // If no collections or selected is already set, it should not be changed from localstorage value. (Usually, localstorage should have the same value).
+        if (this.engines[engineId].collections?.size === 0 || this.engines[engineId].selected) {
+            this.updateSelectedCollectionOutsideService();
+            return;
+        }
+        const storedId = this.readLocalStorage()?.[engineId];
+        if (!storedId) {
+            this.engines[engineId].selected = null;
+            this.updateSelectedCollectionOutsideService();
+            return;
+        }
+        const existing = Array.from(this.engines[engineId].collections).find((item) => item.mtCollection?.id === storedId || item.termCollection?.id === storedId);
+        this.engines[engineId].selected = existing;
+        this.updateSelectedCollectionOutsideService();
+    }
+    removeDeleted(termResponse, mtResponse, engineId) {
+        for (const collection of this.engines[engineId].collections) {
+            const termExistingIx = CombinedCollection.findExistingIndexFromList(termResponse, collection);
+            const mtExistingIx = CombinedCollection.findExistingIndexFromList(mtResponse, collection);
+            if (termExistingIx === null && mtExistingIx === null) {
+                this.engines[engineId]?.collections.delete(collection);
+                if (this.engines[engineId]?.selected === collection) {
+                    this.engines[engineId].selected = null;
+                    this.updateSelectedCollectionOutsideService();
+                }
+            }
+            else {
+                if (termExistingIx !== null) {
+                    const existingTerm = termResponse[termExistingIx];
+                    collection.update(existingTerm);
+                    termResponse.splice(termExistingIx, 1);
+                }
+                else {
+                    collection.deleteTerms();
+                }
+                if (mtExistingIx !== null) {
+                    const existingMt = mtResponse[mtExistingIx];
+                    collection.update(existingMt);
+                    mtResponse.splice(mtExistingIx, 1);
+                }
+                else {
+                    collection.deleteMT();
+                }
+            }
+        }
+    }
+    addCollections(newCollections, engineId) {
+        // sets collection list to this value at the end, so deleted collections are not in the list.
+        for (const collection of newCollections) {
+            // User shouldn't see failed collections if he can't retry to import them.
+            if (!this.hasEditPermissions && collection.mtStatus === MtCollectionStatus.ERROR || collection.mtStatus === MtCollectionStatus.DELETING) {
+                continue;
+            }
+            if (collection.isImporting) {
+                this.engines[engineId].isAnyImporting = true;
+            }
+            const existing = CombinedCollection.findExistingCollectionFromList(this.engines[engineId].collections, collection);
+            // If term api doesn't have engine languages, collection should not be shown (if it is not already imported somehow);
+            if (!existing && collection.source === EngineTermCollectionSource.TILDE_TERM) {
+                let hasLanguages = true;
+                for (let i = 0; i < this.engines[engineId].engineLanguages.length; i++) {
+                    if (!collection.termCollection?.languages?.find((lang) => lang.id === this.engines[engineId].engineLanguages[i])) {
+                        hasLanguages = false;
+                        break;
+                    }
+                }
+                if (!hasLanguages) {
+                    continue;
+                }
+            }
+            if (!existing) {
+                this.engines[engineId].collections.add(collection);
+            }
+            else {
+                existing.update(collection);
+            }
+        }
+        this.engines[engineId].hasAnyCollections = this.engines[engineId].collections.size > 0;
+        this.engineSubject.next(this.engines);
+    }
+    scheduleRefresh(engineId, timeout) {
+        // if menu is closed and selected collection is not importing anymore - auto refreshing should be cancelled.
+        if (!this.engines[engineId].hardAutoRefresh &&
+            !this.engines[engineId]?.isImporting &&
+            this.engines[engineId].isSoftAutoRefreshOn) {
+            this.stopAutoRefresh(engineId);
+            return;
+        }
+        // if hard auto refresho on, auto refresh should be on. If hard autoreferesh is off , refresh needs to be done only if selected is importing.
+        if (this.engines[engineId].hardAutoRefresh ||
+            (!this.engines[engineId] &&
+                (this.engines[engineId].isSoftAutoRefreshOn || this.engines[engineId].selected?.isImporting))) {
+            const timeoutMs = timeout ??
+                (this.engines[engineId].isAnyImporting
+                    ? this.config.termConfig.refreshTimeoutMsWhenImporting
+                    : this.config.termConfig.refreshTimeoutMs);
+            this.engines[engineId].refreshTimeout = setTimeout(() => {
+                this.engines[engineId].refreshTimeout = null;
+                this.loadCollections(engineId);
+            }, timeoutMs);
+        }
+    }
+    storeSelectedInLocalStorage(engineId) {
+        let localStorageObject = this.readLocalStorage();
+        if (!localStorageObject) {
+            localStorageObject = {};
+        }
+        localStorageObject[engineId] = this.engines[engineId].selected ? (this.engines[engineId]?.selected?.mtCollection?.id ?? this.engines[engineId]?.selected?.termCollection?.id) : null;
+        // store term id if it exists
+        localStorage.setItem(this.LOCAL_STORAGE_KEY, JSON.stringify(localStorageObject));
+    }
+    readLocalStorage() {
+        const data = localStorage.getItem(this.LOCAL_STORAGE_KEY);
+        try {
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    updateSelectedCollectionOutsideService() {
+        this.updatedEnginesSubject.next(this.engines);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TerminologyService, deps: [{ token: i1.TerminologyConfigService }, { token: i2.AlertService }, { token: i3.TerminologyCollectionService }, { token: TERMINOLOGY_API_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TerminologyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TerminologyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TerminologyConfigService }, { type: i2.AlertService }, { type: i3.TerminologyCollectionService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TERMINOLOGY_API_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terminology.service.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-common/src/lib/terminology/services/terminology/terminology.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { BehaviorSubject, Observable, Subject, forkJoin, of, tap } from 'rxjs';\r\nimport { CombinedCollection, IMtTermService } from '../../models';\r\nimport { TerminologyConfigService } from '../../config/services';\r\nimport { TERMINOLOGY_API_TOKEN } from '../../injection-tokens/terminology-api.token';\r\nimport { TerminologyCollectionService } from '../terminology-collection/terminology-collection.service';\r\nimport { EngineTermCollectionSource, MtCollectionStatus } from '../../enums';\r\nimport { AlertService } from '../../../services';\r\nimport { TerminologyEngine } from '../../models/terminology-engine.model';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TerminologyService {\r\n  public engines: { [engineId: string]: TerminologyEngine } = {};\r\n\r\n  private engineSubject = new BehaviorSubject(this.engines);\r\n\r\n  private updatedEnginesSubject = new Subject<{[engineId: string]: TerminologyEngine}>();\r\n\r\n  get isAuthenticated() { return this.config.termConfig.isAuth }\r\n  get canCreateCollections() { return this.config.termConfig.canCreateCollection }\r\n\r\n  private readonly LOCAL_STORAGE_KEY = 'systemLastCollections';\r\n\r\n  get hasEditPermissions() {\r\n    return (\r\n      this.config?.termConfig.isAuth &&\r\n      this.canCreateCollections &&\r\n      this.config.termConfig.isTermPortalSupported\r\n    );\r\n  }\r\n\r\n  constructor(\r\n    private readonly config: TerminologyConfigService,\r\n    private readonly alert: AlertService,\r\n    private readonly termCollectionApi: TerminologyCollectionService,\r\n    @Inject(TERMINOLOGY_API_TOKEN) private readonly mtApi: IMtTermService\r\n  ) {}\r\n\r\n  hasAnyCollections(systemId: string): boolean { return this.engines[systemId]?.collections.size > 0 }\r\n\r\n  getEnginesWithSelectedCollectionChange(): Observable<{[engineId: string]: TerminologyEngine}> {\r\n    return this.updatedEnginesSubject.asObservable();\r\n  }\r\n\r\n  setEngine(\r\n    engineId: string,\r\n    languages: string[] | null = null,\r\n    setSelectedFromLocalStorage = false,\r\n    termCollections = true,\r\n    mtCollections = true,\r\n    selectedCollection?: CombinedCollection\r\n  ) {\r\n    const engineExists = this.engines[engineId] ?? null;\r\n\r\n    if (!engineExists) {\r\n      const newEngine: TerminologyEngine = {\r\n        selected: selectedCollection || null,\r\n        isImporting: false,\r\n        isAnyImporting: false,\r\n        hasAnyCollections: false,\r\n        isRefreshingCollections: false,\r\n        collections: new Set<CombinedCollection>,\r\n        refreshMtCollections: mtCollections,\r\n        refreshTermCollections: termCollections,\r\n        engineLanguages: languages || [],\r\n        isSoftAutoRefreshOn: false,\r\n        hardAutoRefresh: false,\r\n        refreshTimeout: 0\r\n      };\r\n\r\n      this.engines[engineId] = newEngine;\r\n    }\r\n\r\n    return this.loadCollections(engineId, setSelectedFromLocalStorage);\r\n  }\r\n\r\n  setSelectedCollection(engineId: string, collection: CombinedCollection | null): void {\r\n    this.engines[engineId].selected = collection;\r\n\r\n    this.storeSelectedInLocalStorage(engineId);\r\n  }\r\n\r\n  loadCollections(engineId: string, setSelectedFromLocalStorage?: boolean): Observable<{[engineId: string]: TerminologyEngine;}> {\r\n      // clear timeout since this refresh replaces scheduled\r\n      this.clearTimeout(engineId);\r\n\r\n      this.engines[engineId] = {...this.engines[engineId], isRefreshingCollections: true}\r\n  \r\n      let termResponse: CombinedCollection[];\r\n      let mtApiResponse: CombinedCollection[];\r\n  \r\n      const observables: Observable<CombinedCollection[]>[] = [];\r\n  \r\n      if (this.engines[engineId].refreshTermCollections) {\r\n        observables.push(\r\n          this.termCollectionApi\r\n            .getCollectionList()\r\n            .pipe(tap((response) => (termResponse = response)))\r\n        );\r\n      }\r\n      if (this.engines[engineId].refreshMtCollections) {\r\n        observables.push(\r\n          this.mtApi\r\n            .getList(engineId)\r\n            .pipe(tap((response) => (mtApiResponse = response)))\r\n        );\r\n      }\r\n      forkJoin(observables).subscribe({\r\n        // do not need response becaue responses are saved in pipe methods\r\n        next: () => {\r\n          this.engines[engineId].isAnyImporting = false;\r\n          // note that termResponse and mtapiresponse gets changed during remove method\r\n          this.removeDeleted(termResponse, mtApiResponse, engineId);\r\n  \r\n          const joined = [];\r\n          if (mtApiResponse) {\r\n            joined.push(...mtApiResponse);\r\n          }\r\n          if (termResponse) {\r\n            joined.push(...termResponse);\r\n          }\r\n  \r\n          this.addCollections(joined, engineId);\r\n          if (setSelectedFromLocalStorage) {\r\n            this.setSelectedFromLocalStorage(engineId);\r\n          }\r\n          this.engines[engineId].isRefreshingCollections = false;\r\n          this.scheduleRefresh(engineId, null);\r\n        },\r\n        error: (error) => {\r\n          this.engines[engineId].isRefreshingCollections = false;\r\n          // it is enough to show error only in console. No special thing is necessary.\r\n          console.error(error);\r\n        },\r\n      });\r\n\r\n      return this.engineSubject.asObservable();\r\n  }\r\n\r\n  getCollections(): Observable<{ [engineId: string]: TerminologyEngine }> {\r\n    return this.engineSubject.asObservable();\r\n  }\r\n\r\n  startAutoRefresh(engineId: string, languages: string[] | null = null, setSelectedFromLocalStorage = false, termCollections = true, mtCollections = true) {\r\n    const engine = this.engines[engineId] ?? {};\r\n    engine.hardAutoRefresh = true;\r\n\r\n    return this.setEngine(engineId, languages ?? this.engines[engineId]?.engineLanguages, setSelectedFromLocalStorage, termCollections, mtCollections);\r\n  }\r\n\r\n  stopAutoRefresh(engineId: string) {\r\n    this.clearTimeout(engineId);\r\n\r\n    this.engines[engineId].isSoftAutoRefreshOn = false;\r\n    this.engines[engineId].hardAutoRefresh = false;\r\n  }\r\n\r\n  create(\r\n    sourceLanguage: string,\r\n    targetLanguage: string,\r\n    collectionName: string,\r\n    engineId: string,\r\n    redirectToEdit = true\r\n  ) {\r\n    return this.termCollectionApi\r\n      .createCollection([sourceLanguage, targetLanguage], collectionName)\r\n      .pipe(\r\n        tap((collection) => {\r\n          if (redirectToEdit) {\r\n            window.open(\r\n              this.termCollectionApi.getEditLink(\r\n                collection.termCollection?.id ?? '',\r\n                sourceLanguage,\r\n                targetLanguage\r\n              ),\r\n              '_blank'\r\n            );\r\n          }\r\n\r\n          this.engines[engineId]?.collections?.add(collection);\r\n\r\n          this.loadCollections(engineId);\r\n        })\r\n      );\r\n  }\r\n\r\n  selectedIdForTranslation(engineId: string): string | null {\r\n    const selected = this.engines[engineId]?.selected;\r\n    if (\r\n      selected?.mtCollection &&\r\n      (selected.mtCollection.lastUpdated ||\r\n        selected.mtCollection.status === MtCollectionStatus.READY)\r\n    ) {\r\n      return selected.mtCollection.id;\r\n    }\r\n    return null;\r\n  }\r\n\r\n  updateIfNecessary(\r\n    collection: CombinedCollection,\r\n    engineId: string,\r\n    isEdited = false\r\n  ): Observable<CombinedCollection> {\r\n    // collection is not imported and should be attached to engine\r\n    if (collection.isEdited() || isEdited) {\r\n      return this.mtApi.add(engineId, collection).pipe(\r\n        tap((updatedCollection) => {\r\n          collection.update(updatedCollection);\r\n        })\r\n      );\r\n    } else {\r\n      return of(collection);\r\n    }\r\n  }\r\n\r\n  handleAddToEngineError(error: any, engineId: string): void {\r\n    this.alert.unhandeledError(error);\r\n    this.engines[engineId].selected = null;\r\n  }\r\n\r\n  sync(\r\n    collection: CombinedCollection,\r\n    engineId: string\r\n  ): Observable<CombinedCollection> {\r\n    return this.mtApi.sync(engineId, collection).pipe(\r\n      tap((updatedCollection) => {\r\n        collection.update(updatedCollection);\r\n      })\r\n    );\r\n  }\r\n\r\n  removeMtCollection(collection: CombinedCollection, engineId: string) {\r\n    return this.mtApi.remove(engineId, collection).pipe(\r\n      tap((response) => {\r\n        collection.update(response);\r\n      })\r\n    );\r\n  }\r\n\r\n  addToEngineValidation(collection: CombinedCollection): boolean {\r\n    if (!collection || !collection.termCollection) {\r\n      console.error(\"Trying to attach collection that has no tilde term id.\");\r\n      return false;\r\n    }\r\n\r\n   return true;\r\n  }\r\n\r\n  private clearTimeout(engineId: string) {\r\n    if (this.engines[engineId]?.refreshTimeout) {\r\n      clearTimeout(this.engines[engineId].refreshTimeout);\r\n      this.engines[engineId].refreshTimeout = null;\r\n    }\r\n  }\r\n\r\n  private setSelectedFromLocalStorage(engineId: string) {\r\n    // If no collections or selected is already set, it should not be changed from localstorage value. (Usually, localstorage should have the same value).\r\n    if (this.engines[engineId].collections?.size === 0 || this.engines[engineId].selected) {\r\n      this.updateSelectedCollectionOutsideService();\r\n      return;\r\n    }\r\n\r\n    const storedId = this.readLocalStorage()?.[engineId];\r\n    \r\n    if (!storedId) {\r\n      this.engines[engineId].selected = null;\r\n      this.updateSelectedCollectionOutsideService();\r\n      return;\r\n    }\r\n\r\n    const existing = Array.from(this.engines[engineId].collections).find(\r\n      (item) => item.mtCollection?.id === storedId || item.termCollection?.id === storedId);\r\n    this.engines[engineId].selected = existing as CombinedCollection;\r\n\r\n    this.updateSelectedCollectionOutsideService();\r\n  }\r\n  \r\n\r\n  private removeDeleted(termResponse: CombinedCollection[], mtResponse: CombinedCollection[], engineId: string): void {\r\n    for (const collection of this.engines[engineId].collections) {\r\n      const termExistingIx = CombinedCollection.findExistingIndexFromList(termResponse, collection);\r\n      const mtExistingIx = CombinedCollection.findExistingIndexFromList(mtResponse, collection);\r\n\r\n      if (termExistingIx === null && mtExistingIx === null) {\r\n        this.engines[engineId]?.collections.delete(collection);\r\n  \r\n        if (this.engines[engineId]?.selected === collection) {\r\n          this.engines[engineId].selected = null;\r\n          this.updateSelectedCollectionOutsideService();\r\n        }\r\n      } else {\r\n        if (termExistingIx !== null) {\r\n          const existingTerm = termResponse[termExistingIx];\r\n          collection.update(existingTerm);\r\n          termResponse.splice(termExistingIx, 1);\r\n        } else {\r\n          collection.deleteTerms();\r\n        }\r\n  \r\n        if (mtExistingIx !== null) {\r\n          const existingMt = mtResponse[mtExistingIx];\r\n          collection.update(existingMt);\r\n          mtResponse.splice(mtExistingIx, 1);\r\n        } else {\r\n          collection.deleteMT();\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private addCollections(newCollections: Iterable<CombinedCollection>, engineId: string) {\r\n    // sets collection list to this value at the end, so deleted collections are not in the list.\r\n    for (const collection of newCollections) {\r\n      // User shouldn't see failed collections if he can't retry to import them.\r\n      if (!this.hasEditPermissions && collection.mtStatus === MtCollectionStatus.ERROR || collection.mtStatus === MtCollectionStatus.DELETING) {\r\n        continue;\r\n      }\r\n\r\n      if (collection.isImporting) {\r\n        this.engines[engineId].isAnyImporting = true;\r\n      }\r\n\r\n      const existing: CombinedCollection | null = CombinedCollection.findExistingCollectionFromList(this.engines[engineId].collections, collection);\r\n\r\n      // If term api doesn't have engine languages, collection should not be shown (if it is not already imported somehow);\r\n      if (!existing && collection.source === EngineTermCollectionSource.TILDE_TERM) {\r\n        let hasLanguages = true;\r\n        for (let i = 0; i < this.engines[engineId].engineLanguages.length; i++) {\r\n          if (\r\n            !collection.termCollection?.languages?.find(\r\n              (lang) => lang.id === this.engines[engineId].engineLanguages[i]\r\n            )\r\n          ) {\r\n            hasLanguages = false;\r\n            break;\r\n          }\r\n        }\r\n\r\n        if (!hasLanguages) {\r\n          continue;\r\n        }\r\n      }\r\n\r\n      if (!existing) {\r\n        this.engines[engineId].collections.add(collection);\r\n      } else {\r\n        existing.update(collection);\r\n      }\r\n    }\r\n\r\n    this.engines[engineId].hasAnyCollections = this.engines[engineId].collections.size > 0;\r\n\r\n    this.engineSubject.next(this.engines);\r\n  }\r\n\r\n  private scheduleRefresh(engineId: string, timeout?: number | null,) {\r\n    // if menu is closed and selected collection is not importing anymore - auto refreshing should be cancelled.\r\n    if (\r\n      !this.engines[engineId].hardAutoRefresh &&\r\n      !this.engines[engineId]?.isImporting &&\r\n      this.engines[engineId].isSoftAutoRefreshOn\r\n    ) {\r\n      this.stopAutoRefresh(engineId);\r\n      return;\r\n    }\r\n\r\n    // if hard auto refresho on, auto refresh should be on. If hard autoreferesh is off , refresh needs to be done only if selected is importing.\r\n    if (\r\n      this.engines[engineId].hardAutoRefresh ||\r\n      (!this.engines[engineId] &&\r\n        (this.engines[engineId].isSoftAutoRefreshOn || this.engines[engineId].selected?.isImporting))\r\n    ) {\r\n      const timeoutMs =\r\n        timeout ??\r\n        (this.engines[engineId].isAnyImporting\r\n          ? this.config.termConfig.refreshTimeoutMsWhenImporting\r\n          : this.config.termConfig.refreshTimeoutMs);\r\n          this.engines[engineId].refreshTimeout = setTimeout(() => {\r\n            this.engines[engineId].refreshTimeout = null;\r\n        this.loadCollections(engineId);\r\n      }, timeoutMs);\r\n    }\r\n  }\r\n\r\n  private storeSelectedInLocalStorage(engineId: string): void {\r\n    let localStorageObject = this.readLocalStorage();\r\n    \r\n    if (!localStorageObject) {\r\n      localStorageObject = {} as any;\r\n    }\r\n\r\n    localStorageObject[engineId] = this.engines[engineId].selected ? (this.engines[engineId]?.selected?.mtCollection?.id ?? this.engines[engineId]?.selected?.termCollection?.id) : null;\r\n    // store term id if it exists\r\n    localStorage.setItem(this.LOCAL_STORAGE_KEY, JSON.stringify(localStorageObject));\r\n  }\r\n\r\n  private readLocalStorage(): any {\r\n    const data = localStorage.getItem(this.LOCAL_STORAGE_KEY) as string;\r\n    try {\r\n      return JSON.parse(data);\r\n    } catch {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private updateSelectedCollectionOutsideService(): void {\r\n    this.updatedEnginesSubject.next(this.engines);\r\n  }\r\n}\r\n"]}