@hmcts/ccpay-web-component 5.0.10-beta07 → 5.0.10-beta09

package/esm5/lib/services/payment-view/payment-view.service.js

@@ -0,0 +1,416 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { PaymentLibService } from '../../payment-lib.service';
+import { WebComponentHttpClient } from '../shared/httpclient/webcomponent.http.client';
+import { ErrorHandlerService } from '../shared/error-handler.service';
+import { catchError } from 'rxjs/operators';
+import { LoggerService } from '../shared/logger/logger.service';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../shared/httpclient/webcomponent.http.client";
+import * as i3 from "../shared/logger/logger.service";
+import * as i4 from "../shared/error-handler.service";
+import * as i5 from "../../payment-lib.service";
+var PaymentViewService = /** @class */ (function () {
+    function PaymentViewService(http, https, logger, errorHandlerService, paymentLibService) {
+        this.http = http;
+        this.https = https;
+        this.logger = logger;
+        this.errorHandlerService = errorHandlerService;
+        this.paymentLibService = paymentLibService;
+        this.ordersList = (/** @type {?} */ (new BehaviorSubject([])));
+    }
+    /**
+     * @param {?} paymentReference
+     * @param {?} paymentMethod
+     * @return {?}
+     */
+    PaymentViewService.prototype.getPaymentDetails = /**
+     * @param {?} paymentReference
+     * @param {?} paymentMethod
+     * @return {?}
+     */
+    function (paymentReference, paymentMethod) {
+        this.logger.info('Payment-view-service getPaymentDetails for: ', paymentReference);
+        return this.http.get(paymentMethod === 'card' || paymentMethod === 'cash' || paymentMethod === 'cheque' || paymentMethod === 'postal order' ?
+            this.paymentLibService.API_ROOT + "/card-payments/" + paymentReference :
+            this.paymentLibService.API_ROOT + "/credit-account-payments/" + paymentReference, {
+            withCredentials: true
+        })
+            .pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} paymentGroupReference
+     * @return {?}
+     */
+    PaymentViewService.prototype.getPaymentGroupDetails = /**
+     * @param {?} paymentGroupReference
+     * @return {?}
+     */
+    function (paymentGroupReference) {
+        this.logger.info('Payment-view-service getPaymentGroupDetails for: ', paymentGroupReference);
+        return this.http.get(this.paymentLibService.API_ROOT + "/payment-groups/" + paymentGroupReference, {
+            withCredentials: true
+        })
+            .pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} paymentReference
+     * @return {?}
+     */
+    PaymentViewService.prototype.getApportionPaymentDetails = /**
+     * @param {?} paymentReference
+     * @return {?}
+     */
+    function (paymentReference) {
+        this.logger.info('Payment-view-service getPaymentGroupDetails for: ', paymentReference);
+        return this.http.get(this.paymentLibService.API_ROOT + "/payment-groups/fee-pay-apportion/" + paymentReference, {
+            withCredentials: true
+        })
+            .pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @return {?}
+     */
+    PaymentViewService.prototype.getPBAaccountDetails = /**
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        var url = this.paymentLibService.API_ROOT + "/pba-accounts";
+        return this.http.get(url, { withCredentials: true }).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} serviceRef
+     * @param {?} body
+     * @return {?}
+     */
+    PaymentViewService.prototype.postWays2PayCardPayment = /**
+     * @param {?} serviceRef
+     * @param {?} body
+     * @return {?}
+     */
+    function (serviceRef, body) {
+        /** @type {?} */
+        var url = this.paymentLibService.API_ROOT + "/service-request/" + serviceRef + "/card-payments";
+        /** @type {?} */
+        var rurl = this.paymentLibService.CARDPAYMENTRETURNURL.replace('.prod', '');
+        body['return-url'] = rurl + "/payment";
+        return this.https.post(url, body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} serviceRef
+     * @param {?} body
+     * @return {?}
+     */
+    PaymentViewService.prototype.postPBAaccountPayment = /**
+     * @param {?} serviceRef
+     * @param {?} body
+     * @return {?}
+     */
+    function (serviceRef, body) {
+        /** @type {?} */
+        var randomKey = 'idam-key-' + Math.random().toString().split('.').join('-');
+        body['idempotency_key'] = randomKey;
+        /** @type {?} */
+        var url = this.paymentLibService.API_ROOT + "/service-request/" + serviceRef + "/pba-payments";
+        return this.https.post(url, body);
+    };
+    /**
+     * @param {?} body
+     * @return {?}
+     */
+    PaymentViewService.prototype.postBSPayments = /**
+     * @param {?} body
+     * @return {?}
+     */
+    function (body) {
+        return this.https.post(this.paymentLibService.API_ROOT + "/payment-groups/bulk-scan-payments", body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} body
+     * @return {?}
+     */
+    PaymentViewService.prototype.postBSUnidentifiedPayments = /**
+     * @param {?} body
+     * @return {?}
+     */
+    function (body) {
+        return this.https.post(this.paymentLibService.API_ROOT + "/payment-allocations", body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} body
+     * @return {?}
+     */
+    PaymentViewService.prototype.postBSUnsolicitedPayments = /**
+     * @param {?} body
+     * @return {?}
+     */
+    function (body) {
+        return this.https.post(this.paymentLibService.API_ROOT + "/payment-allocations", body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} body
+     * @return {?}
+     */
+    PaymentViewService.prototype.postBSAllocationPayments = /**
+     * @param {?} body
+     * @return {?}
+     */
+    function (body) {
+        return this.https.post(this.paymentLibService.API_ROOT + "/payment-allocations", body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} paymentGroupReference
+     * @param {?} feeId
+     * @param {?} body
+     * @return {?}
+     */
+    PaymentViewService.prototype.postPaymentGroupWithRemissions = /**
+     * @param {?} paymentGroupReference
+     * @param {?} feeId
+     * @param {?} body
+     * @return {?}
+     */
+    function (paymentGroupReference, feeId, body) {
+        return this.https.post(this.paymentLibService.API_ROOT + "/payment-groups/" + paymentGroupReference + "/fees/" + feeId + "/remissions", body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} feeId
+     * @return {?}
+     */
+    PaymentViewService.prototype.deleteFeeFromPaymentGroup = /**
+     * @param {?} feeId
+     * @return {?}
+     */
+    function (feeId) {
+        this.logger.info('Payment-view-service deleteFeeFromPaymentGroup for: ', feeId);
+        return this.https.delete(this.paymentLibService.API_ROOT + "/fees/" + feeId).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} body
+     * @param {?} paymentGroupRef
+     * @return {?}
+     */
+    PaymentViewService.prototype.postPaymentToPayHub = /**
+     * @param {?} body
+     * @param {?} paymentGroupRef
+     * @return {?}
+     */
+    function (body, paymentGroupRef) {
+        return this.https.post(this.paymentLibService.API_ROOT + "/payment-groups/" + paymentGroupRef + "/card-payments", body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} body
+     * @param {?} paymentGroupRef
+     * @return {?}
+     */
+    PaymentViewService.prototype.postPaymentAntennaToPayHub = /**
+     * @param {?} body
+     * @param {?} paymentGroupRef
+     * @return {?}
+     */
+    function (body, paymentGroupRef) {
+        return this.https.post(this.paymentLibService.API_ROOT + "/payment-groups/" + paymentGroupRef + "/telephony-card-payments", body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} reportName
+     * @param {?} startDate
+     * @param {?} endDate
+     * @return {?}
+     */
+    PaymentViewService.prototype.downloadSelectedReport = /**
+     * @param {?} reportName
+     * @param {?} startDate
+     * @param {?} endDate
+     * @return {?}
+     */
+    function (reportName, startDate, endDate) {
+        /** @type {?} */
+        var url = this.paymentLibService.API_ROOT + "/report/data?date_from=" + startDate + "&date_to=" + endDate + "&report_type=" + reportName;
+        return this.https.get(url, { withCredentials: true }).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} startDate
+     * @param {?} endDate
+     * @return {?}
+     */
+    PaymentViewService.prototype.downloadFailureReport = /**
+     * @param {?} startDate
+     * @param {?} endDate
+     * @return {?}
+     */
+    function (startDate, endDate) {
+        /** @type {?} */
+        var url = this.paymentLibService.API_ROOT + "/payment-failures/failure-report?date_from=" + startDate + "&date_to=" + endDate;
+        return this.https.get(url, { withCredentials: true }).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @return {?}
+     */
+    PaymentViewService.prototype.getBSfeature = /**
+     * @return {?}
+     */
+    function () {
+        return this.https.get('api/payment-history/bulk-scan-feature', { withCredentials: true }).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @return {?}
+     */
+    PaymentViewService.prototype.getSiteID = /**
+     * @return {?}
+     */
+    function () {
+        return this.https.get('api/payment-history/refdata/legacy-sites', { withCredentials: true }).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} caseNumber
+     * @return {?}
+     */
+    PaymentViewService.prototype.getPartyDetails = /**
+     * @param {?} caseNumber
+     * @return {?}
+     */
+    function (caseNumber) {
+        /** @type {?} */
+        var url = this.paymentLibService.API_ROOT + "/case-payment-orders?case_ids=" + caseNumber;
+        return this.https.get(url, { withCredentials: true }).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} orderLevelFees
+     * @return {?}
+     */
+    PaymentViewService.prototype.setOrdersList = /**
+     * @param {?} orderLevelFees
+     * @return {?}
+     */
+    function (orderLevelFees) {
+        this.ordersList.next(Object.assign([], orderLevelFees));
+    };
+    /**
+     * @return {?}
+     */
+    PaymentViewService.prototype.getOrdersList = /**
+     * @return {?}
+     */
+    function () {
+        return this.ordersList;
+    };
+    //issue refund
+    //issue refund
+    /**
+     * @param {?} body
+     * @return {?}
+     */
+    PaymentViewService.prototype.postRefundsReason = 
+    //issue refund
+    /**
+     * @param {?} body
+     * @return {?}
+     */
+    function (body) {
+        return this.https.post(this.paymentLibService.API_ROOT + "/refund-for-payment", body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    // retro remissions
+    // retro remissions
+    /**
+     * @param {?} paymentGroupReference
+     * @param {?} feeId
+     * @param {?} body
+     * @return {?}
+     */
+    PaymentViewService.prototype.postPaymentGroupWithRetroRemissions = 
+    // retro remissions
+    /**
+     * @param {?} paymentGroupReference
+     * @param {?} feeId
+     * @param {?} body
+     * @return {?}
+     */
+    function (paymentGroupReference, feeId, body) {
+        return this.https.post(this.paymentLibService.API_ROOT + "/payment-groups/" + paymentGroupReference + "/fees/" + feeId + "/retro-remission", body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} body
+     * @return {?}
+     */
+    PaymentViewService.prototype.postRefundRetroRemission = /**
+     * @param {?} body
+     * @return {?}
+     */
+    function (body) {
+        return this.https.post(this.paymentLibService.API_ROOT + "/refund-retro-remission", body).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    /**
+     * @param {?} paymentReference
+     * @return {?}
+     */
+    PaymentViewService.prototype.getPaymentFailure = /**
+     * @param {?} paymentReference
+     * @return {?}
+     */
+    function (paymentReference) {
+        return this.https.get(this.paymentLibService.API_ROOT + "/payment-failures/" + paymentReference, {
+            withCredentials: true
+        }).pipe(catchError(this.errorHandlerService.handleError));
+    };
+    PaymentViewService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    PaymentViewService.ctorParameters = function () { return [
+        { type: HttpClient },
+        { type: WebComponentHttpClient },
+        { type: LoggerService },
+        { type: ErrorHandlerService },
+        { type: PaymentLibService }
+    ]; };
+    /** @nocollapse */ PaymentViewService.ngInjectableDef = i0.defineInjectable({ factory: function PaymentViewService_Factory() { return new PaymentViewService(i0.inject(i1.HttpClient), i0.inject(i2.WebComponentHttpClient), i0.inject(i3.LoggerService), i0.inject(i4.ErrorHandlerService), i0.inject(i5.PaymentLibService)); }, token: PaymentViewService, providedIn: "root" });
+    return PaymentViewService;
+}());
+export { PaymentViewService };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    PaymentViewService.prototype.ordersList;
+    /**
+     * @type {?}
+     * @private
+     */
+    PaymentViewService.prototype.meta;
+    /**
+     * @type {?}
+     * @private
+     */
+    PaymentViewService.prototype.http;
+    /**
+     * @type {?}
+     * @private
+     */
+    PaymentViewService.prototype.https;
+    /**
+     * @type {?}
+     * @private
+     */
+    PaymentViewService.prototype.logger;
+    /**
+     * @type {?}
+     * @private
+     */
+    PaymentViewService.prototype.errorHandlerService;
+    /**
+     * @type {?}
+     * @private
+     */
+    PaymentViewService.prototype.paymentLibService;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"payment-view.service.js","sourceRoot":"ng://@hmcts/ccpay-web-component/","sources":["lib/services/payment-view/payment-view.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { Observable } from 'rxjs/internal/Observable';\nimport { v4 as uuidv4 } from 'uuid';\nimport {IPayment} from '../../interfaces/IPayment';\nimport {PaymentLibService} from '../../payment-lib.service';\nimport { WebComponentHttpClient } from '../shared/httpclient/webcomponent.http.client';\nimport { ErrorHandlerService } from '../shared/error-handler.service';\nimport { catchError } from 'rxjs/operators';\nimport { LoggerService } from '../shared/logger/logger.service';\nimport {IPaymentGroup} from '../../interfaces/IPaymentGroup';\nimport { AddRemissionRequest } from '../../interfaces/AddRemissionRequest';\nimport { PaymentToPayhubRequest } from '../../interfaces/PaymentToPayhubRequest';\nimport { PayhubAntennaRequest } from '../../interfaces/PayhubAntennaRequest';\nimport { UnidentifiedPaymentsRequest } from '../../interfaces/UnidentifiedPaymentsRequest';\nimport { UnsolicitedPaymentsRequest } from '../../interfaces/UnsolicitedPaymentsRequest';\nimport { Meta } from '@angular/platform-browser';\nimport { AllocatePaymentRequest } from '../../interfaces/AllocatePaymentRequest';\nimport { IAllocationPaymentsRequest } from '../../interfaces/IAllocationPaymentsRequest';\nimport {IOrderReferenceFee} from '../../interfaces/IOrderReferenceFee';\nimport { BehaviorSubject } from 'rxjs';\nimport { IserviceRequestPbaPayment } from '../../interfaces/IserviceRequestPbaPayment';\nimport { IserviceRequestCardPayment } from '../../interfaces/IserviceRequestCardPayment';\nimport { RefundsRequest } from '../../interfaces/RefundsRequest';\nimport { AddRetroRemissionRequest } from '../../interfaces/AddRetroRemissionRequest';\nimport { PostRefundRetroRemission } from '../../interfaces/PostRefundRetroRemission';\nimport { PostIssueRefundRetroRemission } from '../../interfaces/PostIssueRefundRetroRemission';\nimport { error } from '@angular/compiler/src/util';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PaymentViewService {\n  private ordersList  = <BehaviorSubject<IOrderReferenceFee[]>>new BehaviorSubject([]);\n\n  private meta: Meta;\n\n  constructor(private http: HttpClient,\n              private https: WebComponentHttpClient,\n              private logger: LoggerService,\n              private errorHandlerService: ErrorHandlerService,\n              private paymentLibService: PaymentLibService) { }\n\n  getPaymentDetails(paymentReference: string, paymentMethod: string): Observable<IPayment> {\n    this.logger.info('Payment-view-service getPaymentDetails for: ', paymentReference);\n\n    return this.http.get<IPayment>(paymentMethod === 'card' || paymentMethod === 'cash' || paymentMethod === 'cheque' || paymentMethod === 'postal order' ?\n          `${this.paymentLibService.API_ROOT}/card-payments/${paymentReference}` :\n          `${this.paymentLibService.API_ROOT}/credit-account-payments/${paymentReference}`, {\n        withCredentials: true\n      })\n      .pipe(\n        catchError(this.errorHandlerService.handleError)\n      );\n  }\n\n  getPaymentGroupDetails(paymentGroupReference: string): Observable<IPaymentGroup> {\n    this.logger.info('Payment-view-service getPaymentGroupDetails for: ', paymentGroupReference);\n\n    return this.http.get<IPayment>(`${this.paymentLibService.API_ROOT}/payment-groups/${paymentGroupReference}`, {\n      withCredentials: true\n    })\n      .pipe(\n        catchError(this.errorHandlerService.handleError)\n      );\n  }\n  getApportionPaymentDetails(paymentReference: string): Observable<IPaymentGroup> {\n    this.logger.info('Payment-view-service getPaymentGroupDetails for: ', paymentReference);\n\n    return this.http.get<IPayment>(`${this.paymentLibService.API_ROOT}/payment-groups/fee-pay-apportion/${paymentReference}`, {\n      withCredentials: true\n    })\n      .pipe(\n        catchError(this.errorHandlerService.handleError)\n      );\n  }\n  getPBAaccountDetails(): Observable<any> {\n    const url = `${this.paymentLibService.API_ROOT}/pba-accounts`;\n    return this.http.get(url, { withCredentials: true }).pipe(\n        catchError(this.errorHandlerService.handleError)\n      );\n  }\n\n  postWays2PayCardPayment(serviceRef: string, body: IserviceRequestCardPayment): Observable<any> {\n    const url = `${this.paymentLibService.API_ROOT}/service-request/${serviceRef}/card-payments`;\n    const rurl = this.paymentLibService.CARDPAYMENTRETURNURL.replace('.prod', '');\n    body['return-url'] = `${rurl}/payment`;\n    return this.https.post(url, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n  \n  postPBAaccountPayment(serviceRef: string, body: IserviceRequestPbaPayment): Observable<any> {\n    let randomKey = 'idam-key-' + Math.random().toString().split('.').join('-');\n    body['idempotency_key'] = randomKey; \n    const url = `${this.paymentLibService.API_ROOT}/service-request/${serviceRef}/pba-payments`;\n    return this.https.post(url, body);\n  }\n\n  postBSPayments(body: AllocatePaymentRequest): Observable<any> {\n    return this.https.post(`${this.paymentLibService.API_ROOT}/payment-groups/bulk-scan-payments`, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n  postBSUnidentifiedPayments(body: UnidentifiedPaymentsRequest): Observable<any> {\n    return this.https.post(`${this.paymentLibService.API_ROOT}/payment-allocations`, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n  postBSUnsolicitedPayments(body: UnsolicitedPaymentsRequest): Observable<any> {\n    return this.https.post(`${this.paymentLibService.API_ROOT}/payment-allocations`, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n  postBSAllocationPayments(body: IAllocationPaymentsRequest): Observable<any> {\n    return this.https.post(`${this.paymentLibService.API_ROOT}/payment-allocations`, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n\n  postPaymentGroupWithRemissions(paymentGroupReference: string, feeId: number, body: AddRemissionRequest): Observable<any> {\n    return this.https.post(`${this.paymentLibService.API_ROOT}/payment-groups/${paymentGroupReference}/fees/${feeId}/remissions`, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n\n  deleteFeeFromPaymentGroup(feeId: number): Observable<any> {\n        this.logger.info('Payment-view-service deleteFeeFromPaymentGroup for: ', feeId);\n    return this.https.delete(`${this.paymentLibService.API_ROOT}/fees/${feeId}`).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n  postPaymentToPayHub(body: PaymentToPayhubRequest, paymentGroupRef: string): Observable<any> {\n    return this.https.post(`${this.paymentLibService.API_ROOT}/payment-groups/${paymentGroupRef}/card-payments`, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n\n  postPaymentAntennaToPayHub(body: PayhubAntennaRequest, paymentGroupRef: string): Observable<any> {\n    return this.https.post(`${this.paymentLibService.API_ROOT}/payment-groups/${paymentGroupRef}/telephony-card-payments`, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n  downloadSelectedReport(reportName: string, startDate: string, endDate:string): Observable<any> {\n    const url = `${this.paymentLibService.API_ROOT}/report/data?date_from=${startDate}&date_to=${endDate}&report_type=${reportName}`;\n    return this.https.get(url, { withCredentials: true }).pipe( catchError(this.errorHandlerService.handleError));\n  }\n  downloadFailureReport(startDate: string, endDate:string): Observable<any> {\n    const url = `${this.paymentLibService.API_ROOT}/payment-failures/failure-report?date_from=${startDate}&date_to=${endDate}`;\n    return this.https.get(url, { withCredentials: true }).pipe( catchError(this.errorHandlerService.handleError));\n  }\n  getBSfeature(): Observable<any> {\n    return this.https.get('api/payment-history/bulk-scan-feature', { withCredentials: true }).pipe( catchError(this.errorHandlerService.handleError));\n  }\n  getSiteID(): Observable<any> {\n    return this.https.get('api/payment-history/refdata/legacy-sites', { withCredentials: true }).pipe( catchError(this.errorHandlerService.handleError));\n  }\n  getPartyDetails(caseNumber: string): Observable<any> {\n    const url = `${this.paymentLibService.API_ROOT}/case-payment-orders?case_ids=${caseNumber}`;\n    return this.https.get(url, { withCredentials: true }).pipe( catchError(this.errorHandlerService.handleError));\n  }\n  \n  setOrdersList(orderLevelFees: IOrderReferenceFee[]): void {\n    this.ordersList.next(Object.assign([], orderLevelFees));\n}\n  getOrdersList() {\n    return this.ordersList;\n  }\n\n  //issue refund\n  postRefundsReason(body: PostRefundRetroRemission): Observable<any> {\n    return this.https.post(`${this.paymentLibService.API_ROOT}/refund-for-payment`, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n\n  // retro remissions\n  postPaymentGroupWithRetroRemissions(paymentGroupReference: string, feeId: number, body: AddRetroRemissionRequest): Observable<any> {\n    return this.https.post(`${this.paymentLibService.API_ROOT}/payment-groups/${paymentGroupReference}/fees/${feeId}/retro-remission`, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n\n  postRefundRetroRemission(body:PostIssueRefundRetroRemission) {\n    return this.https.post(`${this.paymentLibService.API_ROOT}/refund-retro-remission`, body).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n getPaymentFailure(paymentReference: string): Observable<any> {\n    return this.https.get(`${this.paymentLibService.API_ROOT}/payment-failures/${paymentReference}`, {\n      withCredentials: true\n    }).pipe(\n      catchError(this.errorHandlerService.handleError)\n    );\n  }\n}\n"]}