nuxeo-development-framework 3.7.8 → 3.7.9-dms-mep

package/src/lib/Core/services/nuxeo/new-nuxeo-overide.ts

@@ -0,0 +1,157 @@
+import { Inject } from "@angular/core";
+import { KeycloakService } from "keycloak-angular";
+import { CookieService } from "ngx-cookie-service";
+
+const Nuxeo = require('nuxeo');
+const doFetch = require('nuxeo/lib/deps/fetch');
+const Unmarshallers = require('nuxeo/lib/unmarshallers/unmarshallers');
+const Authentication = require('nuxeo/lib/auth/auth');
+const qs = require('querystring');
+
+export class NewNuxeoOverride extends Nuxeo {
+    
+    constructor(opts = {} , @Inject('environment') private environment , 
+    private cookieService : CookieService) {
+    super(opts);
+  }
+  http(opts: any = {}) {
+    const options = this._computeFetchOptions(opts);
+    return new this.Promise((resolve, reject) => {
+      this._activeRequests += 1;
+
+      const fetchOptions: any = {
+        method: options.method,
+        headers: options.headers,
+        body: options.body,
+        signal: options.signal,
+      };
+      if (opts.credentials) {
+        fetchOptions.credentials = opts.credentials;
+      } else if (!this._auth) {
+        fetchOptions.credentials = 'include';
+      }
+
+      doFetch(options.url, fetchOptions)
+        .then((res) => {
+          this._activeRequests -= 1;
+          if (res.status === 401 && !opts.refreshedAuthentication) {
+            // try re-authenticate
+            opts.refreshedAuthentication = true;
+            return this.refreshAccessToken()
+            // return Authentication.refreshAuthentication(this._baseURL, this._auth)
+              .then((refreshedToken) => {
+                //   this.keycloak.getToken().then(refreshedAuth => {
+                    this._auth = {
+                        method: 'bearerToken',
+                        token: refreshedToken,
+                        clientId: this.environment.nuxeoOptions.client_id, // optional OAuth2 client ID to refresh the access token
+                        clientSecret: this.environment.nuxeoOptions.client_secret
+                      };
+                    this._notifyAuthenticationRefreshed(refreshedToken);
+                    this.cookieService.set('CMS_CACHABLE' , this.encriptFormating(res) , 1 , '/cts')
+                    return resolve(this.http(opts));
+                //   });
+              } , (error) => {
+                this.logout();
+                this.login();
+                
+              })
+              .catch(() => {
+                this.logout();
+                this.login();
+                throw res;
+              });
+          }
+
+          if (!(/^2/.test(`${res.status}`))) {
+            const error = new Error(res);
+            throw res;
+          }
+
+          if (options.resolveWithFullResponse || res.status === 204) {
+            return resolve(res);
+          }
+
+          const contentType = res.headers.get('content-type');
+          if (contentType && contentType.indexOf('application/json') === 0) {
+            options.nuxeo = this;
+            return resolve(res.json().then((json) => Unmarshallers.unmarshall(json, options, res)));
+          }
+          return resolve(res);
+        }).catch((error) => {
+          this._activeRequests -= 1;
+          error.text().then(data => {
+            let ret = {};
+            try {
+              ret = data ? JSON.parse(data) : {};
+            } catch (e) {
+              ret = {};
+            }
+            return reject({
+              status: error.status,
+              ret
+            });
+          });
+        });
+    });
+  }
+
+  refreshAccessToken() : Promise<any> {
+    return this.getAccessToken(this.environment.nuxeoOptions.baseURL, this.environment.nuxeoOptions.client_id,
+      this._auth.token.refresh_token, this.environment.nuxeoOptions.client_secret)
+  }
+
+  login(){
+    window.location.replace(`${this.environment.nuxeoOptions.baseURL}/oauth2/authorize?client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&response_type=code&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`);
+  }
+
+  logout(){
+    this.cookieService.set('CMS_CACHABLE' , '' , 1 , '/cts')
+  }
+
+  encriptFormating(cachable){
+    let reformatted =  btoa(JSON.stringify(cachable));
+    return 'Xnd' + reformatted + 'HsTeT'
+    }
+
+    // nrefreshAccessToken = (baseURL, clientId, refreshToken, params = {}) => {
+    //   if (!baseURL) {
+    //     throw new Error('Missing `baseURL` argument');
+    //   }
+    //   if (!clientId) {
+    //     throw new Error('Missing `clientId` argument');
+    //   }
+    //   if (!refreshToken) {
+    //     throw new Error('Missing `refreshToken` argument');
+    //   }
+  
+    //   const defaultParams = { refresh_token: refreshToken, grant_type: 'refresh_token', client_id: clientId };
+    //   const body = extend(true, defaultParams, params);
+    //   return fetchAccessToken(baseURL, body);
+    // }
+
+    getAccessToken(baseURL, clientId , refreshToken , clientSecret) {
+      let body = {
+        refresh_token: refreshToken, 
+        grant_type: 'refresh_token', 
+        client_id: clientId ,  
+        client_secret : clientSecret
+      }
+      // const url = baseURL.endsWith('/') ? baseURL : `${baseURL}/`;
+      return new Promise((resolve, reject) => (
+        doFetch(`${baseURL}/oauth2/token`, {
+          method: 'POST',
+          body: qs.stringify(body),
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        })
+          .then((res) => res.json())
+          .then((token) => {
+            if (token.error) {
+              return reject(token.error);
+            }
+            return resolve(token);
+          })
+          .catch((e) => reject(e))
+      ));
+    };
+}

package/src/lib/Core/services/nuxeo/nuxeo-override.ts

@@ -0,0 +1,86 @@
+import { KeycloakService } from "keycloak-angular";
+
+const Nuxeo = require('nuxeo');
+const doFetch = require('nuxeo/lib/deps/fetch');
+const Unmarshallers = require('nuxeo/lib/unmarshallers/unmarshallers');
+const Authentication = require('nuxeo/lib/auth/auth');
+export class NuxeoOverride extends Nuxeo {
+  constructor(opts = {}, private keycloak: KeycloakService) {
+    super(opts);
+  }
+  http(opts: any = {}) {
+    const options = this._computeFetchOptions(opts);
+    return new this.Promise((resolve, reject) => {
+      this._activeRequests += 1;
+
+      const fetchOptions: any = {
+        method: options.method,
+        headers: options.headers,
+        body: options.body,
+        signal: options.signal,
+      };
+      if (opts.credentials) {
+        fetchOptions.credentials = opts.credentials;
+      } else if (!this._auth) {
+        fetchOptions.credentials = 'include';
+      }
+
+      doFetch(options.url, fetchOptions)
+        .then((res) => {
+          this._activeRequests -= 1;
+          if (res.status === 401 && !opts.refreshedAuthentication) {
+            // try re-authenticate
+            opts.refreshedAuthentication = true;
+            return this.keycloak.updateToken()
+              .then((didRefresh) => {
+                if (didRefresh) {
+                  this.keycloak.getToken().then(refreshedAuth => {
+                    this._auth = refreshedAuth;
+                    this._notifyAuthenticationRefreshed(refreshedAuth);
+                    return resolve(this.http(opts));
+                  });
+                } else {
+                  this.keycloak.logout();
+                  throw res;
+                }
+              })
+              .catch(() => {
+                throw res;
+              });
+          }
+
+          if (!(/^2/.test(`${res.status}`))) {
+            const error = new Error(res);
+            throw res;
+          }
+
+          if (options.resolveWithFullResponse || res.status === 204) {
+            return resolve(res);
+          }
+
+          const contentType = res.headers.get('content-type');
+          if (contentType && contentType.indexOf('application/json') === 0) {
+            options.nuxeo = this;
+            return resolve(res.json().then((json) => Unmarshallers.unmarshall(json, options, res)));
+          }
+          return resolve(res);
+        }).catch((error) => {
+          this._activeRequests -= 1;
+          error.text().then(data => {
+            let ret = {};
+            try {
+              ret = data ? JSON.parse(data) : {};
+            } catch (e) {
+              ret = {};
+            }
+            return reject({
+              status: error.status,
+              ret
+            });
+          });
+        });
+    });
+  }
+
+
+}

package/src/lib/Core/services/nuxeo/nuxeo.service.ts

@@ -0,0 +1,160 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import {Inject, Injectable} from '@angular/core';
+import { KeycloakService } from 'keycloak-angular';
+import { from, Observable } from 'rxjs';
+import { catchError, map, share, tap } from 'rxjs/operators';
+import { NuxeoOverride as Nuxeo } from './nuxeo-override';
+import {APP_BASE_HREF} from '@angular/common';
+import { RolesService } from '../roles/roles.service';
+import { NewNuxeoOverride as myNuxeo } from './new-nuxeo-overide';
+import { CookieService } from 'ngx-cookie-service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class NuxeoService {
+  nuxeoClient;
+  excludedUrls = [];
+  enableBearerInterceptor = true;
+  authenticated = false;
+  token;
+  tokenObservable;
+  constructor(private http: HttpClient, private keycloak: KeycloakService, 
+    @Inject(APP_BASE_HREF) private baseHref: string, 
+    @Inject('environment') private environment,
+    private cookiesService : CookieService,
+    private rolesService : RolesService) {
+
+  }
+  init(): Promise<any> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        this.keycloak.getToken().then(token => {
+        
+          this.createTokenClient(token);
+          this.nuxeoClient.connect()
+            .then((client) => {
+              this.authenticated = true;
+              resolve(client);
+              this.checkForRoles();
+            })
+            .catch((error) => {
+              reject(error);
+            });
+
+        })
+      } catch (error) {
+        reject(error);
+      }
+    });
+
+  }
+
+  initWithNuxeoToken(token){
+    return new Promise(async (resolve, reject) => {
+      try {
+          this.createClientWithNuxeoToken(token);
+          this.nuxeoClient.connect()
+            .then((client) => {
+              this.authenticated = true;
+              resolve(client);
+              this.checkForRoles();
+            })
+            .catch((error) => {
+              reject(error);
+            });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  // create nuxeo client using nuxeo token
+  createClientWithNuxeoToken(token){
+    this.nuxeoClient = new myNuxeo({
+      baseURL: this.environment.nuxeoOptions.baseURL,
+      auth: {
+        method: 'bearerToken',
+        token: token,
+        clientId: this.environment.nuxeoOptions.client_id, // optional OAuth2 client ID to refresh the access token
+        clientSecret: this.environment.nuxeoOptions.client_secret
+      }
+    } , this.environment , this.cookiesService);
+  }
+
+  // create nuxeo client using keycock token
+  createTokenClient(token) {
+    this.nuxeoClient = new Nuxeo({
+      baseURL: this.environment.nuxeo,
+      auth: {
+        method: 'bearerToken',
+        token
+      }
+    }, this.keycloak);
+  }
+
+  getToken() {
+    return this.keycloak.getToken();
+  }
+
+  doLogout() {
+    this.keycloak.logout(window.location.origin + this.baseHref);
+  }
+
+
+  isUserInRole(role: any, committeeCode = null): Observable<any> {
+    const simpleObservable = new Observable(observer => {
+      this.keycloak.isLoggedIn().then(logged => {
+        if (!logged) {
+          observer.next(false);
+        } else {
+          const hasRole = this.rolesService.isUserInRole(this.nuxeoClient.user, role, committeeCode);
+          observer.next(hasRole);
+        }
+
+      });
+    });
+
+    return simpleObservable;
+  }
+  createBlob(file): any {
+    return new Nuxeo.Blob({
+      content: file
+    });
+  }
+
+  getDuplicates(params = {}, body = {}): Observable<any> {
+    return from(
+      this.nuxeoClient
+        .operation('AC_Get_Duplicates', {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params(params)
+        .context(body)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        console.log(err);
+        throw err;
+      })
+    );
+  }
+
+  checkForRoles(){
+    this.isCtsUser();
+    this.isCtsManger();
+  }
+
+  ctsUser = false;
+  isCtsUser(){
+    this.isUserInRole('ctsSecretary', '').subscribe(data => {
+      this.ctsUser = data;
+    })
+  }
+  ctsManger= false;
+  isCtsManger(){
+    this.isUserInRole('ctsManger', '').subscribe(data => {
+      this.ctsManger = data;
+    })
+  }
+}

package/src/lib/Core/services/roles/roles.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { RolesService } from './roles.service';
+
+describe('RolesService', () => {
+  let service: RolesService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(RolesService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/Core/services/roles/roles.service.ts

@@ -0,0 +1,135 @@
+import { Inject, Injectable } from "@angular/core";
+import { GlobalAdminService } from "../../../shared-services/global-admin.service";
+import { NuxeoService } from "../nuxeo/nuxeo.service";
+
+@Injectable({
+  providedIn: "root",
+})
+export class RolesService {
+  constructor(@Inject("environment") private environment 
+  // , private globalAdmin : GlobalAdminService , private nuxeoService : NuxeoService
+  ) {}
+
+  getRoleName(role, code = null): string {
+    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): boolean {
+    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: any) => role.includes("{departmentTitle}")
+    );
+    let departmentRoles = [];
+    let isUserInDepartment: boolean = false;
+    const groups = user ? user.extendedGroups || user.groups : [];
+    if (groups && groups.length) {
+      filteredRoles.forEach((key: any) => {
+        const roleWCode = key.replace("{departmentTitle}", code);
+        departmentRoles.push(roleWCode);
+      });
+    }
+    departmentRoles = departmentRoles.filter((role: string) => {
+      return role.includes("Manager");
+    });
+    groups.forEach((group) => {
+      const groupName = group.name || group;
+      const departmentIsIncluded: boolean = departmentRoles.includes(groupName);
+      if (departmentIsIncluded) {
+        isUserInDepartment = true;
+      }
+    });
+    return isUserInDepartment;
+  }
+
+  getUserDepartment(currentUser, prefix = "cts_role_" , option?) {
+    let groupToExclude = "cts_role_sys";
+    if(option && option.isGlobalAdmin){
+      prefix = `tenant_${option.activeTenant}_cts_role_`;
+      groupToExclude =  `tenant_${option.activeTenant}_cts_role_sys`;
+    }else if(option && !option.isGlobalAdmin && option.tenantId){
+      prefix = `tenant_${option.tenantId}_cts_role_`;
+      groupToExclude = `tenant_${option.tenantId}_cts_role_sys`;
+    }
+    let allGroups: string[] = currentUser.properties.groups;
+    let departmentCode = "";
+    allGroups.some((group) => {
+      if (!group.includes(groupToExclude) && group.includes(prefix)) {
+        departmentCode = group;
+        return true;
+      }
+    });
+    let prefixLength = prefix.length;
+    departmentCode = departmentCode.substring(prefixLength);
+    let lastIndex = departmentCode.lastIndexOf("_");
+    departmentCode = departmentCode.substring(0, lastIndex);
+    return departmentCode;
+  }
+}