nuxeo-development-framework 3.1.2 → 3.1.3

package/esm2015/lib/Core/services/roles/roles.service.js

@@ -0,0 +1,119 @@
+import { Inject, Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class RolesService {
+    constructor(environment) {
+        this.environment = environment;
+    }
+    getRoleName(role, code = null) {
+        if (this.environment.RolesConstants[role]) {
+            return code
+                ? this.environment.RolesConstants[role].replace("{departmentTitle}", code)
+                : `^${this.environment.RolesConstants[role].replace("{departmentTitle}", ".*.")}$`;
+        }
+        else {
+            console.warn(`role: ${role} does not exist in roles config`);
+            return role;
+        }
+    }
+    isUserInRole(user, role, code = null) {
+        let hasRole = false;
+        const groups = user ? user.extendedGroups || user.groups : [];
+        if (groups && groups.length > 0) {
+            if (Array.isArray(role)) {
+                role.forEach((r) => {
+                    if (groups.filter((item) => {
+                        if (code) {
+                            return (item.name || item) === this.getRoleName(r, code);
+                        }
+                        else {
+                            const regex = new RegExp(this.getRoleName(r));
+                            return regex.test(item.name || item);
+                        }
+                    }).length > 0) {
+                        hasRole = true;
+                        return;
+                    }
+                });
+            }
+            else {
+                hasRole =
+                    groups.filter((item) => {
+                        if (code) {
+                            return (item.name || item) === this.getRoleName(role, code);
+                        }
+                        else {
+                            const regex = new RegExp(this.getRoleName(role));
+                            return regex.test(item.name || item);
+                        }
+                    }).length > 0;
+            }
+        }
+        return hasRole;
+    }
+    getUserRoleName(user, code) {
+        let found = null;
+        const groups = user ? user.extendedGroups || user.groups : [];
+        if (groups && groups.length) {
+            Object.keys(this.environment.RolesConstants).forEach((key) => {
+                const roleWCode = this.environment.RolesConstants[key].replace("{departmentTitle}", code);
+                if ((code && roleWCode.includes('dms_user_')) || !code)
+                    groups.forEach((group) => {
+                        if (group.name || group === roleWCode) {
+                            found = key;
+                        }
+                    });
+            });
+        }
+        return found;
+    }
+    isUserManagerInDepartment(user, code) {
+        let filteredRoles = Object.values(this.environment.RolesConstants).filter((role) => role.includes("{departmentTitle}"));
+        let departmentRoles = [];
+        let isUserInDepartment = false;
+        const groups = user ? user.extendedGroups || user.groups : [];
+        if (groups && groups.length) {
+            filteredRoles.forEach((key) => {
+                const roleWCode = key.replace("{departmentTitle}", code);
+                departmentRoles.push(roleWCode);
+            });
+        }
+        departmentRoles = departmentRoles.filter((role) => {
+            return role.includes("Manager");
+        });
+        groups.forEach((group) => {
+            const groupName = group.name || group;
+            const departmentIsIncluded = departmentRoles.includes(groupName);
+            if (departmentIsIncluded) {
+                isUserInDepartment = true;
+            }
+        });
+        return isUserInDepartment;
+    }
+    getUserDepartment(currentUser, prefix = "cts_role_") {
+        let allGroups = currentUser.properties.groups;
+        let departmentCode = "";
+        allGroups.some((group) => {
+            if (!group.includes("cts_role_sys") && group.includes("cts_role")) {
+                departmentCode = group;
+                return true;
+            }
+        });
+        let prefixLength = prefix.length;
+        departmentCode = departmentCode.substring(prefixLength);
+        let lastIndex = departmentCode.lastIndexOf("_");
+        departmentCode = departmentCode.substring(0, lastIndex);
+        return departmentCode;
+    }
+}
+RolesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: RolesService, deps: [{ token: "environment" }], target: i0.ɵɵFactoryTarget.Injectable });
+RolesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: RolesService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: RolesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ["environment"]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"roles.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/Core/services/roles/roles.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAKnD,MAAM,OAAO,YAAY;IACvB,YAA2C,WAAW;QAAX,gBAAW,GAAX,WAAW,CAAA;IAAG,CAAC;IAE1D,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;QAC3B,IAAI,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE;YACzC,OAAO,IAAI;gBACT,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,OAAO,CAC3C,mBAAmB,EACnB,IAAI,CACL;gBACH,CAAC,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,OAAO,CAC/C,mBAAmB,EACnB,KAAK,CACN,GAAG,CAAC;SACV;aAAM;YACL,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,iCAAiC,CAAC,CAAC;YAC7D,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAED,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI;QAClC,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9D,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACvB,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;oBACjB,IACE,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;wBACrB,IAAI,IAAI,EAAE;4BACR,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;yBAC1D;6BAAM;4BACL,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;4BAC9C,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;yBACtC;oBACH,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,EACb;wBACA,OAAO,GAAG,IAAI,CAAC;wBACf,OAAO;qBACR;gBACH,CAAC,CAAC,CAAC;aACJ;iBAAM;gBACL,OAAO;oBACL,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;wBACrB,IAAI,IAAI,EAAE;4BACR,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;yBAC7D;6BAAM;4BACL,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;4BACjD,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;yBACtC;oBACH,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;aACjB;SACF;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,eAAe,CAAC,IAAI,EAAE,IAAI;QACxB,IAAI,KAAK,GAAG,IAAI,CAAC;QACjB,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAE9D,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE;YAC3B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;gBAC3D,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,OAAO,CAC5D,mBAAmB,EACnB,IAAI,CACL,CAAC;gBACF,IAAG,CAAC,IAAI,IAAI,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,IAAI;oBACrD,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;wBACvB,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE;4BACrC,KAAK,GAAG,GAAG,CAAC;yBACb;oBACH,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;SACJ;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,yBAAyB,CAAC,IAAI,EAAE,IAAI;QAClC,IAAI,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,MAAM,CACvE,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAClD,CAAC;QACF,IAAI,eAAe,GAAG,EAAE,CAAC;QACzB,IAAI,kBAAkB,GAAY,KAAK,CAAC;QACxC,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9D,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE;YAC3B,aAAa,CAAC,OAAO,CAAC,CAAC,GAAQ,EAAE,EAAE;gBACjC,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC,mBAAmB,EAAE,IAAI,CAAC,CAAC;gBACzD,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAClC,CAAC,CAAC,CAAC;SACJ;QACD,eAAe,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC,IAAY,EAAE,EAAE;YACxD,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;YACvB,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC;YACtC,MAAM,oBAAoB,GAAY,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YAC1E,IAAI,oBAAoB,EAAE;gBACxB,kBAAkB,GAAG,IAAI,CAAC;aAC3B;QACH,CAAC,CAAC,CAAC;QACH,OAAO,kBAAkB,CAAC;IAC5B,CAAC;IACD,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW;QACjD,IAAI,SAAS,GAAa,WAAW,CAAC,UAAU,CAAC,MAAM,CAAC;QACxD,IAAI,cAAc,GAAG,EAAE,CAAC;QACxB,SAAS,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YACvB,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;gBACjE,cAAc,GAAG,KAAK,CAAC;gBACvB,OAAO,IAAI,CAAC;aACb;QACH,CAAC,CAAC,CAAC;QACH,IAAI,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC;QACjC,cAAc,GAAG,cAAc,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QACxD,IAAI,SAAS,GAAG,cAAc,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAChD,cAAc,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QACxD,OAAO,cAAc,CAAC;IACxB,CAAC;;yGAnHU,YAAY,kBACH,aAAa;6GADtB,YAAY,cAFX,MAAM;2FAEP,YAAY;kBAHxB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAEc,MAAM;2BAAC,aAAa","sourcesContent":["import { Inject, Injectable } from \"@angular/core\";\r\n\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class RolesService {\r\n  constructor(@Inject(\"environment\") private environment) {}\r\n\r\n  getRoleName(role, code = null): string {\r\n    if (this.environment.RolesConstants[role]) {\r\n      return code\r\n        ? this.environment.RolesConstants[role].replace(\r\n            \"{departmentTitle}\",\r\n            code\r\n          )\r\n        : `^${this.environment.RolesConstants[role].replace(\r\n            \"{departmentTitle}\",\r\n            \".*.\"\r\n          )}$`;\r\n    } else {\r\n      console.warn(`role: ${role} does not exist in roles config`);\r\n      return role;\r\n    }\r\n  }\r\n\r\n  isUserInRole(user, role, code = null): boolean {\r\n    let hasRole = false;\r\n    const groups = user ? user.extendedGroups || user.groups : [];\r\n    if (groups && groups.length > 0) {\r\n      if (Array.isArray(role)) {\r\n        role.forEach((r) => {\r\n          if (\r\n            groups.filter((item) => {\r\n              if (code) {\r\n                return (item.name || item) === this.getRoleName(r, code);\r\n              } else {\r\n                const regex = new RegExp(this.getRoleName(r));\r\n                return regex.test(item.name || item);\r\n              }\r\n            }).length > 0\r\n          ) {\r\n            hasRole = true;\r\n            return;\r\n          }\r\n        });\r\n      } else {\r\n        hasRole =\r\n          groups.filter((item) => {\r\n            if (code) {\r\n              return (item.name || item) === this.getRoleName(role, code);\r\n            } else {\r\n              const regex = new RegExp(this.getRoleName(role));\r\n              return regex.test(item.name || item);\r\n            }\r\n          }).length > 0;\r\n      }\r\n    }\r\n    return hasRole;\r\n  }\r\n\r\n  getUserRoleName(user, code) {\r\n    let found = null;\r\n    const groups = user ? user.extendedGroups || user.groups : [];\r\n\r\n    if (groups && groups.length) {\r\n      Object.keys(this.environment.RolesConstants).forEach((key) => {\r\n        const roleWCode = this.environment.RolesConstants[key].replace(\r\n          \"{departmentTitle}\",\r\n          code\r\n        );\r\n        if((code && roleWCode.includes('dms_user_')) || !code)\r\n        groups.forEach((group) => {\r\n          if (group.name || group === roleWCode) {\r\n            found = key;\r\n          }\r\n        });\r\n      });\r\n    }\r\n    return found;\r\n  }\r\n\r\n  isUserManagerInDepartment(user, code) {\r\n    let filteredRoles = Object.values(this.environment.RolesConstants).filter(\r\n      (role: any) => role.includes(\"{departmentTitle}\")\r\n    );\r\n    let departmentRoles = [];\r\n    let isUserInDepartment: boolean = false;\r\n    const groups = user ? user.extendedGroups || user.groups : [];\r\n    if (groups && groups.length) {\r\n      filteredRoles.forEach((key: any) => {\r\n        const roleWCode = key.replace(\"{departmentTitle}\", code);\r\n        departmentRoles.push(roleWCode);\r\n      });\r\n    }\r\n    departmentRoles = departmentRoles.filter((role: string) => {\r\n      return role.includes(\"Manager\");\r\n    });\r\n    groups.forEach((group) => {\r\n      const groupName = group.name || group;\r\n      const departmentIsIncluded: boolean = departmentRoles.includes(groupName);\r\n      if (departmentIsIncluded) {\r\n        isUserInDepartment = true;\r\n      }\r\n    });\r\n    return isUserInDepartment;\r\n  }\r\n  getUserDepartment(currentUser, prefix = \"cts_role_\") {\r\n    let allGroups: string[] = currentUser.properties.groups;\r\n    let departmentCode = \"\";\r\n    allGroups.some((group) => {\r\n      if (!group.includes(\"cts_role_sys\") && group.includes(\"cts_role\")) {\r\n        departmentCode = group;\r\n        return true;\r\n      }\r\n    });\r\n    let prefixLength = prefix.length;\r\n    departmentCode = departmentCode.substring(prefixLength);\r\n    let lastIndex = departmentCode.lastIndexOf(\"_\");\r\n    departmentCode = departmentCode.substring(0, lastIndex);\r\n    return departmentCode;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/Core/services/translation/translate-loader.service.js

@@ -0,0 +1,150 @@
+import { Injectable } from '@angular/core';
+import { Observable, forkJoin, throwError, of } from 'rxjs';
+import { ComponentTranslationModel } from '../../models/component.model';
+import { map, catchError, retry } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class TranslateLoaderService {
+    constructor(http) {
+        this.http = http;
+        this.prefix = 'i18n';
+        this.suffix = '.json';
+        this.providers = [];
+        this.queue = [];
+        this.defaultLang = 'en';
+    }
+    setDefaultLang(value) {
+        this.defaultLang = value || 'en';
+    }
+    registerProvider(name, path) {
+        const registered = this.providers.find((provider) => provider.name === name);
+        if (registered) {
+            registered.path = path;
+        }
+        else {
+            this.providers.push(new ComponentTranslationModel({ name: name, path: path }));
+        }
+    }
+    providerRegistered(name) {
+        return this.providers.find((x) => x.name === name) ? true : false;
+    }
+    fetchLanguageFile(lang, component, fallbackUrl) {
+        const translationUrl = fallbackUrl || `${component.path}/${this.prefix}/${lang}${this.suffix}?v=${Date.now()}`;
+        return this.http.get(translationUrl).pipe(map((res) => {
+            component.json[lang] = res;
+        }), retry(3), catchError(() => {
+            if (!fallbackUrl && lang.includes('-')) {
+                const [langId] = lang.split('-');
+                if (langId && langId !== this.defaultLang) {
+                    const url = `${component.path}/${this.prefix}/${langId}${this.suffix}?v=${Date.now()}`;
+                    return this.fetchLanguageFile(lang, component, url);
+                }
+            }
+            return throwError(`Failed to load ${translationUrl}`);
+        }));
+    }
+    getComponentToFetch(lang) {
+        const observableBatch = [];
+        if (!this.queue[lang]) {
+            this.queue[lang] = [];
+        }
+        this.providers.forEach((component) => {
+            if (!this.isComponentInQueue(lang, component.name)) {
+                this.queue[lang].push(component.name);
+                observableBatch.push(this.fetchLanguageFile(lang, component));
+            }
+        });
+        return observableBatch;
+    }
+    init(lang) {
+        if (this.queue[lang] === undefined) {
+            this.queue[lang] = [];
+        }
+    }
+    isComponentInQueue(lang, name) {
+        return (this.queue[lang] || []).find((x) => x === name) ? true : false;
+    }
+    getFullTranslationJSON(lang) {
+        let result = {};
+        this.providers
+            .slice(0)
+            .sort((a, b) => {
+            if (a.name === 'app') {
+                return 1;
+            }
+            if (b.name === 'app') {
+                return -1;
+            }
+            return a.name.localeCompare(b.name);
+        })
+            .forEach((model) => {
+            if (model.json && model.json[lang]) {
+                result = this.merge(result, model.json[lang]);
+            }
+        });
+        return result;
+    }
+    getTranslation(lang) {
+        let hasFailures = false;
+        const batch = [
+            ...this.getComponentToFetch(lang).map((observable) => {
+                return observable.pipe(catchError((error) => {
+                    console.warn(error);
+                    hasFailures = true;
+                    return of(error);
+                }));
+            })
+        ];
+        return new Observable((observer) => {
+            if (batch.length > 0) {
+                forkJoin(batch).subscribe(() => {
+                    const fullTranslation = this.getFullTranslationJSON(lang);
+                    if (fullTranslation) {
+                        observer.next(fullTranslation);
+                    }
+                    if (hasFailures) {
+                        observer.error('Failed to load some resources');
+                    }
+                    else {
+                        observer.complete();
+                    }
+                }, () => {
+                    observer.error('Failed to load some resources');
+                });
+            }
+            else {
+                const fullTranslation = this.getFullTranslationJSON(lang);
+                if (fullTranslation) {
+                    observer.next(fullTranslation);
+                    observer.complete();
+                }
+            }
+        });
+    }
+    merge(...objects) {
+        const result = {};
+        objects.forEach((source) => {
+            Object.keys(source).forEach((prop) => {
+                if (prop in result && Array.isArray(result[prop])) {
+                    result[prop] = result[prop].concat(source[prop]);
+                }
+                else if (prop in result && typeof result[prop] === 'object') {
+                    result[prop] = this.merge(result[prop], source[prop]);
+                }
+                else {
+                    result[prop] = source[prop];
+                }
+            });
+        });
+        return result;
+    }
+}
+TranslateLoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: TranslateLoaderService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+TranslateLoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: TranslateLoaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: TranslateLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translate-loader.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/Core/services/translation/translate-loader.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { TranslateLoader } from '@ngx-translate/core';\r\nimport { Observable, forkJoin, throwError, of } from 'rxjs';\r\nimport { ComponentTranslationModel } from '../../models/component.model';\r\nimport { map, catchError, retry } from 'rxjs/operators';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class TranslateLoaderService implements TranslateLoader {\r\n\r\n  private prefix: string = 'i18n';\r\n  private suffix: string = '.json';\r\n  private providers: ComponentTranslationModel[] = [];\r\n  private queue: string[][] = [];\r\n  private defaultLang: string = 'en';\r\n\r\n  constructor(private http: HttpClient) {\r\n  }\r\n\r\n  setDefaultLang(value: string) {\r\n    this.defaultLang = value || 'en';\r\n  }\r\n\r\n  registerProvider(name: string, path: string) {\r\n    const registered = this.providers.find((provider) => provider.name === name);\r\n    if (registered) {\r\n      registered.path = path;\r\n    } else {\r\n      this.providers.push(new ComponentTranslationModel({ name: name, path: path }));\r\n    }\r\n  }\r\n\r\n  providerRegistered(name: string): boolean {\r\n    return this.providers.find((x) => x.name === name) ? true : false;\r\n  }\r\n\r\n  fetchLanguageFile(lang: string, component: ComponentTranslationModel, fallbackUrl?: string): Observable<void> {\r\n    const translationUrl = fallbackUrl || `${component.path}/${this.prefix}/${lang}${this.suffix}?v=${Date.now()}`;\r\n\r\n    return this.http.get(translationUrl).pipe(\r\n      map((res: any) => {\r\n        component.json[lang] = res;\r\n      }),\r\n      retry(3),\r\n      catchError(() => {\r\n        if (!fallbackUrl && lang.includes('-')) {\r\n          const [langId] = lang.split('-');\r\n\r\n          if (langId && langId !== this.defaultLang) {\r\n            const url = `${component.path}/${this.prefix}/${langId}${this.suffix}?v=${Date.now()}`;\r\n\r\n            return this.fetchLanguageFile(lang, component, url);\r\n          }\r\n        }\r\n        return throwError(`Failed to load ${translationUrl}`);\r\n      })\r\n    );\r\n  }\r\n\r\n  getComponentToFetch(lang: string): Array<Observable<any>> {\r\n    const observableBatch = [];\r\n    if (!this.queue[lang]) {\r\n      this.queue[lang] = [];\r\n    }\r\n    this.providers.forEach((component) => {\r\n\r\n      if (!this.isComponentInQueue(lang, component.name)) {\r\n        this.queue[lang].push(component.name);\r\n        observableBatch.push(\r\n          this.fetchLanguageFile(lang, component)\r\n        );\r\n      }\r\n    });\r\n\r\n    return observableBatch;\r\n  }\r\n\r\n  init(lang: string) {\r\n    if (this.queue[lang] === undefined) {\r\n      this.queue[lang] = [];\r\n    }\r\n  }\r\n\r\n  isComponentInQueue(lang: string, name: string) {\r\n    return (this.queue[lang] || []).find((x) => x === name) ? true : false;\r\n  }\r\n\r\n  getFullTranslationJSON(lang: string): any {\r\n    let result = {};\r\n\r\n    this.providers\r\n      .slice(0)\r\n      .sort((a, b) => {\r\n        if (a.name === 'app') {\r\n          return 1;\r\n        }\r\n        if (b.name === 'app') {\r\n          return -1;\r\n        }\r\n        return a.name.localeCompare(b.name);\r\n      })\r\n      .forEach((model) => {\r\n        if (model.json && model.json[lang]) {\r\n          result = this.merge(result, model.json[lang]);\r\n        }\r\n      });\r\n\r\n    return result;\r\n  }\r\n\r\n  getTranslation(lang: string): Observable<any> {\r\n    let hasFailures = false;\r\n    const batch = [\r\n      ...this.getComponentToFetch(lang).map((observable) => {\r\n        return observable.pipe(\r\n          catchError((error) => {\r\n            console.warn(error);\r\n            hasFailures = true;\r\n            return of(error);\r\n          })\r\n        );\r\n      })\r\n    ];\r\n\r\n    return new Observable((observer) => {\r\n\r\n      if (batch.length > 0) {\r\n        forkJoin(batch).subscribe(\r\n          () => {\r\n            const fullTranslation = this.getFullTranslationJSON(lang);\r\n            if (fullTranslation) {\r\n              observer.next(fullTranslation);\r\n            }\r\n            if (hasFailures) {\r\n              observer.error('Failed to load some resources');\r\n            } else {\r\n              observer.complete();\r\n            }\r\n          },\r\n          () => {\r\n            observer.error('Failed to load some resources');\r\n          });\r\n      } else {\r\n        const fullTranslation = this.getFullTranslationJSON(lang);\r\n        if (fullTranslation) {\r\n          observer.next(fullTranslation);\r\n          observer.complete();\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  merge(...objects): any {\r\n    const result = {};\r\n\r\n    objects.forEach((source) => {\r\n      Object.keys(source).forEach((prop) => {\r\n        if (prop in result && Array.isArray(result[prop])) {\r\n          result[prop] = result[prop].concat(source[prop]);\r\n        } else if (prop in result && typeof result[prop] === 'object') {\r\n          result[prop] = this.merge(result[prop], source[prop]);\r\n        } else {\r\n          result[prop] = source[prop];\r\n        }\r\n      });\r\n    });\r\n\r\n    return result;\r\n  }\r\n\r\n}\r\n"]}

package/esm2015/lib/Core/services/translation/translation.service.js

@@ -0,0 +1,174 @@
+import { Inject, Injectable, InjectionToken, Optional, } from '@angular/core';
+import { BehaviorSubject, forkJoin, from } from 'rxjs';
+import { UserPreferenceValues, } from '../user/user-preferences.service';
+import { Lang } from '../../enums/language.enum';
+import { catchError, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../localStorag/local-storag.service";
+import * as i3 from "../user/user-preferences.service";
+import * as i4 from "../../../configuration/app-config.service";
+import * as i5 from "../nuxeo/nuxeo.service";
+export const TRANSLATION_PROVIDER = new InjectionToken('Injection token for translation providers.');
+export class TranslationService {
+    constructor(translate, rendererFactory, localStorage, userPreferencesService, appConfig, nuxeoService, environment, providers) {
+        this.translate = translate;
+        this.rendererFactory = rendererFactory;
+        this.localStorage = localStorage;
+        this.appConfig = appConfig;
+        this.nuxeoService = nuxeoService;
+        this.environment = environment;
+        this.isArabic = new BehaviorSubject(false);
+        this.isArabic$ = this.isArabic.asObservable();
+        this.translationApiName = this.appConfig.myConfiguration['translationApi'] ? this.appConfig.myConfiguration['translationApi'] : null;
+        this.customLoader = this.translate.currentLoader;
+        this.renderer = rendererFactory.createRenderer(null, null);
+        this.defaultLang = 'en';
+        translate.setDefaultLang(this.defaultLang);
+        this.customLoader.setDefaultLang(this.defaultLang);
+        if (providers && providers.length > 0) {
+            for (const provider of providers) {
+                this.addTranslationFolder(provider.name, provider.source);
+            }
+        }
+        userPreferencesService
+            .select(UserPreferenceValues.Locale)
+            .subscribe((locale) => {
+            if (locale) {
+                this.userLang = locale.split('-')[0];
+            }
+            if (this.userLang) {
+                this.loadTranslation(this.userLang, this.defaultLang);
+            }
+            else {
+                this.loadTranslation(this.defaultLang);
+            }
+        });
+    }
+    /**
+     * Adds a new folder of translation source files.
+     * @param name Name for the translation provider
+     * @param path Path to the folder
+     */
+    addTranslationFolder(name = '', path = '') {
+        if (!this.customLoader.providerRegistered(name)) {
+            this.customLoader.registerProvider(name, path);
+        }
+    }
+    /**
+     * Loads a translation file.
+     * @param lang Language code for the language to load
+     * @param fallback Language code to fall back to if the first one was unavailable
+     */
+    loadTranslation(lang, fallback) {
+        if (lang === Lang.Arabic) {
+            this.renderer.addClass(document.body, 'rtl');
+            this.isArabic.next(true);
+        }
+        else {
+            this.renderer.removeClass(document.body, 'rtl');
+            this.isArabic.next(false);
+        }
+        const arabicFile$ = this.getOrCreateTranslationFile('ar');
+        const englishFile$ = this.getOrCreateTranslationFile('en');
+        forkJoin([
+            arabicFile$,
+            englishFile$,
+            this.translate.getTranslation(lang),
+        ]).subscribe((res) => {
+            this.arabicFile = res[0];
+            this.englishFile = res[1];
+            this.translate.use(lang);
+            let ArorEnFile = lang === 'en'
+                ? JSON.parse(res[1].properties['note:note'])
+                : JSON.parse(res[0].properties['note:note']);
+            this.translate.setTranslation(this.translate.currentLang, Object.assign({}, ArorEnFile), true);
+            this.onTranslationChanged(lang);
+        }, () => {
+            if (fallback && fallback !== lang) {
+                this.loadTranslation(fallback);
+            }
+        });
+    }
+    /**
+     * Triggers a notification callback when the translation language changes.
+     * @param lang The new language code
+     */
+    onTranslationChanged(lang) {
+        this.translate.onTranslationChange.next({
+            lang: lang,
+            translations: this.customLoader.getFullTranslationJSON(lang),
+        });
+    }
+    /**
+     * Sets the target language for translations.
+     * @param lang Code name for the language
+     * @returns Translations available for the language
+     */
+    use(lang) {
+        this.customLoader.init(lang);
+        return this.translate.use(lang);
+    }
+    /**
+     * Gets the translation for the supplied key.
+     * @param key Key to translate
+     * @param interpolateParams String(s) to be interpolated into the main message
+     * @returns Translated text
+     */
+    get(key, interpolateParams) {
+        return this.translate.get(key, interpolateParams);
+    }
+    /**
+     * Directly returns the translation for the supplied key.
+     * @param key Key to translate
+     * @param interpolateParams String(s) to be interpolated into the main message
+     * @returns Translated text
+     */
+    instant(key, interpolateParams) {
+        return key ? this.translate.instant(key, interpolateParams) : '';
+    }
+    getOrCreateTranslationFile(lang) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(this.translationApiName ? this.translationApiName : 'AC_UA_Translation_GetOrCreate', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .params({ language: lang })
+            .execute({
+            headers: {
+                properties: '*',
+            },
+        })).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    updateTranslationFile(doc, params = {}) {
+        return from(this.nuxeoService.nuxeoClient
+            .repository()
+            .headers({
+            properties: '*',
+        })
+            .update(doc, params)).pipe(map((data) => {
+            return data;
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+}
+TranslationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: TranslationService, deps: [{ token: i1.TranslateService }, { token: i0.RendererFactory2 }, { token: i2.LocalStoragService }, { token: i3.UserPreferencesService }, { token: i4.AppConfigService }, { token: i5.NuxeoService }, { token: 'environment' }, { token: TRANSLATION_PROVIDER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+TranslationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: TranslationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: TranslationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i0.RendererFactory2 }, { type: i2.LocalStoragService }, { type: i3.UserPreferencesService }, { type: i4.AppConfigService }, { type: i5.NuxeoService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TRANSLATION_PROVIDER]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translation.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/Core/services/translation/translation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Inject,\r\n  Injectable,\r\n  InjectionToken,\r\n  Optional,\r\n  Renderer2,\r\n  RendererFactory2,\r\n} from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { BehaviorSubject, forkJoin, from, Observable } from 'rxjs';\r\nimport { TranslateLoaderService } from './translate-loader.service';\r\nimport {\r\n  UserPreferencesService,\r\n  UserPreferenceValues,\r\n} from '../user/user-preferences.service';\r\nimport { LocalStoragService } from '../localStorag/local-storag.service';\r\nimport { Lang } from '../../enums/language.enum';\r\nimport { NuxeoService } from '../nuxeo/nuxeo.service';\r\nimport { catchError, map } from 'rxjs/operators';\r\nimport { AppConfigService } from '../../../configuration/app-config.service';\r\n\r\nexport const TRANSLATION_PROVIDER = new InjectionToken(\r\n  'Injection token for translation providers.'\r\n);\r\n\r\nexport interface TranslationProvider {\r\n  name: string;\r\n  source: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TranslationService {\r\n  public arabicFile;\r\n  public englishFile;\r\n  defaultLang: string;\r\n  userLang: string;\r\n  customLoader: TranslateLoaderService;\r\n  lang: string;\r\n  private renderer: Renderer2;\r\n  isArabic = new BehaviorSubject<boolean>(false);\r\n  isArabic$ = this.isArabic.asObservable();\r\n  translationApiName;\r\n  constructor(\r\n    public translate: TranslateService,\r\n    private rendererFactory: RendererFactory2,\r\n    private localStorage: LocalStoragService,\r\n    userPreferencesService: UserPreferencesService,\r\n    private appConfig : AppConfigService,\r\n    private nuxeoService: NuxeoService, \r\n    @Inject('environment') private environment,\r\n    @Optional() @Inject(TRANSLATION_PROVIDER) providers: TranslationProvider[]\r\n  ) {\r\n    this.translationApiName = this.appConfig.myConfiguration['translationApi'] ? this.appConfig.myConfiguration['translationApi'] : null;\r\n    this.customLoader = <TranslateLoaderService>this.translate.currentLoader;\r\n    this.renderer = rendererFactory.createRenderer(null, null);\r\n\r\n    this.defaultLang = 'en';\r\n    translate.setDefaultLang(this.defaultLang);\r\n    this.customLoader.setDefaultLang(this.defaultLang);\r\n\r\n    if (providers && providers.length > 0) {\r\n      for (const provider of providers) {\r\n        this.addTranslationFolder(provider.name, provider.source);\r\n      }\r\n    }\r\n    userPreferencesService\r\n      .select(UserPreferenceValues.Locale)\r\n      .subscribe((locale) => {\r\n        if (locale) {\r\n          this.userLang = locale.split('-')[0];\r\n        }\r\n        if (this.userLang) {\r\n          this.loadTranslation(this.userLang, this.defaultLang);\r\n        } else {\r\n          this.loadTranslation(this.defaultLang);\r\n        }\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Adds a new folder of translation source files.\r\n   * @param name Name for the translation provider\r\n   * @param path Path to the folder\r\n   */\r\n  addTranslationFolder(name: string = '', path: string = '') {\r\n    if (!this.customLoader.providerRegistered(name)) {\r\n      this.customLoader.registerProvider(name, path);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Loads a translation file.\r\n   * @param lang Language code for the language to load\r\n   * @param fallback Language code to fall back to if the first one was unavailable\r\n   */\r\n  loadTranslation(lang: string, fallback?: string) {\r\n    if (lang === Lang.Arabic) {\r\n      this.renderer.addClass(document.body, 'rtl');\r\n      this.isArabic.next(true);\r\n    } else {\r\n      this.renderer.removeClass(document.body, 'rtl');\r\n      this.isArabic.next(false);\r\n    }\r\n    const arabicFile$ = this.getOrCreateTranslationFile('ar');\r\n    const englishFile$ = this.getOrCreateTranslationFile('en');\r\n\r\n    forkJoin([\r\n      arabicFile$,\r\n      englishFile$,\r\n      this.translate.getTranslation(lang),\r\n    ]).subscribe(\r\n      (res: any) => {\r\n        this.arabicFile = res[0];\r\n        this.englishFile = res[1];\r\n        this.translate.use(lang);\r\n        let ArorEnFile =\r\n          lang === 'en'\r\n            ? JSON.parse(res[1].properties['note:note'])\r\n            : JSON.parse(res[0].properties['note:note']);\r\n        this.translate.setTranslation(\r\n          this.translate.currentLang,\r\n          { ...ArorEnFile },\r\n          true\r\n        );\r\n\r\n        this.onTranslationChanged(lang);\r\n      },\r\n      () => {\r\n        if (fallback && fallback !== lang) {\r\n          this.loadTranslation(fallback);\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Triggers a notification callback when the translation language changes.\r\n   * @param lang The new language code\r\n   */\r\n  onTranslationChanged(lang: string): void {\r\n    this.translate.onTranslationChange.next({\r\n      lang: lang,\r\n      translations: this.customLoader.getFullTranslationJSON(lang),\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Sets the target language for translations.\r\n   * @param lang Code name for the language\r\n   * @returns Translations available for the language\r\n   */\r\n  use(lang: string): Observable<any> {\r\n    this.customLoader.init(lang);\r\n    return this.translate.use(lang);\r\n  }\r\n\r\n  /**\r\n   * Gets the translation for the supplied key.\r\n   * @param key Key to translate\r\n   * @param interpolateParams String(s) to be interpolated into the main message\r\n   * @returns Translated text\r\n   */\r\n  get(\r\n    key: string | Array<string>,\r\n    interpolateParams?: Object\r\n  ): Observable<string | any> {\r\n    return this.translate.get(key, interpolateParams);\r\n  }\r\n\r\n  /**\r\n   * Directly returns the translation for the supplied key.\r\n   * @param key Key to translate\r\n   * @param interpolateParams String(s) to be interpolated into the main message\r\n   * @returns Translated text\r\n   */\r\n  instant(\r\n    key: string | Array<string>,\r\n    interpolateParams?: Object\r\n  ): string | any {\r\n    return key ? this.translate.instant(key, interpolateParams) : '';\r\n  }\r\n\r\n  getOrCreateTranslationFile(lang) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation( this.translationApiName ? this.translationApiName : 'AC_UA_Translation_GetOrCreate', {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .params({ language: lang })\r\n        .execute({\r\n          headers: {\r\n            properties: '*',\r\n          },\r\n        })\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  updateTranslationFile(doc, params = {}) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .repository()\r\n        .headers({\r\n          properties: '*',\r\n        })\r\n        .update(doc, params)\r\n    ).pipe(\r\n      map((data: any) => {\r\n        return data;\r\n      }),\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n}\r\n"]}