D-Net

import {InvoiceMasterData} from './invoice-master-data.interface';

export interface Record {

  id: number;

  documentClassificationId: number;

  documentSubclassificationId: number;

  ipowerClientId: number;

  dmsFileCode: string;

  abbyyConfidenceLvl: number;

  abbyyTemplate: string;

  invoiceMasterData: InvoiceMasterData;

}

export interface LookupData {

  id: number;

  name: string;

}

export interface SystemException {

  id: number;

  processId: number;

  clientId: string;

  jobName: string;

  dmsFileCode: string;

  message: string;

  cause: string;

  creationDatetime : Date;

  trace: string;

}

import {Sort} from './sort.interface';

export interface Pageable {

  sort: Sort;

  offset: number;

  pageNumber: number;

  pageSize: number;

  unpaged: boolean;

  paged: boolean;

}

import { DocumentClassification } from "./document-classification.interface";

export interface DocumentSubclassification {

  subclassificationId: number;

  subclassificationName: string;

  documentClassification: DocumentClassification;

}

import { LookupData } from './lookup-data.interface';

import { ReceivedFiles } from './receivedFiles.interface';

export interface StatusPerDocument {

  statusPerDocRecId: number;

  batchId: number;

  documentStatusLastUpdate: Date;

  documentCurrentStatusId: LookupData;

  receivedFile: ReceivedFiles;

}

import { Template } from './template.interface';

import { DocumentClassification } from './document-classification.interface';

import { IPowerClient } from './ipower-client.interface';

import { CapturingVerification } from './capturing-verification.interface';

import { JournalVerification } from './journal-verification.interface';

export interface VerificationRule {

  id: number;

  confidenceLevelMinThreshold: number;

  alteryxRoutineId: string;

  verificationRuleStatus: string;

  client: IPowerClient;

  docClassificationCategory: DocumentClassification

  template: Template;

  capturingVerification: CapturingVerification;

  journalVerification: JournalVerification;

}

import {FILE_TYPE} from '../enums/FILE_TYPE.enum';

export interface InboxSearchCriteriaInterface {

  receivedFrom: Date;

  receivedTo: Date;

  fileCode: string;

  fileType: FILE_TYPE;

  //TODO change me in the future front and back

  ignore_status: boolean;

  ipowerClientName: string;

  ipowerClientCode: string;

  personalData: boolean;

  userId: string;

}

export interface InvoiceMasterData {

  id: number;

  supplierName: string;

  supplierTaxCode: string;

  customerName: string;

  customerTaxCode: string;

  invoiceNumber: string;

  invoiceType: string;

  invoiceIssueDate: Date;

  deliveryAddress: string;

  totalPriceBeforeDiscount: number;

  discountPercentage: number;

  discountAmount: number;

  totalPriceBeforeVat: number;

  vatRate: number;

  vatCode: number;

  vatAmount: number;

  totalAmount: number;

  totalAmountInBaseCurrency: number;

  numberOfDetailLines: number;

}

export interface PieModel {

  labels: string[];

  datasets: dataset[];

}

export interface dataset {

  data: number[];

  backgroundColor: string[];

  hoverBackgroundColor: string[];

}

import {Record} from './record.interface';

import {LookupData} from './lookup-data.interface';

export interface AlteryxException {

  id: number;

  record: Record[];

  alteryxExceptionStatus: LookupData;

  alteryxRoutineId: number;

  alteryxExceptionDescription: string;

}

export interface IPowerAssignment {

  id: number;

  name: string;

  description: string;

  status: string;

}

export interface InvoiceProcessesRouterParams {

  clientCode: string;

  docClassification: number;

}

import { TestBed } from '@angular/core/testing';

import { RouterTestingModule } from '@angular/router/testing';

import { AppComponent } from './app.component';

describe('AppComponent', () => {

  beforeEach(async () => {

    await TestBed.configureTestingModule({

      imports: [

        RouterTestingModule

      ],

      declarations: [

        AppComponent

      ],

    }).compileComponents();

  });

  it('should create the app', () => {

    const fixture = TestBed.createComponent(AppComponent);

    const app = fixture.componentInstance;

    expect(app).toBeTruthy();

  });

  it(`should have as title 'RTA-Admin-UI'`, () => {

    const fixture = TestBed.createComponent(AppComponent);

    const app = fixture.componentInstance;

    expect(app.title).toEqual('RTA-Admin-UI');

  });

  it('should render title', () => {

    const fixture = TestBed.createComponent(AppComponent);

    fixture.detectChanges();

    const compiled = fixture.nativeElement;

    expect(compiled.querySelector('.content span').textContent).toContain('RTA-Admin-UI app is running!');

  });

});

export interface SearchResponse<T> {

    totalPages: number;

    totalElements: number;

    data: T[];

  }

<p-toast preventOpenDuplicates="true"></p-toast>

<div class="container">

  <div class="p-grid p-nogutter">

    <div class="p-col-12">

      <app-header></app-header>

      <app-main-page></app-main-page>

    </div>

  </div>

</div>

import { AuthService } from './shared/services/auth.service';

import { Component, OnInit } from '@angular/core';

import { PrimeNGConfig } from 'primeng/api';

@Component({

  selector: 'app-root',

  templateUrl: './app.component.html',

  styleUrls: ['./app.component.scss']

})

export class AppComponent implements OnInit {

  constructor(private primengConfig: PrimeNGConfig, private authService: AuthService) { }

  ngOnInit(): void {

    this.primengConfig.ripple = true;

    this.authService.initializeOAuth2Login();

  }

}

export interface ProcessStatus {

  id: number;

  name: string;

}

import { TranslateModule } from '@ngx-translate/core';

import { NgModule } from '@angular/core';

import { CommonModule } from '@angular/common';

import { HttpClientModule } from '@angular/common/http';

import { ValidationMessageComponent } from './utils/components/validation-message/validation-message.component';

import { HourMinutesSecsPipe } from './pipes/hour-minutes-secs.pipe';

@NgModule({

  declarations: [ValidationMessageComponent, HourMinutesSecsPipe],

  imports: [

    CommonModule,

    HttpClientModule

  ],

  exports: [

    TranslateModule,

    ValidationMessageComponent,

    HourMinutesSecsPipe

  ]

})

export class SharedModule {

}

export interface PwcUser {

  email?: string;

  cloudEmail?: string;

  preferredMail?: string;

  guid: string;

}

export interface CardItem {

  title: string;

  subtitle: string;

  headerImage: string;

  footerImage: string;

  path: string;

}

import { HourMinutesSecsPipe } from './hour-minutes-secs.pipe';

describe('HourMinutesSecsPipe', () => {

  it('create an instance', () => {

    const pipe = new HourMinutesSecsPipe();

    expect(pipe).toBeTruthy();

  });

});

import { RtaUser } from './../rta-user.interface';

import { Role } from '../role.interface';

import { IPowerClient } from 'src/app/shared/models/ipower-client.interface';

import { UserAccess } from '../user-access.interface';

export interface AssignUpdateRole {

  id: number;

  ipowerClient: IPowerClient;

  role: Role;

  users: RtaUser;

}

import {FilesPerProcess} from './files-per-process.interface';

import {LookupData} from './lookup-data.interface';

export interface InvoiceProcess {

  id: number;

  processCreationDatetime: Date;

  documentClassificationId: number;

  processStatus: LookupData;

  userId: string;

  filesPerProcess: FilesPerProcess[];

}

import { IPowerClient } from "../ipower-client.interface";

export interface SearchSystemException {

  processId: number;

  jobName: string;

  dmsFileCode: string;

  dateFrom: Date;

  dateTo: Date;

  clientId: IPowerClient;

}

import {LookupData} from './lookup-data.interface';

import {JournalEntry} from './journal-entry.interface';

import {AlteryxException} from './alteryx-exception.interface';

import {AlteryxUnhandledData} from './alteryx-unhandled-data.interface';

import {FilesPerProcess} from './files-per-process.interface';

import {ProcessFailedRecord} from './process-failed-record.interface';

export interface FullInvoiceProcess {

  id: number;

  processCreationDatetime: Date;

  documentClassificationId: number;

  processStatus: LookupData;

  userId: string;

  filesPerProcess: FilesPerProcess[];

  recordsPerProcess: any;

  journalEntries: JournalEntry[];

  alteryxExceptions: AlteryxException[];

  alteryxUnhandled: AlteryxUnhandledData[];

  failedRecords: ProcessFailedRecord[];

}

import { MenuItem } from 'primeng/api';

export interface VerticalMenu {

  title: string;

  items: MenuItem[];

}

import { Pipe, PipeTransform } from '@angular/core';

@Pipe({

  name: 'hourMinutesSecs'

})

export class HourMinutesSecsPipe implements PipeTransform {

  transform(totalSeconds: number, ...args: unknown[]): unknown {

    const hours = Math.floor(totalSeconds / 3600);

    const minutes = Math.floor((totalSeconds % 3600) / 60);

    const seconds = totalSeconds % 60;

    let result = `${minutes

      .toString()

      .padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;

    if (!!hours) {

      result = `${hours.toString().padStart(2, '0')}:${minutes

        .toString()

        .padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;

    }

    return result;

  }

}

import { FILE_TYPE } from './../enums/FILE_TYPE.enum';

import { Injectable } from '@angular/core';

@Injectable({

  providedIn: 'root'

})

export class UtilsService {

  constructor() { }

  public base64ToFile(base64Data: string, contentType: FILE_TYPE): Blob {

    const byteString = window.atob(base64Data);

    const arrayBuffer = new ArrayBuffer(byteString.length);

    const int8Array = new Uint8Array(arrayBuffer);

    for (let i = 0; i < byteString.length; i++) {

      int8Array[i] = byteString.charCodeAt(i);

    }

    const blob = new Blob([int8Array], { type: this.convertContentType(contentType) });

    return blob;

  }

  public convertContentType(type: FILE_TYPE): string {

    switch (type) {

      case FILE_TYPE.DOC:

        return 'application/msword';

      case FILE_TYPE.DOCX:

        return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';

      case FILE_TYPE.PDF:

        return 'application/pdf';

      case FILE_TYPE.PNG:

        return 'image/png';

      case FILE_TYPE.XLS:

        return 'application/vnd.ms-excel';

      case FILE_TYPE.XLSX:

        return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';

    }

  }

}

import { Right } from 'src/app/shared/models';

export interface RightsCategory {

  id: number;

  name: string;

  rights: Right[];

}

<div *ngIf="displayMessage">

  <p class="validation-message">{{validationMessage}}</p>

</div>

import { Component, Input, OnInit } from '@angular/core';

import { FormControl } from '@angular/forms';

@Component({

  selector: 'app-validation-message',

  templateUrl: './validation-message.component.html',

  styleUrls: ['./validation-message.component.scss']

})

export class ValidationMessageComponent implements OnInit {

  @Input() control: FormControl;

  @Input() validationMessage: String;

  @Input() set displayEvenIfPristine(val: boolean) {

    this._displayEvenIfPristine = val;

    this.shouldMessageBeShown();

  }

  _displayEvenIfPristine: boolean

  displayMessage: boolean;

  constructor() { }

  ngOnInit(): void {

    this.shouldMessageBeShown();

    this.control.statusChanges.subscribe(() => this.shouldMessageBeShown());

  }

  shouldMessageBeShown() {

    let temp = this.control.invalid && (this.control.dirty || this.control.touched || this._displayEvenIfPristine);

    this.displayMessage = temp;

  }

}

@import 'src/styles';

.validation-message{

  color: red;

  font-size: 90%;

  margin: 0px;

  padding: 0px;

}

import { ComponentFixture, TestBed } from '@angular/core/testing';

import { ValidationMessageComponent } from './validation-message.component';

describe('ValidationMessageComponent', () => {

  let component: ValidationMessageComponent;

  let fixture: ComponentFixture<ValidationMessageComponent>;

  beforeEach(async () => {

    await TestBed.configureTestingModule({

      declarations: [ ValidationMessageComponent ]

    })

    .compileComponents();

  });

  beforeEach(() => {

    fixture = TestBed.createComponent(ValidationMessageComponent);

    component = fixture.componentInstance;

    fixture.detectChanges();

  });

  it('should create', () => {

    expect(component).toBeTruthy();

  });

});

import {LookupData} from './lookup-data.interface';

import {ReceivedFile} from './inbox-document.interface';

export interface DownloadingProcedureMetadata {

  id: number;

  downloadingProcedureStart: Date;

  downloadingProcedureFinish: Date;

  downloadingProcedureStatusId: LookupData;

  estimatedTime: Date;

  receivedFiles: ReceivedFile[];

}

export interface CapturingVerification {

  id: number;

  capturingVerificationsName: string;

}

export interface IPowerClient {

  id: string;

  name: string;

  status: string;

  clientCode: string;

  bcServer: string;

  bcPort: string;

  bcDbInstance: string;

  hotFolderId: string;

  confidenceMinLvl: number;

  confidenceMaxLvl: number;

}

export interface ConfiguratorParameter {

  configurationId: number;

  configurationVariable: string;

  variableType: string;

  integerValue: number;

  stringValue: string;

}

import { PieModel } from './chart.interface';

export interface DashboardSection {

  type: string;

  totalClients: number;

  totalProcesses: number;

  totalExceptions: number;

  totalUnhandled: number;

  totalPages: number;

  totalElements: number;

  pie?: PieModel;

  selectedElements: number;

  selectedPage: number;

  resultsLoading: boolean;

  aggregatedResults: ProcessesPerClient[];

}

export interface ProcessesPerClient {

  clientName?: string;

  clientId: string;

  processesNumber: number;

  unhandledNumber: number;

  exceptionsNumber: number;

}

import { RtaUser } from './rta-user.interface';

import { Role } from './role.interface';

import { IPowerClient } from 'src/app/shared/models/ipower-client.interface';

import { USER_ACCESS_STATUS } from '../enums/USER_ACCESS_STATUS.enum';

export interface UserAccess {

  id: number;

  ipowerClient: IPowerClient;

  role: Role;

  users: RtaUser;

  status: USER_ACCESS_STATUS;

}

import { CardItem } from "./card-item.interface";

export interface AdministrationSection {

  title: string;

  subSections: CardItem[];

}

import { environment } from 'src/environments/environment';

import { Injectable } from '@angular/core';

import { GenericRestService } from './generic-rest.service';

import { LookupData } from '../models/lookup-data.interface';

import { HttpClient } from '@angular/common/http';

import { Observable, of, } from 'rxjs';

import { FullInvoiceProcess } from '../models/full-invoice-process.interface';

import { InvoiceProcess } from '../models/invoice-process.interface';

import { AlteryxUnhandledData } from '../models/alteryx-unhandled-data.interface';

import { InvoiceMasterData } from '../models/invoice-master-data.interface';

import { SentStringInterface } from '../models/sentString.interface';

import {JournalEntry} from "../models/journal-entry.interface";

import {AlteryxException} from "../models/alteryx-exception.interface";

import {ProcessFailedRecord} from "../models/process-failed-record.interface";

import {ProcessHistory} from "../models/process-history.interface";

@Injectable({

  providedIn: 'root'

})

export class InvoiceProcessesService extends GenericRestService<InvoiceProcess> {

  constructor(private http: HttpClient) {

    super(`${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}/processes`, http);

  }

  getAllStatuses(): Observable<LookupData> {

    return this.http.get<LookupData>(this.baseUrl + '/process-status/all');

  }

  getAllFileTypes(): Observable<string[]> {

    return of(['XL', 'PDF', 'DOCX']);

  }

  getFullInvoiceProcessById(invoiceProcessId: number): Observable<FullInvoiceProcess> {

    return this.http.get<FullInvoiceProcess>(this.baseUrl + '/full/' + invoiceProcessId.toString());

  }

  getIframe(invoiceProcessId: string): Observable<string> {

    return this.http.get<string>(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}/abbyy` + '/verify/' + invoiceProcessId.toString());

  }

  getAssignToUsersDistinct(username: string): Observable<string[]> {

    return this.http.get<string[]>(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}/processes/search-username/` + username.toString());

  }

  reclassifyRecords(id: string, selectedClassification: any, selectedSubClassification: any): Observable<InvoiceMasterData> {

    return this.http.post<any>(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/alteryx/reclassify/' + id, '', {

      params: {

        docClassificationId: selectedClassification,

        docSubClassificationId: selectedSubClassification

      }

    });

  }

  recalculateException(id: number): Observable<any> {

    return this.http.post<any>(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/alteryx/recalculate-exception/' + id, ''

    );

  }

  updateVerificationCompletedForProcess(id: number): Observable<any> {

    return this.http.get(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/abbyy/verification-completed/' + id

    );

  }

  downloadFile(id: number): Observable<string> {

    return this.http.get(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/download-file/' + id, { responseType: 'text' }

    );

  }

  assignProcess(id: number, name: string): any {

    return this.http.put(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/assign-process?processId=' + id + '&username=' + name, '', {responseType: 'text'}

    );

  }

  unassignProcess(id: number): any {

    return this.http.put(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/assign-process?processId=' + id, '', {responseType: 'text'}

    );

  }

  refreshJournalEntries(processId: number): Observable<JournalEntry[]> {

    return this.http.get<JournalEntry[]>(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/refresh-journal/' + processId

    );

  }

  refreshAlteryxExceptions(processId: number): Observable<AlteryxException[]> {

    return this.http.get<AlteryxException[]>(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/refresh-alteryx-exceptions/' + processId

    );

  }

  refreshAlteryxUnhandled(processId: number): Observable<AlteryxUnhandledData[]> {

    return this.http.get<AlteryxUnhandledData[]>(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/refresh-alteryx-unhandled/' + processId

    );

  }

  sendProcessToAlteryxRecalculation(id: number): any {

    return this.http.put(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/send-to-alteryx-recalculation/' + id , '', {responseType: 'text'}

    );

  }

  sendProcessToAbbyyVerification(id: number): any {

    return this.http.put(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/send-to-abbyy-verification/' + id , '' , {responseType: 'text'}

    );

  }

  setProcessCanceled(id: number): any {

    return this.http.put(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/set-canceled/' + id , '' , {responseType: 'text'}

    );

  }

  setProcessCompleted(id: number): any {

    return this.http.put(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/set-completed/' + id , '' , {responseType: 'text'}

    );

  }

  getProcessHistory(processId: number): Observable<ProcessHistory[]> {

    return this.http.get<ProcessHistory[]>(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}` +

      '/processes/process-history/' + processId

    );

  }

}

import { USER_RIGHTS } from './../enums/USER_RIGHTS.enum';

import { IPowerClient } from './../models/ipower-client.interface';

import { RightsByClient } from './../models/rights-by-client.interface';

import { RtaUser } from './../models/rta-user.interface';

import { environment } from 'src/environments/environment';

import { ApiService } from './api.service';

import { PwcUser } from './../models/pwc-user-interface';

import { authCodeFlowConfig } from '../auth-codeflow-config';

import { OAuthService } from 'angular-oauth2-oidc';

import { EventEmitter, Injectable, Output } from '@angular/core';

import { Router } from '@angular/router';

import { BehaviorSubject, ReplaySubject, Observable, combineLatest, from, interval } from 'rxjs';

import { catchError, filter, map, mergeMap } from 'rxjs/operators';

import { Right } from '../models';

import { UserAccess } from '../models/user-access.interface';

import { USER_ACCESS_STATUS } from '../enums/USER_ACCESS_STATUS.enum';

@Injectable({

  providedIn: 'root'

})

export class AuthService {

  @Output() authStatusChanged = new EventEmitter<boolean>();

  private isAuthenticatedSubject$ = new BehaviorSubject<boolean>(false);

  public isAuthenticated$ = this.isAuthenticatedSubject$.asObservable();

  private isDoneLoadingSubject$ = new ReplaySubject<boolean>();

  public isDoneLoading$ = this.isDoneLoadingSubject$.asObservable();

  public tokenExpiresInSec$ = new BehaviorSubject(0);

  private loggedInUserDetails: RtaUser;

  private loggedInUserRights: RightsByClient[] = [];

  /**

   * Publishes "true" only if all the asynchronous initial login calls have completed and the user ended up being authenticated.

   * Essentially, it combines:

   * - the latest known status of the user (whether they are authorized)

   * - whether all the oauth2 shenanigan calls have been completed :P

   */

  public canActivateProtectedRoutes$: Observable<boolean> = combineLatest([

    this.isAuthenticated$,

    this.isDoneLoading$

  ]).pipe(

    map(values => values.every(b => b))

  );

  constructor(private router: Router, private oauthService: OAuthService, private api: ApiService) {

    this.oauthService.events

      .subscribe(_ => {

        this.isAuthenticatedSubject$.next(this.oauthService.hasValidAccessToken());

      });

    this.oauthService.events

      .pipe(filter(e => ['token_received'].includes(e.type)))

      .subscribe(e => this.oauthService.loadUserProfile());

    this.oauthService.events

      .pipe(filter(e => ['session_terminated', 'session_error'].includes(e.type)))

      .subscribe(e => this.navigateToLoginPage());

  }

  private navigateToLoginPage(): void {

    this.router.navigateByUrl('/login');

  }

  public initializeOAuth2Login(): void {

    this.oauthService.configure(authCodeFlowConfig);

    from(this.oauthService.loadDiscoveryDocument())

      .pipe(

        mergeMap((successEvent) => {

          console.log('successEvent', successEvent);

          return from(this.oauthService.tryLoginImplicitFlow());

        }),

        // @TODO: Handle errors

        catchError((err) => {

          return err;

        })

      ).subscribe(() => {

        if (!this.oauthService.hasValidAccessToken()) {

          if (environment.oAuth2.autoLogin) {

            this.oauthService.initImplicitFlow();

          }

          else {

            this.authStatusChanged.emit(false);

          }

        } else {

          // Succesfully authenticated :)

          this.authStatusChanged.emit(true);

          this.getUserDetails();

        }

      });

  }

  public getUserDetails(): void {

    const email = environment.staging || environment.production ?

      (this.oauthService.getIdentityClaims() as PwcUser).cloudEmail :

        (this.oauthService.getIdentityClaims() as PwcUser).email;

    // Request only the ACTIVE UserAccess relations of the user.

    this.api.getUserByEmail(email, USER_ACCESS_STATUS.ACTIVE).subscribe((result) => {

      this.loggedInUserDetails = result;

      // Process the received user data and assign a proper value to 'this.loggedInUserRights'.

      this.assignLoggedInUserRights(result);

      this.isDoneLoadingSubject$.next(true);

      this.startTokenExpirationCounter();

      console.log('Logged-in User\'s Rights', this.userRights);

    },

      err => {

        // @TODO: Handle errors

        console.log(err);

        this.isDoneLoadingSubject$.next(true);

      });

  }

  private assignLoggedInUserRights(user: RtaUser) {

    // ClientId to RightsByClient.

    let rightsPerClientMap: Map<string, RightsByClient> = new Map();

    user.userAccessUsers.forEach(ua => {

      // If we don't have an entry for this client, create it. Initialise it with the client, but no rights.

      if (!rightsPerClientMap.has(ua.ipowerClient.id)) {

        let newEntry: RightsByClient = {

          client: ua.ipowerClient,

          rights: []

        }

        rightsPerClientMap.set(ua.ipowerClient.id, newEntry);

      }

      // Now, regardless of whether the entry existed or not, add the rights.   -Map does not

      rightsPerClientMap.get(ua.ipowerClient.id).rights = rightsPerClientMap.get(ua.ipowerClient.id).rights.concat(ua.role.rightsList);

    });

    // Finally, pass them all unto the 'loggedInUserRights' variable.

    this.loggedInUserRights = [];

    rightsPerClientMap.forEach((value, key) => this.loggedInUserRights.push(value));

  }

  // This is mostly useful if "autoLogin" is false in environment, so we manually trigger the final step of the OAuth2 login flow.

  login(targetUrl?: string): void {

    this.oauthService.initLoginFlow(targetUrl || this.router.url);

  }

  logout(): void {

    this.loggedInUserDetails = null;

    this.loggedInUserRights = null;

    this.oauthService.logOut(true);

    this.authStatusChanged.emit(false);

    this.router.navigateByUrl('/login');

  }

  isLoggedIn(): boolean {

    return this.oauthService.hasValidAccessToken();

  }

  startTokenExpirationCounter(): void {

    const expiringAt = this.oauthService.getAccessTokenExpiration() ? this.oauthService.getAccessTokenExpiration() : Date.now();

    const now = Date.now();

    let remainingSecs = Math.floor(expiringAt / 1000) - Math.floor(now / 1000);

    const secondsCounter = interval(1000);

    // Subscribe to begin publishing values

    const subscription = secondsCounter.subscribe(n => {

      remainingSecs = remainingSecs > 0 ? remainingSecs - 1 : remainingSecs;

      this.tokenExpiresInSec$.next(remainingSecs);

    });

  }

  /*

   * Public Methods

   */

  public get userDetails(): RtaUser { return this.loggedInUserDetails; }

  public get userRights(): RightsByClient[] { return this.loggedInUserRights; }

  public userHasRightForClient(right: USER_RIGHTS, clientId: string): boolean {

    // return true;   // Bypass. Also has to be set in USER_RIGHTS.isGrantedToUser()

    return this.userRights.find(rdc => rdc.client.id == clientId)?.rights?.find(r => r.code == right.code) != null;

  }

}

import { TestBed } from '@angular/core/testing';

import { UtilsService } from './utils.service';

describe('UtilsService', () => {

  let service: UtilsService;

  beforeEach(() => {

    TestBed.configureTestingModule({});

    service = TestBed.inject(UtilsService);

  });

  it('should be created', () => {

    expect(service).toBeTruthy();

  });

});

import {ReceivedFile} from './inbox-document.interface';

import {LookupData} from './lookup-data.interface';

import { ReceivedFiles } from './receivedFiles.interface';

export interface InboxBatch {

  batchId: number;

  documentCurrentStatusId: LookupData;

  documentStatusLastUpdate: Date;

  statusPerDocRecId: number;

  receivedFile: ReceivedFiles;

}

import {Record} from './record.interface';

import {LookupData} from './lookup-data.interface';

export interface AlteryxUnhandledData {

  id:string;

  record: Record;

  alteryxUnhandledStatus: LookupData;

}

import { UserAccess } from './user-access.interface';

import { Right } from './index';

export interface Role {

  id: number;

  name: string;

  description: string;

  readOnly: boolean;

  status: boolean;

  canBeDeleted: boolean;

  isGlobal: boolean;

  rightsList: Right[];

  userAccessRoles: UserAccess[];

}

import {ReceivedFile} from './inbox-document.interface';

export interface FilesPerProcess {

  id: number;

  receivedFile: ReceivedFile;

}

import { UserAccess } from './user-access.interface';

export interface RtaUser {

  id: number;

  name: string;

  surname: string;

  email: string;

  status: string;

  userCode: string;

  userAccessUsers: UserAccess[];

}

export * from './role.interface';

export * from './right.interface';

export * from './i-power-assignment.interface';

import { TestBed } from '@angular/core/testing';

import { ApplicationLevelExceptionService } from './application-level-exception.service';

describe('ApplicationLevelExceptionService', () => {

  let service: ApplicationLevelExceptionService;

  beforeEach(() => {

    TestBed.configureTestingModule({});

    service = TestBed.inject(ApplicationLevelExceptionService);

  });

  it('should be created', () => {

    expect(service).toBeTruthy();

  });

});

import { LookupData } from './lookup-data.interface';

export interface JournalEntry {

  id: number;

  recordId: number;

  journalEntriesStatus: LookupData;

  postingDate: Date;

  documentType: string;

  documentNo: string;

  accountType: string;

  accountNo: string;

  description: string;

  eu3PartyTrade: string;

  genPostingType: string;

  genBusPostingGroup: string;

  genProdPostingGroup: string;

  vatBusPostingGroup: string;

  vatProdPostingGroup: string;

  deferralCode: number;

  currencyCode: string;

  vatBaseAmount: number;

  vatAmount: number;

  amount: number;

  amountLCY: number;

  balAccountType: string;

  balAccountNo: string;

  balGenPostingType: string;

  externalDocumentNo: string;

  dmsCodeNo: string;

  correction: string;

  comment: string;

  shortcutDimension1Code: string;

  shortcutDimension2Code: string;

  shortcutDimension3Code: string;

  shortcutDimension4Code: string;

  shortcutDimension5Code: string;

  shortcutDimension6Code: string;

  shortcutDimension7Code: string;

  shortcutDimension8Code: string;

  shortcutDimension9Code: string;

  shortcutDimension10Code: string;

  applied: string;

  appliedAutomatically: string;

  appliesToDocNo: string;

  appliesToDocType: string;

  appliesToExtDocNo: string;

  appliesToId: string;

}

export interface JournalVerification {

  id: number;

  journalVerificationsName: string;

}

import { TestBed } from '@angular/core/testing';

import { VerificationRulesService } from './verification-rules.service';

describe('VerificationRulesServiceService', () => {

  let service: VerificationRulesService;

  beforeEach(() => {

    TestBed.configureTestingModule({});

    service = TestBed.inject(VerificationRulesService);

  });

  it('should be created', () => {

    expect(service).toBeTruthy();

  });

});

import { TestBed } from '@angular/core/testing';

import { JournalVerificationsService } from './journal-verifications.service';

describe('JournalVerificationsService', () => {

  let service: JournalVerificationsService;

  beforeEach(() => {

    TestBed.configureTestingModule({});

    service = TestBed.inject(JournalVerificationsService);

  });

  it('should be created', () => {

    expect(service).toBeTruthy();

  });

});

import { FILE_TYPE } from '../enums/FILE_TYPE.enum';

import { DownloadingProcedureMetadata } from './downloading-procedure-metadata.interface';

export interface ReceivedFiles {

  id: number;

  downloadingProcedureMetadata: DownloadingProcedureMetadata;

  dmsFileCode: string;

  dmsFileName: string;

  dmsFileType: FILE_TYPE;

  dmsPersonalData: boolean;

  dmsClientCode: string;

  rtaReceivedDate: Date;

  dmsInsertedDate: Date;

  rtaFolderPath: string;

  dmsDocumentNumber : string;

  rtaFileName: string;

}

import { TestBed } from '@angular/core/testing';

import { DocumentSubclassificationsService } from './document-subclassifications.service';

describe('DocumentSubclassificationsService', () => {

  let service: DocumentSubclassificationsService;

  beforeEach(() => {

    TestBed.configureTestingModule({});

    service = TestBed.inject(DocumentSubclassificationsService);

  });

  it('should be created', () => {

    expect(service).toBeTruthy();

  });

});

import { TestBed } from '@angular/core/testing';

import { ConfiguratorService } from './configurator.service';

describe('ConfiguratorService', () => {

  let service: ConfiguratorService;

  beforeEach(() => {

    TestBed.configureTestingModule({});

    service = TestBed.inject(ConfiguratorService);

  });

  it('should be created', () => {

    expect(service).toBeTruthy();

  });

});

import { environment } from 'src/environments/environment';

import { Category } from './../../models/category.interface';

import { IPowerClient } from './../../models/ipower-client.interface';

import { Observable } from 'rxjs';

import { GenericRestService } from './../generic-rest.service';

import { Injectable } from '@angular/core';

import { Template } from '../../models/template.interface';

import { HttpClient } from '@angular/common/http';

@Injectable({

  providedIn: 'root'

})

export class TemplatesService extends GenericRestService<Template> {

  constructor(private http: HttpClient) {

    super(`${environment.baseApiUrl}${environment.apiUrl.verificationRulesWs}/templates`, http); // TODO: Change this when GenericRestService<> changes.

  }

  public createNewTemplate(template: Template): Observable<Template> {

    // Create the model required by the backend ('CreateTemplateRequestModel') before using the generic create method.

    let createCategoryRequestModel = {

      id: null,

      category: template.category,

      subCategoryCode: template.subCategoryCode,

      abbyyTemplate: template.abbyyTemplate,

      clientId: template.client.id,

      // Just to comply to the required Template interface.

      documentClassification: null,

      client: null

    }

    return super.create(createCategoryRequestModel);

  }

  public updateTemplate(template: Template): Observable<Template> {

    // Create the model required by the backend ('CreateTemplateRequestModel') before using the generic create method.

    let updateCategoryRequestModel = {

      id: template.id,

      category: template.category,

      subCategoryCode: template.subCategoryCode,

      abbyyTemplate: template.abbyyTemplate,

      clientId: template.client.id,

      // Just to comply to the required Template interface.

      documentClassification: null,

      client: null

    }

    return super.update(updateCategoryRequestModel);

  }

}

import { Injectable } from '@angular/core';

import {HttpClient} from '@angular/common/http';

import {environment} from '../../../../environments/environment';

import {Observable} from 'rxjs';

import {ConfiguratorParameter} from '../../models/configurator-parameter.interface';

import {GenericRestService} from '../generic-rest.service';

@Injectable({

  providedIn: 'root'

})

export class ConfiguratorService extends GenericRestService<ConfiguratorParameter>  {

  constructor(private http: HttpClient) {

    super(`${environment.baseApiUrl}${environment.apiUrl.configurationWs}/platform-configurations`, http);

  }

  getConfiguratorParameters(): Observable<ConfiguratorParameter[]> {

    return this.http.get<ConfiguratorParameter[]>(this.baseUrl + `/all`);

  }

  public updateConfiguratorParameter(parameter: ConfiguratorParameter) {

    // Create the model required by the backend ('CreateCategoryRequestModel') before using the generic create method.

    const updateParameterRequestModel = {

      configurationId: parameter.configurationId,

      configurationVariable: parameter.configurationVariable,

      variableType: parameter.variableType,

      integerValue: parameter.integerValue,

      stringValue: parameter.stringValue

    };

    // return super.update(updateParameterRequestModel);

    return this.http.put(`${this.baseUrl}/` + parameter.configurationId, updateParameterRequestModel);

  }

}

import { HttpClient } from "@angular/common/http";

import { Injectable } from "@angular/core";

import { environment } from "src/environments/environment";

import { SystemException } from "../../models/system-exception.interface";

import { GenericRestService } from "../generic-rest.service";

@Injectable({

  providedIn: 'root'

})

export class ApplicationLevelExceptionService extends GenericRestService<SystemException> {

  constructor(private http: HttpClient) {

    super(`${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}/exceptions`, http);

  }

}