D-Net

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();

  }

}

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 {

}

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 { HourMinutesSecsPipe } from './hour-minutes-secs.pipe';

describe('HourMinutesSecsPipe', () => {

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

    const pipe = new HourMinutesSecsPipe();

    expect(pipe).toBeTruthy();

  });

});

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 { 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();

  });

});

<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 { 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();

  });

});

export interface PieModel {

  labels: string[];

  datasets: dataset[];

}

export interface dataset {

  data: number[];

  backgroundColor: string[];

  hoverBackgroundColor: string[];

}

export interface SearchResponse<T> {

    totalPages: number;

    totalElements: number;

    data: T[];

  }

export interface PwcUser {

  email?: string;

  cloudEmail?: string;

  preferredMail?: string;

  guid: string;

}

export interface SearchUser {

    userCode: string;

    name: string;

    surname: string;

    email: string;

    status: string; 

  }

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 { IPowerClient } from "../ipower-client.interface";

export interface SearchSystemException {

  processId: number;

  jobName: string;

  dmsFileCode: string;

  dateFrom: Date;

  dateTo: Date;

  clientId: IPowerClient;

}

export interface CardItem {

  title: string;

  subtitle: string;

  headerImage: string;

  footerImage: string;

  path: string;

}

export interface DocumentClassification {

  classificationId: number;

  classificationName: string;

}

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 {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 {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[];

}

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

export interface InvoiceProcessCriteriaInterface {

  userId: string;

  fromDate: Date;

  toDate: Date;

  docClassification: string;

  fileCode: string;

  fileType: FILE_TYPE;

  processId: number;

  processStatus: string;

  ipowerClientName: string;

  ipowerClientCode: string;

  personalData: boolean;

  username: string;

}

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

export interface RightsCategory {

  id: number;

  name: string;

  rights: Right[];

}

import { MenuItem } from 'primeng/api';

export interface VerticalMenu {

  title: string;

  items: MenuItem[];

}

export interface CapturingVerification {

  id: number;

  capturingVerificationsName: string;

}

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

export interface Category {

  id: number;

  documentClassification?: DocumentClassification;

  categoryName: string;

  categoryCode: string;

}

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;

}

export interface ConfiguratorParameter {

  configurationId: number;

  configurationVariable: string;

  variableType: string;

  integerValue: number;

  stringValue: 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 DownloadProcessTemp {

  id: number;

  iPowerClientName: string;

  iPowerClientCode: string;

  dmsClientWorkspace: string;

  dmsActualWorkspace: string;

  status: string;

  results: number;

  downloadDate: Date;

}

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

export interface AdministrationSection {

  title: string;

  subSections: CardItem[];

}

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;

}

export interface JournalVerification {

  id: number;

  journalVerificationsName: string;

}

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 { 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;

}

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;

}

export interface UserAutoComplete {

    id: string;

    name: string;

    surname: string;

    email: string;

    status: string;

  }

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

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

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

export interface Template {

  id: number;

  // The 'category' field in Template objects comes from a different backend DTO than the pure Category model,

  // and thus does NOT have a DocumentClassification field. Use the documentClassification field below.

  category: Category;

  subCategoryCode: string;

  abbyyTemplate: string;

  client: IPowerClient;

  documentClassification: DocumentClassification;

}

export interface ProcessFailedRecord {

  id: number;

  processId: number;

  recordIdentifier: string;

}

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

import {ProcessStatus} from "./process-status.interface";

export interface ProcessHistory {

  id: number;

  processStatus: ProcessStatus;

  processStatusUpdate: LookupData;

  processHistoryDescription: string;

  userId: string;

}

import { RightsCategory } from './rights-category.interface';

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

import { IPowerAssignment } from './index';

export interface Right {

  id: number;

  name: string;

  code: string;

  isGlobal: boolean;

  rightsCategory: RightsCategory;

  rolesList: Role[];

  ipowerAssignment: IPowerAssignment;

}

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;

}

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

export interface SchedulerCriteriaInterface {

  iPowerClientCode: string;

  status: string;

}

export interface SystemException {

  id: number;

  processId: number;

  clientId: string;

  jobName: string;

  dmsFileCode: string;

  message: string;

  cause: string;

  creationDatetime : Date;

  trace: string;

}

export interface RealTimeExecution {

    status: string;

    receivedFiles: number;

  }

export interface LookupData {

  id: number;

  name: string;

}

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

export interface DocumentSubclassification {

  subclassificationId: number;

  subclassificationName: string;

  documentClassification: DocumentClassification;

}

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

export interface Pageable {

  sort: Sort;

  offset: number;

  pageNumber: number;

  pageSize: number;

  unpaged: boolean;

  paged: boolean;

}

export interface Sort {

  unsorted: boolean;

  sorted: boolean;

  empty: boolean;

}

import {Pageable} from './pageable.interface';

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

export interface Page<T> {

  data: T[];

  totalPages: number;

  totalElements: number;

}

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;

}

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

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

export interface StatusPerDocument {

  statusPerDocRecId: number;

  batchId: number;

  documentStatusLastUpdate: Date;

  documentCurrentStatusId: LookupData;

  receivedFile: ReceivedFiles;

}

export interface Language {

  code: string;

  name: string;

}

import { Right } from './right.interface';

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

export interface RightsByClient {

  client: IPowerClient;

  rights: Right[];

}

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

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

export interface AlteryxException {

  id: number;

  record: Record[];

  alteryxExceptionStatus: LookupData;

  alteryxRoutineId: number;

  alteryxExceptionDescription: string;

}

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;

}

export interface IPowerAssignment {

  id: number;

  name: string;

  description: string;

  status: string;

}

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

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

import { DocumentSubclassification } from './document-subclassification.interface';

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

import { StatusPerDocument } from './status-per-document.interface';

export interface ReceivedFile extends ReceivedFiles {

  //This data comes from IMANAGER  (Valasides)

  downloadingProcedureId: number;

  dmsWorkspacePath: string;

  iPowerClientCode: number;

  iPowerClientName: string;

  statusPerDocument: StatusPerDocument;

  //This data comes from Adones

  abbyClassification: DocumentClassification;

  abbySubClassification: DocumentSubclassification;

}

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 ProcessStatus {

  id: number;

  name: string;

}

export interface InvoiceProcessesRouterParams {

  clientCode: string;

  docClassification: number;

}

export interface SentStringInterface {

  value: string;

}

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

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

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

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

import {Observable} from 'rxjs';

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

@Injectable({

  providedIn: 'root'

})

export class ReceivedFilesService extends GenericRestService<ReceivedFile> {

  constructor(private http: HttpClient) {

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

  }

  public getLatestFilesByIpowerClientId(iPowerClientCode:string): Observable<ReceivedFile[]> {

    return this.http.get<ReceivedFile[]>(this.baseUrl + '/latestFilesPerClient/'+ iPowerClientCode);

  }

}

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

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

import {Observable} from 'rxjs';

import {Page} from '../models/paging/page.interface';

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

@Injectable({

  providedIn: 'root'

})

export class GenericRestService<T> {

  // tslint:disable-next-line:variable-name

  private _baseUrl: string;

  public get baseUrl(): string {

    return this._baseUrl;

  }

  constructor(url: string, private httpService: HttpClient) {

    // TODO when we unify the backend will be like that but for now

    // if (url.endsWith('/')) {

    //   throw Error('Malformed url: ' + url + '\nEnds with slash');

    // }

    // if (url.startsWith('/')) {

    //   throw Error('Malformed url: ' + url + '\nStarts with slash');

    // }

    // this._baseUrl = environment.ApiUrl + '/' + url;

    // will be like this

    if (url.endsWith('/')) {

        throw Error('Malformed url: ' + url + '\nEnds with slash');

      }

    if (url.startsWith('/')) {

      throw Error('Malformed url: ' + url + '\nStarts with slash');

    }

    this._baseUrl = url;

    // this remains unchanged

    this._baseUrl = url;

  }

  public getAll(): Observable<T[]> {

    return this.httpService.get<T[]>(this.baseUrl + '/all');

  }

  public getAllPaged(page: number, offset: number): Observable<Page<T>> {

    if (!environment.production && offset !== 10) {

      console.log('DEV MESSAGE: The deal is 10 results per page. Your offset became 10.I only show up in non-prod environment :)');

    }

    return this.httpService.get<Page<T>>(this.baseUrl + '/all', {

      params: {

        page: page.toString(),

        offset: '10'

      }

    });

  }

  public getById(id: string | number): Observable<T> {

    return this.httpService.get<T>(this.baseUrl + '/' + id.toString());

  }

  public update(data: T): Observable<T> {

    return this.httpService.put<T>(this.baseUrl, data);

  }

  public create(data: T): Observable<T> {

    return this.httpService.post<T>(this.baseUrl, data);

  }

  public delete(id: string | number): Observable<T> {

    return this.httpService.delete<T>(this.baseUrl + '/' + id.toString());

  }

  public deleteById(data: T): Observable<T> {

    return this.httpService.delete<T>(this.baseUrl, data);

  }

  public searchByCriteriaPaged(page: number, offset: number, criteria: any, urlExtension: string): Observable<Page<T>> {

    // TODO make this better

    if (!environment.production && offset !== 10) {

      console.log('DEV MESSAGE: The deal is 10 results per page. Your offset became 10.I only show up in non-prod environment :)');

    }

    if (urlExtension) {

      if (urlExtension.endsWith('/')) {

        throw Error('Malformed url: ' + urlExtension + '\nEnds with slash');

      }

      if (urlExtension.startsWith('/')) {

        throw Error('Malformed url: ' + urlExtension + '\nStarts with slash');

      }

      urlExtension = '/' + urlExtension;

    } else {

      urlExtension = '';

    }

    return this.httpService.post<Page<T>>(this.baseUrl + urlExtension, criteria, {

      params: {

        page: page.toString(),

        offset: '10'

      }

    });

  }

}

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

import { ErrorHandlingService } from './error-handling.service';

describe('ErrorHandlingService', () => {

  let service: ErrorHandlingService;

  beforeEach(() => {

    TestBed.configureTestingModule({});

    service = TestBed.inject(ErrorHandlingService);

  });

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

    expect(service).toBeTruthy();

  });

});

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

import { RTAErrorMessage } from './../../enums/rta-error-message';

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

import { MessageService } from 'primeng/api';

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

@Injectable({

  providedIn: 'root',

})

export class ErrorHandlingService {

  constructor(private messageService: MessageService, private translate: TranslateService) { }

  showHttpResponseError(error: HttpErrorResponse): void {

    this.messageService.add({

      severity: 'error',

      summary: this.translate.instant('RTA_ERRORS.TITLE_ERROR'),

      detail: this.httpErrorResponseToMessage(error)

    });

  }

  showErrorMessage(message: string): void {

    this.messageService.add({

      severity: 'error',

      summary: this.translate.instant('RTA_ERRORS.TITLE_ERROR'),

      detail: message

    });

  }

  clearErrors(): void {

    this.messageService.clear();

  }

  private httpErrorResponseToMessage(error: HttpErrorResponse): string {

    if (error && error.status === 0) {

      return this.translate.instant(`RTA_ERRORS.${RTAErrorMessage.TIMEOUT.toString()}`);

    }

    const errMsg = this.translate.instant(`RTA_ERRORS.${error.message}`);

    return errMsg ?? this.translate.instant('RTA_ERRORS.UNKNOWN_ERROR');

  }

}

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

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

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

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

import {InboxBatch} from '../models/inbox-batch.interface';

@Injectable({

  providedIn: 'root'

})

export class InboxManagementService extends GenericRestService<InboxBatch> {

  constructor(private http: HttpClient) {

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

  }

  downloadFile(url: string): any {

    return this.http.get(url, {responseType: 'blob'});

  }

  ignoreFile(id: string): any {

    return this.http.post(`${this.baseUrl}/ignore/${id}`, '');

  }

  forward(id: string): any {

    return this.http.post(`${this.baseUrl}/forward/${id}`, '');

  }

  reclassify(doc: InboxBatch): any {

    return this.http.put(`${this.baseUrl}/reclassify`, doc);

  }

}

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

import { InvoiceProcessesService } from './invoice-processes.service';

describe('InvoiceProcessesService', () => {

  let service: InvoiceProcessesService;

  beforeEach(() => {

    TestBed.configureTestingModule({});

    service = TestBed.inject(InvoiceProcessesService);

  });

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

    expect(service).toBeTruthy();

  });

});

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

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

describe('AuthService', () => {

  let service: AuthService;

  beforeEach(() => {

    TestBed.configureTestingModule({});

    service = TestBed.inject(AuthService);

  });

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

    expect(service).toBeTruthy();

  });

});

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

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

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

import {Observable} from "rxjs";

@Injectable({

  providedIn: 'root'

})

export class JournalDialogEditService {

  constructor(private http: HttpClient) {

  }

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

    return this.http.get<string>(

      `${environment.baseApiUrl}${environment.apiUrl.documentsProcessesWs}/journalEntries/edit/` + journalEntryId.toString());

  }

}

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(