@qbs-origin/origin-form 0.5.0

package/esm2022/lib/services/open-banking.service.mjs

@@ -0,0 +1,194 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { of } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../others/config-service";
+// Status code mapping for API responses
+const STATUS_CODE_MAP = {
+    0: 'received',
+    1: 'valid',
+    2: 'rejected',
+    3: 'expired',
+    4: 'terminated',
+    5: 'revokedByPsu'
+};
+// Bank-specific transaction period limits (in days)
+const BANK_TRANSACTION_LIMITS = {
+    'BCR': 90,
+    'BTRL': 120, // BT - Banca Transilvania
+    'BT': 90,
+    'BRD': 730, // 2 years
+    'RZBA': -1, // RZB - unlimited
+    'PRVA': 180, // Patria Bank
+    'CEC': 180,
+    'INGB': 90,
+    'ING': 90
+};
+export class OpenBankingService {
+    constructor(http, configService) {
+        this.http = http;
+        this.configService = configService;
+        this.apiUrl = '';
+        // Get API URL from app config
+        const config = this.configService.readConfig();
+        this.apiUrl = config.baseUrlSmartAccounts;
+    }
+    /**
+     * Fix data URL format for logos
+     * Converts "data:image/svg;base64," to "data:image/svg+xml;base64,"
+     */
+    fixDataUrlFormat(logoUrl) {
+        if (!logoUrl)
+            return undefined;
+        // If it's already a proper data URL, return as is
+        if (logoUrl.startsWith('data:image/')) {
+            // Fix common format issues
+            return logoUrl
+                .replace('data:image/svg;base64,', 'data:image/svg+xml;base64,')
+                .replace('data:image/png;base64,', 'data:image/png;base64,')
+                .replace('data:image/jpeg;base64,', 'data:image/jpeg;base64,')
+                .replace('data:image/jpg;base64,', 'data:image/jpeg;base64,');
+        }
+        return logoUrl;
+    }
+    /**
+     * Get list of supported banks
+     * @param countryCode Optional country code filter
+     */
+    getBanks(countryCode) {
+        let params = new HttpParams();
+        if (countryCode) {
+            params = params.set('countryCode', countryCode);
+        }
+        return this.http.get(`${this.apiUrl}/banks`, { params }).pipe(map(banks => {
+            return banks.map(bank => ({
+                ...bank,
+                // Fix data URL format if needed
+                logoUrl: this.fixDataUrlFormat(bank.logoUrl)
+            }));
+        }), catchError((error) => {
+            console.error('Error fetching banks:', error);
+            return of([]);
+        }));
+    }
+    /**
+     * Initialize consent flow
+     */
+    initializeConsent(request) {
+        return this.http.post(`${this.apiUrl}/consents/initialize`, request).pipe(catchError((error) => {
+            console.error('Error initializing consent:', error);
+            return of();
+        }));
+    }
+    /**
+     * Get consent status
+     */
+    getConsentStatus(bankCode, consentId) {
+        return this.http.get(`${this.apiUrl}/consents/${bankCode}/${consentId}`).pipe(map(response => {
+            // Map numeric status to string if needed
+            if (typeof response.status === 'number') {
+                return {
+                    ...response,
+                    status: STATUS_CODE_MAP[response.status] || 'received'
+                };
+            }
+            return response;
+        }), catchError((error) => {
+            console.error('Error checking consent status:', error);
+            return of();
+        }));
+    }
+    /**
+     * Process consent callback
+     */
+    processConsentCallback(params) {
+        const queryParams = new HttpParams()
+            .set('message', params.message)
+            .set('type', params.type)
+            .set('internalConsentId', params.internalConsentId)
+            .set('code', params.code || '')
+            .set('state', params.state || '');
+        return this.http.get(`${this.apiUrl}/consents/callback`, { params: queryParams }).pipe(catchError((error) => {
+            console.error('Error processing consent callback:', error);
+            return of({
+                message: 'Consent processed (mock)',
+                internalConsentId: params.internalConsentId,
+                status: 'approved'
+            });
+        }));
+    }
+    /**
+     * Get accounts for a consent
+     */
+    getAccounts(consentId, bankCode) {
+        const params = new HttpParams()
+            .set('consentId', consentId)
+            .set('bankCode', bankCode);
+        return this.http.get(`${this.apiUrl}/accounts`, { params }).pipe(map(accounts => {
+            return accounts.map(account => ({
+                ...account,
+            }));
+        }), catchError((error) => {
+            console.error('Error fetching accounts:', error);
+            return of();
+        }));
+    }
+    /**
+     * Get maximum transaction period for a bank
+     * @param bankCode The bank code
+     * @returns Maximum number of days or -1 for unlimited
+     */
+    getMaxTransactionPeriod(bankCode) {
+        const upperBankCode = bankCode.toUpperCase();
+        // Check if we have a specific limit for this bank
+        if (BANK_TRANSACTION_LIMITS.hasOwnProperty(upperBankCode)) {
+            return BANK_TRANSACTION_LIMITS[upperBankCode];
+        }
+        // Default to 90 days if bank not specified
+        return 90;
+    }
+    /**
+     * Get transactions for an account
+     */
+    getTransactions(request) {
+        let params = new HttpParams()
+            .set('consentId', request.consentId)
+            .set('bankCode', request.bankCode)
+            .set('accountId', request.accountId);
+        if (request.fromDate) {
+            params = params.set('fromDate', request.fromDate);
+        }
+        if (request.toDate) {
+            params = params.set('toDate', request.toDate);
+        }
+        if (request.page) {
+            params = params.set('page', request.page.toString());
+        }
+        if (request.pageSize) {
+            params = params.set('pageSize', request.pageSize.toString());
+        }
+        return this.http.get(`${this.apiUrl}/transactions`, { params }).pipe(map(page => {
+            return {
+                ...page,
+                pageNumber: page.page,
+                items: page.items.map(txn => ({
+                    ...txn
+                }))
+            };
+        }), catchError((error) => {
+            console.error('Error fetching transactions:', error);
+            return of();
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OpenBankingService, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OpenBankingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OpenBankingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"open-banking.service.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/services/open-banking.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { Observable, of } from 'rxjs';\nimport { map, catchError } from 'rxjs/operators';\nimport { ConfigService } from '../others/config-service';\n\n// Bank interfaces\nexport interface Bank {\n  id: string;\n  bankCode: string;\n  displayName: string;\n  logoUrl?: string;\n  countryCode: string;\n  requiresRedirect: boolean;\n  supportedFeatures: string;\n  isActive: boolean;\n}\n\n// Consent interfaces\nexport interface ConsentInitRequest {\n  bankCode: string;\n  psuEmail: string;\n  psuIntermediaryId: string;\n  periodOfValidity?: number; // Days, default 90\n  tcAccepted: boolean;\n}\n\nexport interface ConsentInitResponse {\n  authorizationUrl: string;\n  consentId: string;\n}\n\nexport interface ConsentStatus {\n  consentId: string;\n  status: 'received' | 'valid' | 'rejected' | 'expired' | 'terminated' | 'revokedByPsu';\n  expiresAt?: string;\n}\n\n// Status code mapping for API responses\nconst STATUS_CODE_MAP: { [key: number]: ConsentStatus['status'] } = {\n  0: 'received',\n  1: 'valid',\n  2: 'rejected',\n  3: 'expired',\n  4: 'terminated',\n  5: 'revokedByPsu'\n};\n\n// Bank-specific transaction period limits (in days)\nconst BANK_TRANSACTION_LIMITS: { [key: string]: number } = {\n  'BCR': 90,\n  'BTRL': 120,  // BT - Banca Transilvania\n  'BT': 90,\n  'BRD': 730,  // 2 years\n  'RZBA': -1,  // RZB - unlimited\n  'PRVA': 180,  // Patria Bank\n  'CEC': 180,\n  'INGB': 90,\n  'ING': 90\n};\n\nexport interface ConsentCallbackParams {\n  message: string;\n  type: string;\n  internalConsentId: string;\n  code?: string;\n  state?: string;\n}\n\nexport interface ConsentCallbackResponse {\n  message: string;\n  internalConsentId: string;\n  status: 'approved' | 'rejected';\n}\n\n// Account interfaces\nexport interface Account {\n  id: string;\n  accountId: string;\n  iban: string;\n  currency: string;\n  name: string;\n  accountHolderName: string;\n  accountHolderConfidence: string;\n  balance: number;\n  lastSyncedAt: string;\n}\n\n// Transaction interfaces\nexport interface Transaction {\n  transactionId: string;\n  accountId: string;\n  amount: number;\n  currency: string;\n  bookingDate: string;\n  valueDate?: string;\n  creditorName?: string;\n  creditorIBAN?: string;\n  debtorName?: string;\n  debtorIBAN?: string;\n  remittanceInformation?: string;\n  status: 'Booked' | 'Pending';\n  type: 'Debit' | 'Credit';\n  // Additional fields for compatibility\n  description?: string;\n  transactionDate?: string;\n  category?: string;\n  merchantName?: string;\n  reference?: string;\n}\n\nexport interface TransactionPage {\n  items: Transaction[];\n  page: number;\n  pageNumber?: number; // Alias for page\n  pageSize: number;\n  totalCount: number;\n  totalPages: number;\n  hasNextPage: boolean;\n  hasPreviousPage: boolean;\n  nextPageLink?: string;\n}\n\nexport interface TransactionRequest {\n  consentId: string;\n  bankCode: string;\n  accountId: string;\n  fromDate?: string;\n  toDate?: string;\n  page?: number;\n  pageSize?: number;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class OpenBankingService {\n  private apiUrl: string = '';\n\n  constructor(\n    private http: HttpClient,\n    private configService: ConfigService\n  ) {\n    // Get API URL from app config\n    const config = this.configService.readConfig();\n    this.apiUrl = config.baseUrlSmartAccounts;\n  }\n\n  /**\n   * Fix data URL format for logos\n   * Converts \"data:image/svg;base64,\" to \"data:image/svg+xml;base64,\"\n   */\n  private fixDataUrlFormat(logoUrl?: string): string | undefined {\n    if (!logoUrl) return undefined;\n\n    // If it's already a proper data URL, return as is\n    if (logoUrl.startsWith('data:image/')) {\n      // Fix common format issues\n      return logoUrl\n        .replace('data:image/svg;base64,', 'data:image/svg+xml;base64,')\n        .replace('data:image/png;base64,', 'data:image/png;base64,')\n        .replace('data:image/jpeg;base64,', 'data:image/jpeg;base64,')\n        .replace('data:image/jpg;base64,', 'data:image/jpeg;base64,');\n    }\n\n    return logoUrl;\n  }\n\n  /**\n   * Get list of supported banks\n   * @param countryCode Optional country code filter\n   */\n  getBanks(countryCode?: string): Observable<Bank[]> {\n    let params = new HttpParams();\n    if (countryCode) {\n      params = params.set('countryCode', countryCode);\n    }\n\n    return this.http.get<Bank[]>(`${this.apiUrl}/banks`, { params }).pipe(\n      map(banks => {\n        return banks.map(bank => ({\n          ...bank,\n          // Fix data URL format if needed\n          logoUrl: this.fixDataUrlFormat(bank.logoUrl)\n        }));\n      }),\n      catchError((error) => {\n        console.error('Error fetching banks:', error);\n        return of([]);\n      })\n    );\n  }\n\n  /**\n   * Initialize consent flow\n   */\n  initializeConsent(request: ConsentInitRequest): Observable<ConsentInitResponse> {\n    return this.http.post<ConsentInitResponse>(`${this.apiUrl}/consents/initialize`, request).pipe(\n      catchError((error) => {\n        console.error('Error initializing consent:', error);\n        return of();\n      })\n    );\n  }\n\n  /**\n   * Get consent status\n   */\n  getConsentStatus(bankCode: string, consentId: string): Observable<ConsentStatus> {\n    return this.http.get<any>(`${this.apiUrl}/consents/${bankCode}/${consentId}`).pipe(\n      map(response => {\n        // Map numeric status to string if needed\n        if (typeof response.status === 'number') {\n          return {\n            ...response,\n            status: STATUS_CODE_MAP[response.status] || 'received'\n          };\n        }\n        return response;\n      }),\n      catchError((error) => {\n        console.error('Error checking consent status:', error);\n        return of();\n      })\n    );\n  }\n\n  /**\n   * Process consent callback\n   */\n  processConsentCallback(params: ConsentCallbackParams): Observable<ConsentCallbackResponse> {\n    const queryParams = new HttpParams()\n      .set('message', params.message)\n      .set('type', params.type)\n      .set('internalConsentId', params.internalConsentId)\n      .set('code', params.code || '')\n      .set('state', params.state || '');\n\n    return this.http.get<ConsentCallbackResponse>(`${this.apiUrl}/consents/callback`, { params: queryParams }).pipe(\n      catchError((error) => {\n        console.error('Error processing consent callback:', error);\n        return of({\n          message: 'Consent processed (mock)',\n          internalConsentId: params.internalConsentId,\n          status: 'approved' as const\n        });\n      })\n    );\n  }\n\n  /**\n   * Get accounts for a consent\n   */\n  getAccounts(consentId: string, bankCode: string): Observable<Account[]> {\n    const params = new HttpParams()\n      .set('consentId', consentId)\n      .set('bankCode', bankCode);\n\n    return this.http.get<Account[]>(`${this.apiUrl}/accounts`, { params }).pipe(\n      map(accounts => {\n        return accounts.map(account => ({\n          ...account,\n        }));\n      }),\n      catchError((error) => {\n        console.error('Error fetching accounts:', error);\n        return of();\n      })\n    );\n  }\n\n  /**\n   * Get maximum transaction period for a bank\n   * @param bankCode The bank code\n   * @returns Maximum number of days or -1 for unlimited\n   */\n  getMaxTransactionPeriod(bankCode: string): number {\n    const upperBankCode = bankCode.toUpperCase();\n    // Check if we have a specific limit for this bank\n    if (BANK_TRANSACTION_LIMITS.hasOwnProperty(upperBankCode)) {\n      return BANK_TRANSACTION_LIMITS[upperBankCode];\n    }\n    // Default to 90 days if bank not specified\n    return 90;\n  }\n\n  /**\n   * Get transactions for an account\n   */\n  getTransactions(request: TransactionRequest): Observable<TransactionPage> {\n    let params = new HttpParams()\n      .set('consentId', request.consentId)\n      .set('bankCode', request.bankCode)\n      .set('accountId', request.accountId);\n\n    if (request.fromDate) {\n      params = params.set('fromDate', request.fromDate);\n    }\n    if (request.toDate) {\n      params = params.set('toDate', request.toDate);\n    }\n    if (request.page) {\n      params = params.set('page', request.page.toString());\n    }\n    if (request.pageSize) {\n      params = params.set('pageSize', request.pageSize.toString());\n    }\n\n    return this.http.get<TransactionPage>(`${this.apiUrl}/transactions`, { params }).pipe(\n      map(page => {\n        return {\n          ...page,\n          pageNumber: page.page,\n          items: page.items.map(txn => ({\n            ...txn\n          }))\n        };\n      }),\n      catchError((error) => {\n        console.error('Error fetching transactions:', error);\n        return of();\n      })\n    );\n  }\n}"]}

package/esm2022/lib/services/origin-form-signalr-handler.service.mjs

@@ -0,0 +1,107 @@
+import { Injectable, inject } from '@angular/core';
+import { Subject, Subscription, BehaviorSubject, firstValueFrom, interval, } from 'rxjs';
+import { ApplicationDataService } from './applicationData.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./origin-form-signalr.service";
+export class OriginFormSignalrHandlerService {
+    constructor(originFormSignalrService) {
+        this.originFormSignalrService = originFormSignalrService;
+        this.subscriptions = new Subscription();
+        this.applicationDataService = inject(ApplicationDataService);
+        this.currentAppDataUuid = null;
+        this._isLoading = new BehaviorSubject(false);
+        this.isLoading$ = this._isLoading.asObservable();
+        this._operationCompleted = new Subject();
+        this.operationCompleted$ = this._operationCompleted.asObservable();
+        this.originFormSignalrService
+            .initiateSignalrConnection()
+            .then(() => this.subscribeToCoreEvents())
+            .catch((error) => console.error('CollectorFormSignalrHandlerService: Error initiating base SignalR connection', error));
+    }
+    subscribeToCoreEvents() {
+        const kycSub = this.originFormSignalrService.kycProcessingComplete.subscribe((appDataId) => {
+            if (appDataId === this.currentAppDataUuid) {
+                this.setKycOperationCompleted();
+            }
+            else {
+                console.warn(`Received KycProcessingComplete event for unexpected appDataId: ${appDataId}. Expected: ${this.currentAppDataUuid}`);
+            }
+        });
+        this.subscriptions.add(kycSub);
+    }
+    async setKycOperationCompleted() {
+        if (this.currentAppDataUuid) {
+            let appData = null;
+            try {
+                appData = await this.applicationDataService.getSteps(this.currentAppDataUuid);
+            }
+            catch (error) {
+                console.error('Error fetching steps after KYC completion:', error);
+            }
+            this._isLoading.next(false);
+            this._operationCompleted.next({
+                operationIdentifier: 'KYC_PROCESSING',
+                success: true,
+                data: appData,
+            });
+            this.currentAppDataUuid = null;
+        }
+        if (this.poolingInterval) {
+            this.poolingInterval.unsubscribe();
+        }
+    }
+    async startBackupPooling() {
+        let isBusy = false;
+        this.poolingInterval = interval(5000)
+            .subscribe(() => {
+            if (this.currentAppDataUuid && !isBusy) {
+                isBusy = true;
+                this.applicationDataService.getProcessStatus(this.currentAppDataUuid).subscribe(status => {
+                    isBusy = false;
+                    if (status === 2) {
+                        this.setKycOperationCompleted();
+                    }
+                });
+            }
+        });
+    }
+    async initiateKycProcessing(appDataUuid) {
+        if (this._isLoading.value) {
+            console.warn('Another operation is already in progress.');
+            return;
+        }
+        this._isLoading.next(true);
+        this.currentAppDataUuid = appDataUuid;
+        try {
+            await firstValueFrom(this.applicationDataService.makeProcessApiCall(appDataUuid));
+            this.startBackupPooling(); //fire and forget
+        }
+        catch (error) {
+            console.error('Error initiating KYC processing (API call failed):', error);
+            this._isLoading.next(false);
+            this._operationCompleted.next({
+                operationIdentifier: 'KYC_PROCESSING',
+                success: false,
+                error,
+            });
+            this.currentAppDataUuid = null;
+        }
+    }
+    ngOnDestroy() {
+        if (this.subscriptions) {
+            this.subscriptions.unsubscribe();
+        }
+        if (this.poolingInterval) {
+            this.poolingInterval.unsubscribe();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OriginFormSignalrHandlerService, deps: [{ token: i1.OriginFormSignalrService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OriginFormSignalrHandlerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OriginFormSignalrHandlerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.OriginFormSignalrService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"origin-form-signalr-handler.service.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/services/origin-form-signalr-handler.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy, inject } from '@angular/core';\nimport {\n  Observable,\n  Subject,\n  Subscription,\n  BehaviorSubject,\n  firstValueFrom,\n  interval,\n  startWith,\n  takeWhile,\n} from 'rxjs';\nimport { OriginFormSignalrService } from './origin-form-signalr.service';\nimport { ApplicationDataService } from './applicationData.service';\n\nexport interface OperationResult {\n  operationIdentifier: string;\n  success: boolean;\n  data?: any;\n  error?: any;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class OriginFormSignalrHandlerService implements OnDestroy {\n  private subscriptions: Subscription = new Subscription();\n  private applicationDataService = inject(ApplicationDataService);\n  private currentAppDataUuid: string | null = null;\n\n  private _isLoading = new BehaviorSubject<boolean>(false);\n  public readonly isLoading$: Observable<boolean> = this._isLoading.asObservable();\n\n  private _operationCompleted = new Subject<OperationResult>();\n  public readonly operationCompleted$: Observable<OperationResult> =\n    this._operationCompleted.asObservable();\n\n  constructor(private originFormSignalrService: OriginFormSignalrService) {\n    this.originFormSignalrService\n      .initiateSignalrConnection()\n      .then(() => this.subscribeToCoreEvents())\n      .catch((error) =>\n        console.error(\n          'CollectorFormSignalrHandlerService: Error initiating base SignalR connection',\n          error\n        )\n      );\n  }\n\n  private subscribeToCoreEvents(): void {\n    const kycSub =\n      this.originFormSignalrService.kycProcessingComplete.subscribe(\n        (appDataId: string) => {\n          if (appDataId === this.currentAppDataUuid) {\n            this.setKycOperationCompleted();\n          } else {\n            console.warn(\n              `Received KycProcessingComplete event for unexpected appDataId: ${appDataId}. Expected: ${this.currentAppDataUuid}`\n            );\n          }\n        }\n      );\n    this.subscriptions.add(kycSub);\n  }\n\n  private async setKycOperationCompleted() {\n    if (this.currentAppDataUuid) {\n      let appData = null;\n\n      try {\n        appData = await this.applicationDataService.getSteps(this.currentAppDataUuid);\n      } catch (error) {\n        console.error('Error fetching steps after KYC completion:', error);\n      }\n\n      this._isLoading.next(false);\n\n      this._operationCompleted.next({\n        operationIdentifier: 'KYC_PROCESSING',\n        success: true,\n        data: appData,\n      });\n      this.currentAppDataUuid = null;\n    }\n    if (this.poolingInterval) {\n      this.poolingInterval.unsubscribe();\n    }\n  }\n\n  private poolingInterval: Subscription;\n\n  private async startBackupPooling() {\n    let isBusy = false;\n    this.poolingInterval = interval(5000)\n      .subscribe(() => {\n        if (this.currentAppDataUuid && !isBusy) {\n          isBusy = true;\n          this.applicationDataService.getProcessStatus(this.currentAppDataUuid).subscribe(status => {\n            isBusy = false;\n            if (status === 2) {\n              this.setKycOperationCompleted();\n            }\n          });\n        }\n      });\n  }\n\n  public async initiateKycProcessing(appDataUuid: string): Promise<void> {\n    if (this._isLoading.value) {\n      console.warn('Another operation is already in progress.');\n      return;\n    }\n    this._isLoading.next(true);\n    this.currentAppDataUuid = appDataUuid;\n    try {\n      await firstValueFrom(\n        this.applicationDataService.makeProcessApiCall(appDataUuid)\n      );\n      this.startBackupPooling();//fire and forget\n    } catch (error) {\n      console.error(\n        'Error initiating KYC processing (API call failed):',\n        error\n      );\n      this._isLoading.next(false);\n      this._operationCompleted.next({\n        operationIdentifier: 'KYC_PROCESSING',\n        success: false,\n        error,\n      });\n      this.currentAppDataUuid = null;\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.subscriptions) {\n      this.subscriptions.unsubscribe();\n    }\n    if (this.poolingInterval) {\n      this.poolingInterval.unsubscribe();\n    }\n  }\n}\n"]}

package/esm2022/lib/services/origin-form-signalr.service.mjs

@@ -0,0 +1,105 @@
+import { Injectable, inject } from '@angular/core';
+import * as signalR from '@microsoft/signalr';
+import { Subject } from 'rxjs';
+import { ConfigService } from '../others/config-service';
+import * as i0 from "@angular/core";
+export class OriginFormSignalrService {
+    constructor() {
+        this.connection = null;
+        this.connectionPromise = null;
+        // Generic subjects for different events
+        this.eventSubjects = new Map();
+        // Specific event for KYC completion as an example
+        this.kycProcessingComplete = new Subject();
+        this.configService = inject(ConfigService);
+        this.hubUrl =
+            this.configService.readConfig().baseUrlBusiness + '/collectorhub';
+        this.registerSpecificEvents();
+    }
+    registerSpecificEvents() {
+        this.eventSubjects.set('KycProcessingComplete', this.kycProcessingComplete);
+    }
+    async initiateSignalrConnection() {
+        if (this.connection &&
+            this.connection.state === signalR.HubConnectionState.Connected) {
+            console.log('SignalR connection already established.');
+            return Promise.resolve();
+        }
+        if (this.connectionPromise) {
+            return this.connectionPromise;
+        }
+        this.connection = new signalR.HubConnectionBuilder()
+            .withUrl(this.hubUrl, {
+            skipNegotiation: true,
+            transport: signalR.HttpTransportType.WebSockets,
+        })
+            .withAutomaticReconnect()
+            .withHubProtocol(new signalR.JsonHubProtocol())
+            .build();
+        this.setSignalrClientMethods();
+        this.connectionPromise = this.connection
+            .start()
+            .then(() => {
+            if (this.connection) {
+                console.log(`Collector SignalR connection success! connectionId: ${this.connection.connectionId}`);
+            }
+            this.connectionPromise = null;
+        })
+            .catch((error) => {
+            console.error(`Collector SignalR connection error: ${error}`);
+            this.connectionPromise = null;
+            throw error;
+        });
+        return this.connectionPromise;
+    }
+    setSignalrClientMethods() {
+        if (!this.connection)
+            return;
+        // Generic handler: Iterate over pre-registered event subjects
+        this.eventSubjects.forEach((subject, eventName) => {
+            this.connection?.on(eventName, (data) => {
+                subject.next(data);
+            });
+        });
+        // Example for a specific event if not using the generic map for some reason
+        // this.connection.on('KycProcessingComplete', (data: any) => {
+        //   this.kycProcessingComplete.next(data);
+        // });
+    }
+    /**
+     * Allows dynamic registration of an event listener if the event name isn't known at design time
+     * or if a component wants to manage its own subject.
+     * @param eventName The name of the event from the server.
+     * @returns An RxJS Subject that will emit data when the event is received.
+     */
+    listenForEvent(eventName) {
+        if (!this.eventSubjects.has(eventName)) {
+            const newSubject = new Subject();
+            this.eventSubjects.set(eventName, newSubject);
+            // If connection is already live, register the handler immediately
+            if (this.connection &&
+                this.connection.state === signalR.HubConnectionState.Connected) {
+                this.connection.on(eventName, (data) => {
+                    newSubject.next(data);
+                });
+            }
+        }
+        return this.eventSubjects.get(eventName);
+    }
+    async stopConnection() {
+        if (this.connection &&
+            this.connection.state === signalR.HubConnectionState.Connected) {
+            await this.connection.stop();
+            console.log('Collector SignalR connection stopped.');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OriginFormSignalrService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OriginFormSignalrService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OriginFormSignalrService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"origin-form-signalr.service.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/services/origin-form-signalr.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;;AAKzD,MAAM,OAAO,wBAAwB;IAanC;QAZQ,eAAU,GAAiC,IAAI,CAAC;QAChD,sBAAiB,GAAyB,IAAI,CAAC;QAGvD,wCAAwC;QAChC,kBAAa,GAA8B,IAAI,GAAG,EAAE,CAAC;QAE7D,kDAAkD;QAC3C,0BAAqB,GAAiB,IAAI,OAAO,EAAO,CAAC;QAExD,kBAAa,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QAG5C,IAAI,CAAC,MAAM;YACT,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC,eAAe,GAAG,eAAe,CAAC;QACpE,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAEO,sBAAsB;QAC5B,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,uBAAuB,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC;IAC9E,CAAC;IAEM,KAAK,CAAC,yBAAyB;QACpC,IACE,IAAI,CAAC,UAAU;YACf,IAAI,CAAC,UAAU,CAAC,KAAK,KAAK,OAAO,CAAC,kBAAkB,CAAC,SAAS,EAC9D,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,yCAAyC,CAAC,CAAC;YACvD,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QAC3B,CAAC;QAED,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,iBAAiB,CAAC;QAChC,CAAC;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,OAAO,CAAC,oBAAoB,EAAE;aACjD,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE;YACpB,eAAe,EAAE,IAAI;YACrB,SAAS,EAAE,OAAO,CAAC,iBAAiB,CAAC,UAAU;SAChD,CAAC;aACD,sBAAsB,EAAE;aACxB,eAAe,CAAC,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;aAC9C,KAAK,EAAE,CAAC;QAEX,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAE/B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,UAAU;aACrC,KAAK,EAAE;aACP,IAAI,CAAC,GAAG,EAAE;YACT,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACpB,OAAO,CAAC,GAAG,CACT,uDAAuD,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CACtF,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAChC,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,KAAU,EAAE,EAAE;YACpB,OAAO,CAAC,KAAK,CAAC,uCAAuC,KAAK,EAAE,CAAC,CAAC;YAC9D,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;YAC9B,MAAM,KAAK,CAAC;QACd,CAAC,CAAC,CAAC;QAEL,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAEO,uBAAuB;QAC7B,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,OAAO;QAE7B,8DAA8D;QAC9D,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,SAAS,EAAE,EAAE;YAChD,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,SAAS,EAAE,CAAC,IAAS,EAAE,EAAE;gBAC3C,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACrB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,4EAA4E;QAC5E,+DAA+D;QAC/D,2CAA2C;QAC3C,MAAM;IACR,CAAC;IAED;;;;;OAKG;IACI,cAAc,CAAI,SAAiB;QACxC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YACvC,MAAM,UAAU,GAAG,IAAI,OAAO,EAAK,CAAC;YACpC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;YAC9C,kEAAkE;YAClE,IACE,IAAI,CAAC,UAAU;gBACf,IAAI,CAAC,UAAU,CAAC,KAAK,KAAK,OAAO,CAAC,kBAAkB,CAAC,SAAS,EAC9D,CAAC;gBACD,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,IAAO,EAAE,EAAE;oBACxC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACxB,CAAC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,CAAe,CAAC;IACzD,CAAC;IAEM,KAAK,CAAC,cAAc;QACzB,IACE,IAAI,CAAC,UAAU;YACf,IAAI,CAAC,UAAU,CAAC,KAAK,KAAK,OAAO,CAAC,kBAAkB,CAAC,SAAS,EAC9D,CAAC;YACD,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YAC7B,OAAO,CAAC,GAAG,CAAC,uCAAuC,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;+GAjHU,wBAAwB;mHAAxB,wBAAwB,cAFvB,MAAM;;4FAEP,wBAAwB;kBAHpC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport * as signalR from '@microsoft/signalr';\nimport { Subject } from 'rxjs';\nimport { ConfigService } from '../others/config-service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class OriginFormSignalrService {\n  private connection: signalR.HubConnection | null = null;\n  private connectionPromise: Promise<void> | null = null;\n  private hubUrl: string;\n\n  // Generic subjects for different events\n  private eventSubjects: Map<string, Subject<any>> = new Map();\n\n  // Specific event for KYC completion as an example\n  public kycProcessingComplete: Subject<any> = new Subject<any>();\n\n  private configService = inject(ConfigService);\n\n  constructor() {\n    this.hubUrl =\n      this.configService.readConfig().baseUrlBusiness + '/collectorhub';\n    this.registerSpecificEvents();\n  }\n\n  private registerSpecificEvents() {\n    this.eventSubjects.set('KycProcessingComplete', this.kycProcessingComplete);\n  }\n\n  public async initiateSignalrConnection(): Promise<void> {\n    if (\n      this.connection &&\n      this.connection.state === signalR.HubConnectionState.Connected\n    ) {\n      console.log('SignalR connection already established.');\n      return Promise.resolve();\n    }\n\n    if (this.connectionPromise) {\n      return this.connectionPromise;\n    }\n\n    this.connection = new signalR.HubConnectionBuilder()\n      .withUrl(this.hubUrl, {\n        skipNegotiation: true,\n        transport: signalR.HttpTransportType.WebSockets,\n      })\n      .withAutomaticReconnect()\n      .withHubProtocol(new signalR.JsonHubProtocol())\n      .build();\n\n    this.setSignalrClientMethods();\n\n    this.connectionPromise = this.connection\n      .start()\n      .then(() => {\n        if (this.connection) {\n          console.log(\n            `Collector SignalR connection success! connectionId: ${this.connection.connectionId}`\n          );\n        }\n        this.connectionPromise = null;\n      })\n      .catch((error: any) => {\n        console.error(`Collector SignalR connection error: ${error}`);\n        this.connectionPromise = null;\n        throw error;\n      });\n\n    return this.connectionPromise;\n  }\n\n  private setSignalrClientMethods(): void {\n    if (!this.connection) return;\n\n    // Generic handler: Iterate over pre-registered event subjects\n    this.eventSubjects.forEach((subject, eventName) => {\n      this.connection?.on(eventName, (data: any) => {\n        subject.next(data);\n      });\n    });\n\n    // Example for a specific event if not using the generic map for some reason\n    // this.connection.on('KycProcessingComplete', (data: any) => {\n    //   this.kycProcessingComplete.next(data);\n    // });\n  }\n\n  /**\n   * Allows dynamic registration of an event listener if the event name isn't known at design time\n   * or if a component wants to manage its own subject.\n   * @param eventName The name of the event from the server.\n   * @returns An RxJS Subject that will emit data when the event is received.\n   */\n  public listenForEvent<T>(eventName: string): Subject<T> {\n    if (!this.eventSubjects.has(eventName)) {\n      const newSubject = new Subject<T>();\n      this.eventSubjects.set(eventName, newSubject);\n      // If connection is already live, register the handler immediately\n      if (\n        this.connection &&\n        this.connection.state === signalR.HubConnectionState.Connected\n      ) {\n        this.connection.on(eventName, (data: T) => {\n          newSubject.next(data);\n        });\n      }\n    }\n    return this.eventSubjects.get(eventName) as Subject<T>;\n  }\n\n  public async stopConnection(): Promise<void> {\n    if (\n      this.connection &&\n      this.connection.state === signalR.HubConnectionState.Connected\n    ) {\n      await this.connection.stop();\n      console.log('Collector SignalR connection stopped.');\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,28 @@
+import { Injectable, inject } from '@angular/core';
+import { catchError, map, of } from 'rxjs';
+import { ConfigService } from '../others/config-service';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth-http.service";
+export class OtpService {
+    constructor(http) {
+        this.http = http;
+        this.configService = inject(ConfigService);
+    }
+    generate(params) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            `/otp/generate-app-otp`;
+        const data = { ...params, templateName: 'otpCode' };
+        return this.http.postExtended(url, data, { observe: 'response' }).pipe(map((response) => response), catchError((error) => of({ ...error, body: false })));
+    }
+    validate(data) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            `/otp/validate-app-otp`;
+        return this.http.postExtended(url, data, { observe: 'response' }).pipe(map((response) => response), catchError((error) => of({ ...error, body: false })));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OtpService, deps: [{ token: i1.AuthHttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OtpService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OtpService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.AuthHttpService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth-http.service";
+import * as i2 from "@angular/router";
+export class ProxyService {
+    constructor(http, route) {
+        this.http = http;
+        this.route = route;
+        this.apiURL = 'https://apiro.id-kyc.com';
+        this.env = '';
+        this.tokenUrl = '';
+        this.debug = false;
+        this.langIso = '';
+        this.token = '';
+        this.debug = this.env == 'QA' || this.env == 'DEMO';
+        this.tokenUrl =
+            this.apiURL +
+                (this.env == 'PROD'
+                    ? '/public/authorization/token'
+                    : '/dev_public/authorization/token');
+    }
+    getValuesForLog() {
+        return {
+            apiURL: this.apiURL,
+            orderID: this.orderID,
+            env: this.env,
+            tokenUrl: this.tokenUrl,
+            token: this.token,
+        };
+    }
+    getToken() {
+        return new Promise((resolve, reject) => {
+            var tokenUrlFull = this.tokenUrl + 'new?flow=origin';
+            if (this.debug)
+                console.log('GetToken called at' + tokenUrlFull);
+            this.http.get(tokenUrlFull).subscribe({
+                next: (resp) => {
+                    this.token = resp.token;
+                    sessionStorage.setItem('token-kyc', this.token);
+                    if (this.debug)
+                        console.log('GetToken responded: ' + JSON.stringify(this.getValuesForLog()));
+                    resolve({ success: true, error: '' });
+                },
+                error: (error) => {
+                    console.log('GetToken responded: ' + JSON.stringify(error));
+                    resolve({ success: false, error: error });
+                },
+                complete: () => {
+                    console.log('GetToken complete');
+                    resolve({ success: true, error: '' });
+                },
+            });
+        });
+    }
+    async getTokenAndSave() {
+        try {
+            const tokenResp = (await this.getToken());
+            if (tokenResp.success) {
+                return this.token;
+            }
+            else {
+                throw new Error('Token retrieval failed');
+            }
+        }
+        catch (error) {
+            console.error('Error retrieving token:', error);
+            throw error;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProxyService, deps: [{ token: i1.AuthHttpService }, { token: i2.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProxyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProxyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthHttpService }, { type: i2.ActivatedRoute }] });
+//# sourceMappingURL=data:application/json;base64,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