@colijnit/transaction 12.1.78 → 12.1.80

package/esm2015/lib/service/dynamic-component.service.js

@@ -0,0 +1,93 @@
+import { ApplicationRef, ComponentFactoryResolver, Injectable, Injector } from "@angular/core";
+import * as i0 from "@angular/core";
+export class DynamicComponentService {
+    constructor(_compFactoryResolver, appRef, injector) {
+        this._compFactoryResolver = _compFactoryResolver;
+        this.appRef = appRef;
+        this.injector = injector;
+        this._componentRefs = [];
+    }
+    getComponentRefs() {
+        return this._componentRefs;
+    }
+    createAndReturnComponentRef(componentClass, inputs) {
+        return new Promise((resolve) => {
+            const componentRef = this._compFactoryResolver
+                .resolveComponentFactory(componentClass)
+                .create(this.injector);
+            if (inputs) {
+                for (let property in inputs) {
+                    if (inputs.hasOwnProperty(property)) {
+                        componentRef.instance[property] = inputs[property];
+                    }
+                }
+            }
+            this.appRef.attachView(componentRef.hostView);
+            const domElem = componentRef.hostView
+                .rootNodes[0];
+            document.body.appendChild(domElem);
+            componentRef.onDestroy(() => {
+                this.appRef.detachView(componentRef.hostView);
+            });
+            resolve(componentRef);
+        });
+    }
+    createComponent(componentClass, inputs, outputs, providers) {
+        return new Promise((resolve) => {
+            if (providers) {
+                Injector.create(providers, this.injector);
+            }
+            const componentRef = this._compFactoryResolver
+                .resolveComponentFactory(componentClass)
+                .create(this.injector);
+            this._componentRefs.push(componentRef);
+            if (inputs) {
+                for (let property in inputs) {
+                    if (inputs.hasOwnProperty(property)) {
+                        componentRef.instance[property] = inputs[property];
+                    }
+                }
+            }
+            if (outputs) {
+                for (let event in outputs) {
+                    if (outputs.hasOwnProperty(event)) {
+                        componentRef.instance[event].subscribe(() => outputs[event]());
+                    }
+                }
+            }
+            this.appRef.attachView(componentRef.hostView);
+            const domElem = componentRef.hostView
+                .rootNodes[0];
+            document.body.appendChild(domElem);
+            componentRef.onDestroy(() => {
+                this.appRef.detachView(componentRef.hostView);
+            });
+            componentRef.instance.onClose = (button, output) => {
+                const idx = this._componentRefs.indexOf(componentRef);
+                this.appRef.detachView(componentRef.hostView);
+                this._componentRefs[idx] = undefined;
+                this._componentRefs.splice(idx, 1);
+                if (outputs) {
+                    for (let event in outputs) {
+                        if (outputs.hasOwnProperty(event)) {
+                            componentRef.instance[event].unsubscribe();
+                        }
+                    }
+                }
+                resolve({ button: button, output: output ? output : undefined });
+            };
+        });
+    }
+}
+DynamicComponentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function DynamicComponentService_Factory() { return new DynamicComponentService(i0.ɵɵinject(i0.ComponentFactoryResolver), i0.ɵɵinject(i0.ApplicationRef), i0.ɵɵinject(i0.INJECTOR)); }, token: DynamicComponentService, providedIn: "root" });
+DynamicComponentService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+DynamicComponentService.ctorParameters = () => [
+    { type: ComponentFactoryResolver },
+    { type: ApplicationRef },
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-component.service.js","sourceRoot":"","sources":["../../../../../projects/transaction/src/lib/service/dynamic-component.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {ApplicationRef, ComponentFactoryResolver, ComponentRef, EmbeddedViewRef, Injectable, Injector, StaticProvider} from \"@angular/core\";\r\nimport {DialogResponseInterface} from \"../interface/dialog-response.interface\";\r\n\r\n@Injectable({\r\n  providedIn: \"root\"\r\n})\r\nexport class DynamicComponentService {\r\n\r\n  private _componentRefs: any[] = [];\r\n\r\n  constructor(\r\n    private _compFactoryResolver: ComponentFactoryResolver,\r\n    private appRef: ApplicationRef,\r\n    private injector: Injector\r\n  ) { }\r\n\r\n  public getComponentRefs(): ComponentRef<any>[] {\r\n    return this._componentRefs;\r\n  }\r\n\r\n  public createAndReturnComponentRef(componentClass: any, inputs?: any): Promise<any> {\r\n    return new Promise((resolve: Function) => {\r\n      const componentRef: any = this._compFactoryResolver\r\n        .resolveComponentFactory(componentClass)\r\n        .create(this.injector);\r\n\r\n      if (inputs) {\r\n        for (let property in inputs) {\r\n          if (inputs.hasOwnProperty(property)) {\r\n            componentRef.instance[property] = inputs[property];\r\n          }\r\n        }\r\n      }\r\n\r\n      this.appRef.attachView(componentRef.hostView);\r\n\r\n      const domElem = (componentRef.hostView as EmbeddedViewRef<any>)\r\n        .rootNodes[0] as HTMLElement;\r\n\r\n      document.body.appendChild(domElem);\r\n      componentRef.onDestroy(() => {\r\n        this.appRef.detachView(componentRef.hostView);\r\n      });\r\n      resolve(componentRef);\r\n    })\r\n  }\r\n\r\n  public createComponent(componentClass: any, inputs?: any, outputs?: any, providers?: StaticProvider[]): Promise<DialogResponseInterface> {\r\n    return new Promise((resolve: Function) => {\r\n      if (providers) {\r\n        Injector.create(providers, this.injector);\r\n      }\r\n      const componentRef: any = this._compFactoryResolver\r\n        .resolveComponentFactory(componentClass)\r\n        .create(this.injector);\r\n      this._componentRefs.push(componentRef);\r\n\r\n      if (inputs) {\r\n        for (let property in inputs) {\r\n          if (inputs.hasOwnProperty(property)) {\r\n            componentRef.instance[property] = inputs[property];\r\n          }\r\n        }\r\n      }\r\n\r\n      if (outputs) {\r\n        for (let event in outputs) {\r\n          if (outputs.hasOwnProperty(event)) {\r\n            componentRef.instance[event].subscribe(() => outputs[event]());\r\n          }\r\n        }\r\n      }\r\n\r\n      this.appRef.attachView(componentRef.hostView);\r\n\r\n      const domElem = (componentRef.hostView as EmbeddedViewRef<any>)\r\n        .rootNodes[0] as HTMLElement;\r\n\r\n      document.body.appendChild(domElem);\r\n      componentRef.onDestroy(() => {\r\n        this.appRef.detachView(componentRef.hostView);\r\n      });\r\n\r\n      componentRef.instance.onClose = (button: any, output?: any) => {\r\n        const idx: number = this._componentRefs.indexOf(componentRef);\r\n        this.appRef.detachView(componentRef.hostView);\r\n        this._componentRefs[idx] = undefined;\r\n        this._componentRefs.splice(idx, 1);\r\n\r\n        if (outputs) {\r\n          for (let event in outputs) {\r\n            if (outputs.hasOwnProperty(event)) {\r\n              componentRef.instance[event].unsubscribe();\r\n            }\r\n          }\r\n        }\r\n        resolve({button: button, output: output ? output : undefined});\r\n      }\r\n    })\r\n  }\r\n}\r\n"]}

package/esm2015/lib/service/error.service.js

@@ -0,0 +1,68 @@
+import { Injectable } from "@angular/core";
+import { DialogService } from "./dialog.service";
+import { DictionaryService } from "./dictionary.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./dialog.service";
+import * as i2 from "./dictionary.service";
+export class ErrorService {
+    constructor(_dialogService, _dictionaryService) {
+        this._dialogService = _dialogService;
+        this._dictionaryService = _dictionaryService;
+    }
+    showError(message, details) {
+        return this._dialogService.showError(message, details);
+    }
+    showValidationError(response) {
+        const messages = [];
+        const messagesDetails = [];
+        messages.push('<div class="dialog-error-wrapper">');
+        if (response.message) {
+            messages.push(this._messageAsValidationError(response.message));
+        }
+        else if (response.validationResult && !response.validationResult.success) {
+            if (response.validationResult.messages && response.validationResult.messages.length > 0) {
+                response.validationResult.messages.forEach(m => {
+                    messages.push(this._messageAsValidationError(m.message));
+                    if (m.messageCode) {
+                        messagesDetails.push(this._messageDetails(m.messageCode));
+                    }
+                });
+            }
+            else if (response.validationResult.fieldValidations) {
+                messages.push(this._messageAsValidationError('Validation error'));
+                for (let key in response.validationResult.fieldValidations) {
+                    if (response.validationResult.fieldValidations.hasOwnProperty(key)) {
+                        if (response.validationResult.fieldValidations[key].messages && response.validationResult.fieldValidations[key].messages.length > 0) {
+                            for (let i = 0; i < response.validationResult.fieldValidations[key].messages.length; i++) {
+                                const messageCode = {
+                                    value: response.validationResult.fieldValidations[key].messages[i].fieldId,
+                                    defaultStr: response.validationResult.fieldValidations[key].messages[i].message
+                                };
+                                messagesDetails.push(this._messageDetails(messageCode));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        messages.push('</div>');
+        return this.showError(messages.join(''), messagesDetails.length > 0 ? messagesDetails.join('') : undefined);
+    }
+    _messageAsValidationError(message) {
+        return `<div class="dialog-validation-error">${message}</div>`;
+    }
+    _messageDetails(messageCode) {
+        return `<div class="dialog-error-code-string">${messageCode.value}: ${messageCode.defaultStr}</div>`;
+    }
+}
+ErrorService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ErrorService_Factory() { return new ErrorService(i0.ɵɵinject(i1.DialogService), i0.ɵɵinject(i2.DictionaryService)); }, token: ErrorService, providedIn: "root" });
+ErrorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+ErrorService.ctorParameters = () => [
+    { type: DialogService },
+    { type: DictionaryService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/service/icon-cache.service.js

@@ -0,0 +1,51 @@
+import { Injectable } from "@angular/core";
+import { DomSanitizer } from "@angular/platform-browser";
+import { IconSvg } from "../model/icon-svg";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class IconCacheService {
+    constructor(_sanitizer) {
+        this._sanitizer = _sanitizer;
+        this._iconCache = {};
+        this.setIconCache();
+    }
+    /**
+     * All the icons as a large JSON object, from the all-icons.json file.
+     * The object has property keys that are the icon names, and property values with the data string of the actual svg icon.
+     */
+    get iconCache() {
+        return this._iconCache;
+    }
+    getIcon(iconName) {
+        if (iconName) {
+            return this._iconCache[iconName.toLowerCase()];
+        }
+    }
+    getIconAsBase64(iconName) {
+        const icon = IconSvg[iconName];
+        const base64Data = window.btoa(icon);
+        return this._sanitizer.bypassSecurityTrustUrl(`data:image/svg+xml;base64,${base64Data}`);
+    }
+    getRawIcon(iconName) {
+        if (iconName) {
+            return IconSvg[iconName.toLowerCase()];
+        }
+    }
+    setIconCache() {
+        for (const key in IconSvg) {
+            if (IconSvg.hasOwnProperty(key) && typeof IconSvg[key] !== "function") {
+                this._iconCache[key.toLowerCase()] = this._sanitizer.bypassSecurityTrustHtml(IconSvg[key]);
+            }
+        }
+    }
+}
+IconCacheService.ɵprov = i0.ɵɵdefineInjectable({ factory: function IconCacheService_Factory() { return new IconCacheService(i0.ɵɵinject(i1.DomSanitizer)); }, token: IconCacheService, providedIn: "root" });
+IconCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+IconCacheService.ctorParameters = () => [
+    { type: DomSanitizer }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/service/options.service.js

@@ -0,0 +1,71 @@
+import { __awaiter } from "tslib";
+import { Injectable } from "@angular/core";
+import { BehaviorSubject } from "rxjs";
+import { DictionaryService } from "./dictionary.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./dictionary.service";
+export class OptionsService {
+    constructor(_dictionary) {
+        this._dictionary = _dictionary;
+        this.optionsInitialized = new BehaviorSubject(false);
+        this.optionsLoaded = new BehaviorSubject(false);
+    }
+    set options(value) {
+        this._options = value;
+    }
+    get options() {
+        return this._options;
+    }
+    createSettingsFromObject(obj) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.options = new Object();
+            if (obj.hasOwnProperty("url")) {
+                this.options.url = obj["url"];
+            }
+            if (obj.hasOwnProperty("schema")) {
+                this.options.schema = obj["schema"];
+            }
+            if (obj.hasOwnProperty("version")) {
+                this.options.version = obj["version"];
+            }
+            if (obj.hasOwnProperty("languageCode")) {
+                this.options.languageCode = obj["languageCode"];
+            }
+            else {
+                this.options.languageCode = "NL";
+            }
+            if (obj.hasOwnProperty("username")) {
+                this.options.username = obj["username"];
+            }
+            if (obj.hasOwnProperty("password")) {
+                this.options.password = obj["password"];
+            }
+            if (obj.hasOwnProperty("session")) {
+                this.options.session = obj["session"];
+            }
+            if (obj.hasOwnProperty("useLoginEncryption")) {
+                this.options.useLoginEncryption = obj["useLoginEncryption"];
+            }
+            this.optionsLoaded.next(true);
+        });
+    }
+    initialize(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options) {
+                yield this.createSettingsFromObject(options);
+                yield this._dictionary.setDictionary(this.options.languageCode);
+                this.optionsInitialized.next(true);
+            }
+        });
+    }
+}
+OptionsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function OptionsService_Factory() { return new OptionsService(i0.ɵɵinject(i1.DictionaryService)); }, token: OptionsService, providedIn: "root" });
+OptionsService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+OptionsService.ctorParameters = () => [
+    { type: DictionaryService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/service/payment.service.js

@@ -0,0 +1,105 @@
+import { __awaiter } from "tslib";
+import { Injectable } from "@angular/core";
+import { PaymentMethod } from "@colijnit/transactionapi/build/model/payment-method.bo";
+import { TransactionService } from "./transaction.service";
+import { TransactionConnectorAdapterService } from "./transaction-connector-adapter.service";
+import { SelectMultipleCacheService } from "../cache/service/select-multiple-cache.service";
+import { PaymentViewmodel } from "../model/payment.viewmodel";
+import { SharedService } from "./shared.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./transaction-connector-adapter.service";
+import * as i2 from "../cache/service/select-multiple-cache.service";
+import * as i3 from "./transaction.service";
+import * as i4 from "./shared.service";
+export class PaymentService {
+    constructor(_adapterService, _selectMultipleCacheService, _transactionService, _sharedService) {
+        this._adapterService = _adapterService;
+        this._selectMultipleCacheService = _selectMultipleCacheService;
+        this._transactionService = _transactionService;
+        this._sharedService = _sharedService;
+    }
+    updateHeaderTransactionToDownPay(uuid, downPayment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._adapterService.changeHeaderTransactionToDownPay(uuid, downPayment)
+                .catch((error) => {
+                // todo: do something with the error
+                return false;
+            });
+            if (response) {
+                const success = yield this._transactionService.handleHeaderOperationStatuses(response);
+                this._transactionService.rememberCurrentTransaction(response);
+                return success;
+            }
+            return false;
+        });
+    }
+    registerSalesOrderPayment(uuid, amount, currencyId, paymentMethod, cashRegisterGroupId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._adapterService.registerSalesOrderPayment(uuid, amount, currencyId, paymentMethod, cashRegisterGroupId);
+            if (response.validationResult.success) {
+                return true;
+            }
+            return false;
+        });
+    }
+    createIonePaymentLinkAndQRCode(uuid, amount, paymentMethodCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._adapterService.createIonePaymentLinkAndQRCode(uuid, amount, paymentMethodCode);
+        });
+    }
+    getPaymentLinkStatus(paymentLinkUUID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._adapterService.getPaymentLinkStatus(paymentLinkUUID);
+        });
+    }
+    getDownPaymentInfo(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._adapterService.getDownPaymentInfo(uuid);
+        });
+    }
+    getPaymentMethods() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._selectMultipleCacheService.requestCache(PaymentMethod, () => {
+                return this._adapterService.getPaymentMethods();
+            }).getValue();
+        });
+    }
+    getPaymentMethodsViewModels() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = [];
+            const methods = yield this.getPaymentMethods();
+            methods.forEach((m) => __awaiter(this, void 0, void 0, function* () {
+                const paymentViewModel = new PaymentViewmodel(m);
+                const imageDocs = m.documents.filter(d => d.isImageDocument());
+                if (imageDocs && imageDocs.length) {
+                    const image = imageDocs[0];
+                    if (image.filePath) {
+                        paymentViewModel.image = image.filePath;
+                    }
+                    else {
+                        if (!image.thumbnailBody) {
+                            const content = yield this._sharedService.getDocumentContent(image.documentId);
+                            image.thumbnailBody = content;
+                        }
+                        paymentViewModel.image = image.thumbnailBodyAsDataUri;
+                    }
+                }
+                result.push(paymentViewModel);
+            }));
+            return result;
+        });
+    }
+}
+PaymentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PaymentService_Factory() { return new PaymentService(i0.ɵɵinject(i1.TransactionConnectorAdapterService), i0.ɵɵinject(i2.SelectMultipleCacheService), i0.ɵɵinject(i3.TransactionService), i0.ɵɵinject(i4.SharedService)); }, token: PaymentService, providedIn: "root" });
+PaymentService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+PaymentService.ctorParameters = () => [
+    { type: TransactionConnectorAdapterService },
+    { type: SelectMultipleCacheService },
+    { type: TransactionService },
+    { type: SharedService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"payment.service.js","sourceRoot":"","sources":["../../../../../projects/transaction/src/lib/service/payment.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from \"@angular/core\";\r\nimport {TransactionInfoResponse} from \"@colijnit/transactionapi/build/model/transaction-info-response.bo\";\r\nimport {PaymentMethod} from \"@colijnit/transactionapi/build/model/payment-method.bo\";\r\nimport {CreatePaymentLinkResult} from \"@colijnit/transactionapi/build/model/create-payment-link-result.bo\";\r\nimport {TransactionService} from \"./transaction.service\";\r\nimport {PaymentLinkStatus} from \"@colijnit/transactionapi/build/model/payment-link-status.bo\";\r\nimport {TransactionConnectorAdapterService} from \"./transaction-connector-adapter.service\";\r\nimport {SelectMultipleCacheService} from \"../cache/service/select-multiple-cache.service\";\r\nimport {TransactionDownPaymentInfo} from \"@colijnit/transactionapi/build/model/transaction-down-payment-info.bo\";\r\nimport {PaymentViewmodel} from \"../model/payment.viewmodel\";\r\nimport {SharedService} from \"./shared.service\";\r\nimport {DataServiceResponseData} from \"@colijnit/ioneconnector/build/model/data-service-response-data\";\r\nimport {CoDocument} from \"@colijnit/mainapi/build/model/co-document\";\r\n\r\n@Injectable({\r\n  providedIn: \"root\"\r\n})\r\nexport class PaymentService {\r\n\r\n  constructor(\r\n    private _adapterService: TransactionConnectorAdapterService,\r\n    private _selectMultipleCacheService: SelectMultipleCacheService,\r\n    private _transactionService: TransactionService,\r\n    private _sharedService: SharedService\r\n  ) {\r\n  }\r\n\r\n  public async updateHeaderTransactionToDownPay(uuid: string, downPayment: number): Promise<boolean> {\r\n    const response: TransactionInfoResponse | boolean = await this._adapterService.changeHeaderTransactionToDownPay(uuid, downPayment)\r\n      .catch((error) => {\r\n        // todo: do something with the error\r\n        return false;\r\n      });\r\n    if (response) {\r\n      const success: boolean = await this._transactionService.handleHeaderOperationStatuses(response);\r\n      this._transactionService.rememberCurrentTransaction(response);\r\n      return success;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  public async registerSalesOrderPayment(\r\n    uuid: string, amount: number, currencyId: number, paymentMethod: string, cashRegisterGroupId: number\r\n  ): Promise<boolean> {\r\n    const response: DataServiceResponseData =\r\n      await this._adapterService.registerSalesOrderPayment(uuid, amount, currencyId, paymentMethod, cashRegisterGroupId);\r\n    if (response.validationResult.success) {\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  public async createIonePaymentLinkAndQRCode(uuid: string, amount: number, paymentMethodCode: string): Promise<CreatePaymentLinkResult> {\r\n    return this._adapterService.createIonePaymentLinkAndQRCode(uuid, amount, paymentMethodCode);\r\n  }\r\n\r\n  public async getPaymentLinkStatus(paymentLinkUUID: string): Promise<PaymentLinkStatus> {\r\n    return this._adapterService.getPaymentLinkStatus(paymentLinkUUID);\r\n  }\r\n\r\n  public async getDownPaymentInfo(uuid: string): Promise<TransactionDownPaymentInfo> {\r\n    return this._adapterService.getDownPaymentInfo(uuid);\r\n  }\r\n\r\n  public async getPaymentMethods(): Promise<PaymentMethod[]> {\r\n    return this._selectMultipleCacheService.requestCache<PaymentMethod>(PaymentMethod, () => {\r\n      return this._adapterService.getPaymentMethods()\r\n    }).getValue();\r\n  }\r\n\r\n  public async getPaymentMethodsViewModels(): Promise<PaymentViewmodel[]> {\r\n    const result: PaymentViewmodel[] = [];\r\n    const methods = await this.getPaymentMethods();\r\n    methods.forEach(async (m: PaymentMethod) => {\r\n      const paymentViewModel: PaymentViewmodel = new PaymentViewmodel(m);\r\n      const imageDocs: CoDocument[] = m.documents.filter(d => d.isImageDocument());\r\n      if (imageDocs && imageDocs.length) {\r\n        const image: CoDocument = imageDocs[0];\r\n        if (image.filePath) {\r\n          paymentViewModel.image = image.filePath;\r\n        } else {\r\n          if (!image.thumbnailBody) {\r\n            const content: string = await this._sharedService.getDocumentContent(image.documentId);\r\n            image.thumbnailBody = content;\r\n          }\r\n          paymentViewModel.image = image.thumbnailBodyAsDataUri;\r\n        }\r\n      }\r\n      result.push(paymentViewModel);\r\n    });\r\n    return result;\r\n  }\r\n}\r\n"]}