@colijnit/transaction 12.1.76 → 12.1.78

package/projects/transaction/src/lib/service/error.service.ts

@@ -0,0 +1,63 @@
+import {Injectable} from "@angular/core";
+import {DialogService} from "./dialog.service";
+import {DictionaryService} from "./dictionary.service";
+import {DataServiceResponseData} from "@colijnit/ioneconnector/build/model/data-service-response-data";
+
+@Injectable({
+  providedIn: "root"
+})
+export class ErrorService {
+
+  constructor(
+    private _dialogService: DialogService,
+    private _dictionaryService: DictionaryService
+    ) {
+  }
+
+  public showError(message: string, details?: string): Promise<any> {
+    return this._dialogService.showError(message, details);
+  }
+
+  public showValidationError(response: DataServiceResponseData | any): Promise<any> {
+    const messages: string[] = [];
+    const messagesDetails: string[] = [];
+    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);
+  }
+
+  private _messageAsValidationError(message: string): string {
+    return `<div class="dialog-validation-error">${message}</div>`;
+  }
+
+  private _messageDetails(messageCode: any): string {
+    return `<div class="dialog-error-code-string">${messageCode.value}: ${messageCode.defaultStr}</div>`;
+  }
+}

package/projects/transaction/src/lib/service/icon-cache.service.ts

@@ -0,0 +1,51 @@
+import {Injectable} from "@angular/core";
+import {DomSanitizer, SafeHtml} from "@angular/platform-browser";
+import {Icon} from "../enum/icon.enum";
+import {IconSvg} from "../model/icon-svg";
+
+@Injectable({
+  providedIn: "root"
+})
+export class IconCacheService {
+  /**
+   * 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.
+   */
+  public get iconCache(): { [iconName: string]: SafeHtml } {
+    return this._iconCache;
+  }
+
+  private _iconCache: { [iconName: string]: SafeHtml } = {};
+
+  constructor(
+    private _sanitizer: DomSanitizer
+  ) {
+    this.setIconCache();
+  }
+
+  public getIcon(iconName: Icon | string): SafeHtml {
+    if (iconName) {
+      return this._iconCache[iconName.toLowerCase()];
+    }
+  }
+
+  public getIconAsBase64(iconName: Icon): SafeHtml {
+    const icon: string = IconSvg[iconName];
+    const base64Data: string = window.btoa(icon);
+    return this._sanitizer.bypassSecurityTrustUrl(`data:image/svg+xml;base64,${base64Data}`);
+  }
+
+  public getRawIcon(iconName: Icon): string {
+    if (iconName) {
+      return IconSvg[iconName.toLowerCase()];
+    }
+  }
+
+  public setIconCache(): void {
+    for (const key in IconSvg) {
+      if (IconSvg.hasOwnProperty(key) && typeof IconSvg[key] !== "function") {
+        this._iconCache[key.toLowerCase()] = this._sanitizer.bypassSecurityTrustHtml(IconSvg[key]);
+      }
+    }
+  }
+}

package/projects/transaction/src/lib/service/options.service.ts

@@ -0,0 +1,66 @@
+import {Injectable} from "@angular/core";
+import {BehaviorSubject} from "rxjs";
+import {DictionaryService} from "./dictionary.service";
+
+@Injectable({
+  providedIn: "root"
+})
+export class OptionsService {
+
+  public optionsInitialized: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+
+  public set options(value: any) {
+    this._options = value;
+  }
+
+  public get options(): any {
+    return this._options;
+  }
+
+  public optionsLoaded: BehaviorSubject<boolean> = new BehaviorSubject(false);
+
+  private _options: any;
+
+  constructor(private _dictionary: DictionaryService) {
+  }
+
+  public async createSettingsFromObject(obj: any): Promise<void> {
+    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);
+  }
+
+  public async initialize(options: any): Promise<void> {
+    if (options) {
+      await this.createSettingsFromObject(options);
+      await this._dictionary.setDictionary(this.options.languageCode);
+      this.optionsInitialized.next(true);
+    }
+  }
+}

package/projects/transaction/src/lib/service/payment.service.ts

@@ -0,0 +1,93 @@
+import {Injectable} from "@angular/core";
+import {TransactionInfoResponse} from "@colijnit/transactionapi/build/model/transaction-info-response.bo";
+import {PaymentMethod} from "@colijnit/transactionapi/build/model/payment-method.bo";
+import {CreatePaymentLinkResult} from "@colijnit/transactionapi/build/model/create-payment-link-result.bo";
+import {TransactionService} from "./transaction.service";
+import {PaymentLinkStatus} from "@colijnit/transactionapi/build/model/payment-link-status.bo";
+import {TransactionConnectorAdapterService} from "./transaction-connector-adapter.service";
+import {SelectMultipleCacheService} from "../cache/service/select-multiple-cache.service";
+import {TransactionDownPaymentInfo} from "@colijnit/transactionapi/build/model/transaction-down-payment-info.bo";
+import {PaymentViewmodel} from "../model/payment.viewmodel";
+import {SharedService} from "./shared.service";
+import {DataServiceResponseData} from "@colijnit/ioneconnector/build/model/data-service-response-data";
+import {CoDocument} from "@colijnit/mainapi/build/model/co-document";
+
+@Injectable({
+  providedIn: "root"
+})
+export class PaymentService {
+
+  constructor(
+    private _adapterService: TransactionConnectorAdapterService,
+    private _selectMultipleCacheService: SelectMultipleCacheService,
+    private _transactionService: TransactionService,
+    private _sharedService: SharedService
+  ) {
+  }
+
+  public async updateHeaderTransactionToDownPay(uuid: string, downPayment: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this._adapterService.changeHeaderTransactionToDownPay(uuid, downPayment)
+      .catch((error) => {
+        // todo: do something with the error
+        return false;
+      });
+    if (response) {
+      const success: boolean = await this._transactionService.handleHeaderOperationStatuses(response);
+      this._transactionService.rememberCurrentTransaction(response);
+      return success;
+    }
+    return false;
+  }
+
+  public async registerSalesOrderPayment(
+    uuid: string, amount: number, currencyId: number, paymentMethod: string, cashRegisterGroupId: number
+  ): Promise<boolean> {
+    const response: DataServiceResponseData =
+      await this._adapterService.registerSalesOrderPayment(uuid, amount, currencyId, paymentMethod, cashRegisterGroupId);
+    if (response.validationResult.success) {
+      return true;
+    }
+    return false;
+  }
+
+  public async createIonePaymentLinkAndQRCode(uuid: string, amount: number, paymentMethodCode: string): Promise<CreatePaymentLinkResult> {
+    return this._adapterService.createIonePaymentLinkAndQRCode(uuid, amount, paymentMethodCode);
+  }
+
+  public async getPaymentLinkStatus(paymentLinkUUID: string): Promise<PaymentLinkStatus> {
+    return this._adapterService.getPaymentLinkStatus(paymentLinkUUID);
+  }
+
+  public async getDownPaymentInfo(uuid: string): Promise<TransactionDownPaymentInfo> {
+    return this._adapterService.getDownPaymentInfo(uuid);
+  }
+
+  public async getPaymentMethods(): Promise<PaymentMethod[]> {
+    return this._selectMultipleCacheService.requestCache<PaymentMethod>(PaymentMethod, () => {
+      return this._adapterService.getPaymentMethods()
+    }).getValue();
+  }
+
+  public async getPaymentMethodsViewModels(): Promise<PaymentViewmodel[]> {
+    const result: PaymentViewmodel[] = [];
+    const methods = await this.getPaymentMethods();
+    methods.forEach(async (m: PaymentMethod) => {
+      const paymentViewModel: PaymentViewmodel = new PaymentViewmodel(m);
+      const imageDocs: CoDocument[] = m.documents.filter(d => d.isImageDocument());
+      if (imageDocs && imageDocs.length) {
+        const image: CoDocument = imageDocs[0];
+        if (image.filePath) {
+          paymentViewModel.image = image.filePath;
+        } else {
+          if (!image.thumbnailBody) {
+            const content: string = await this._sharedService.getDocumentContent(image.documentId);
+            image.thumbnailBody = content;
+          }
+          paymentViewModel.image = image.thumbnailBodyAsDataUri;
+        }
+      }
+      result.push(paymentViewModel);
+    });
+    return result;
+  }
+}

package/projects/transaction/src/lib/service/pending-reason.service.ts

@@ -0,0 +1,323 @@
+import {Injectable} from "@angular/core";
+import {TransactionInfoResponse} from "@colijnit/transactionapi/build/model/transaction-info-response.bo";
+import {LineOperationStatus} from "@colijnit/transactionapi/build/model/line-operation-status.bo";
+import {PendingReasonType} from "@colijnit/transactionapi/build/enum/pending-reason-type.enum";
+import {TransactionLineInfo} from "@colijnit/transactionapi/build/model/transaction-line-info.bo";
+import {OptionsService} from "./options.service";
+import {TransactionConnectorService} from "./transaction-connector.service";
+import {BehaviorSubject, Subject} from "rxjs";
+import {TransactionLineType} from "@colijnit/transactionapi/build/enum/transaction-line-type.enum";
+import {DialogService} from "./dialog.service";
+import {ResolveLinePendingReasonRequest} from "@colijnit/transactionapi/build/model/resolve-pending-reason-request.bo";
+import {ArticleConnectorService} from "./article-connector.service";
+import {HeaderOperationStatus} from "@colijnit/transactionapi/build/model/header-operation-status.bo";
+import {ResolveHeaderPendingReasonRequest} from "@colijnit/transactionapi/build/model/resolve-header-pending-reason-request.bo";
+import {TransactionInfo} from "@colijnit/transactionapi/build/model/transaction-info.bo";
+import {TransactionLineCharacteristic} from "@colijnit/transactionapi/build/model/transactionLineCharacteristic.bo";
+import {PurchasePortalLine} from "@colijnit/transactionapi/build/model/purchase-portal-line.bo";
+import {DocDeliveryBatch} from "@colijnit/transactionapi/build/model/doc-delivery-batch.bo";
+import {DialogResponseInterface} from "../interface/dialog-response.interface";
+import {AppPopupButtonType} from "../component/core/enum/app-popup-button-type.enum";
+import {SharedService} from "@colijnit/sharedcomponents";
+import {DictionaryService} from "./dictionary.service";
+import {TransactionEventService} from "./transaction-event.service";
+import {CustomerFullObject} from "@colijnit/relationapi/build/model/customer-full-object.bo";
+import {ValidationResult} from "@colijnit/ioneconnector/build/model/validation-result";
+import {RelationStatus} from "@colijnit/articleapi/build/enum/relation-status.enum";
+import {RelationKind} from "@colijnit/articleapi/build/enum/relation-kind.enum";
+import {SupplierFullObject} from "@colijnit/relationapi/build/model/supplier-full-object.bo";
+import {RelationSmallObject} from "@colijnit/relationapi/build/model/relation-small-object.bo";
+import {TransactionKind} from "@colijnit/transactionapi/build/enum/transaction-kind.enum";
+import {RelationService} from "./relation.service";
+import {Relation} from "@colijnit/relationapi/build/model/relation.bo";
+
+@Injectable({
+  providedIn: "root"
+})
+export class PendingReasonService {
+  public logout: Subject<void> = new Subject<void>();
+  public transactionUpdated: BehaviorSubject<TransactionInfoResponse> = new BehaviorSubject<TransactionInfoResponse>(undefined);
+  public relationUpdated: BehaviorSubject<Relation> = new BehaviorSubject<Relation>(undefined);
+
+  public applicationUser: boolean = false;
+  public invoiceAddressSameAsDelivery: boolean = true;
+
+  public transactionKind: TransactionKind = TransactionKind.SalesOrder;
+
+  public currentTransaction: TransactionInfoResponse = new TransactionInfoResponse();
+
+  public set relation(value: Relation) {
+    if (value) {
+      this._relation = value;
+      this.relationUpdated.next(this._relation);
+    }
+  }
+  public get relation(): Relation {
+    return this._relation;
+  }
+  public purchasePortalLine: PurchasePortalLine[] = [];
+  public docDeliveryBatch: DocDeliveryBatch = new DocDeliveryBatch()
+
+  public articleAmount: number = 0;
+
+  private _relation: Relation = new Relation();
+
+  constructor(
+    public options: OptionsService,
+    protected dialogService: DialogService,
+    protected connector: TransactionConnectorService,
+    protected sharedService: SharedService,
+    protected articleConnector: ArticleConnectorService,
+    protected dictionaryService: DictionaryService,
+    protected transactionEventService: TransactionEventService,
+    protected relationService: RelationService
+  ) {
+  }
+
+  public async init(options: any): Promise<void> {
+    await this.options.initialize(options);
+    this.sharedService.init(options);
+    this.connector.connect();
+    this.transactionEventService.connectionInitialized.next(true);
+  }
+
+  public resetCurrentTransaction(): void {
+    this.currentTransaction = new TransactionInfoResponse();
+    this._relation = new CustomerFullObject();
+    this.articleAmount = 0;
+  }
+
+  public commit(): Promise<boolean> {
+    return this.connector.commit();
+  }
+
+  public rollback(): Promise<boolean> {
+    return this.connector.rollback();
+  }
+
+  public async cancelAddTransactionLine(lineUuid: string, remember: boolean = true): Promise<TransactionInfoResponse> {
+    return new Promise<TransactionInfoResponse>((resolve, reject) => {
+      this.connector.cancelAddTransactionLine(lineUuid)
+        .then(async (response: TransactionInfoResponse) => {
+          if (remember) {
+            this.rememberCurrentTransaction(response);
+          }
+          if (response.isSuccess) {
+            resolve(response);
+          } else {
+            reject(response);
+          }
+        })
+        .catch((reason: ValidationResult) => {
+          resolve(null);
+        });
+    });
+  }
+
+  public async handleHeaderOperationStatuses(response: TransactionInfoResponse): Promise<boolean> {
+    if (!response.headerOperationStatuses || response.headerOperationStatuses.length === 0) {
+      return this._saveTransactionAndCommit();
+    }
+    let success: boolean = true;
+    for (let i: number = 0; i < response.headerOperationStatuses.length; i++) {
+      const status: HeaderOperationStatus = response.headerOperationStatuses[i];
+      success = success && await this._handleHeaderOperationStatus(status, response.transactionInfo);
+    }
+    const hasPendingReasons: boolean = response.headerOperationStatuses.filter(los => los.pendingReason !== "NONE").length > 0;
+    if (!hasPendingReasons) {
+      return this._saveTransactionAndCommit();
+    }
+    return success;
+  }
+
+  public async saveTransaction(): Promise<TransactionInfoResponse> {
+    const response: TransactionInfoResponse = await this.connector.saveTransaction(this.currentTransaction.transactionInfo.uuid)
+    if (response && response.isSuccess) {
+      this.rememberCurrentTransaction(response);
+    }
+    return response;
+  }
+
+  public async rememberCurrentTransaction(value: TransactionInfoResponse): Promise<void> {
+    // if (value && value.transactionLines) {
+    //   value.transactionLines.sort((a, b) => a.lineNr < b.lineNr ? -1 : 1);
+    // }
+    this.currentTransaction = value;
+    this._setAmount();
+    if (this.currentTransaction.transactionInfo.relation && this.currentTransaction.transactionInfo.relation.relationId && !this.relation.relationId) {
+      this._getRelation(this.currentTransaction.transactionInfo.relation);
+    }
+
+    this.transactionUpdated.next(this.currentTransaction);
+  }
+
+  protected initializeTransaction(): void {
+    if (!this.relation) {
+      this.relation = new CustomerFullObject();
+    }
+    if (!this.relation.relationId) {
+      if (this.relation.relationType === RelationKind.Customer) {
+        (this.relation as CustomerFullObject).relationStatus = RelationStatus.RegularCustomer;
+      }
+      this.relation.startDate = new Date();
+    }
+    if (this.currentTransaction.transactionInfo.preferredDeliveryDate2 === undefined) {
+      this.currentTransaction.transactionInfo.preferredDeliveryDate2 = "=";
+    }
+  }
+
+  protected async handleLineOperationStatuses(response: TransactionInfoResponse): Promise<boolean> {
+    if (!response.lineOperationStatuses || response.lineOperationStatuses.length === 0) {
+      return this._saveTransactionAndCommit();
+    }
+    let success: boolean = true;
+    for (let i: number = 0; i < response.lineOperationStatuses.length; i++) {
+      const status: LineOperationStatus = response.lineOperationStatuses[i];
+      const transLine: TransactionLineInfo = response.transactionLines.find(t => t.lineNr === status.lineNr);
+      success = success && await this._handleLineOperationStatus(status, transLine);
+    }
+    const hasPendingReasons: boolean = response.lineOperationStatuses.filter(los => los.pendingReason !== "NONE").length > 0;
+    if (!hasPendingReasons) {
+      return this._saveTransactionAndCommit();
+    }
+    return success;
+  }
+
+  private async _saveTransactionAndCommit(): Promise<boolean> {
+    // we can safely save/commit the changes
+    const response: TransactionInfoResponse = await this.saveTransaction();
+    // we need to do an extra commit to release the lock
+    const commitSuccess: boolean = await this.commit();
+    return response && response.isSuccess && commitSuccess;
+  }
+
+  private async _handleLineOperationStatus(operationStatus: LineOperationStatus, transactionLine: TransactionLineInfo): Promise<boolean> {
+    switch (operationStatus.pendingReasonType) {
+      case PendingReasonType.ABORTED:
+      case PendingReasonType.CANCELLED:
+        if (operationStatus.pendingReason !== 'USER_DECISION') {
+        //   await this._cancelArticle(operationStatus.uuid);
+        // } else {
+          this._showReasonDialog(operationStatus.pendingReason);
+        }
+        return false;
+      case PendingReasonType.CONFIRMATION_NEEDED:
+        await this._confirmAction(transactionLine.uuid, operationStatus.pendingReason, operationStatus.pendingReasonType);
+        return true;
+      case PendingReasonType.INVALID_LOGISTICS:
+        await this._showWarehouseCcDialog(
+          operationStatus.uuid, transactionLine.amount, transactionLine.commissionCode, transactionLine.warehouseNumber,
+          operationStatus.pendingReason, operationStatus.pendingReasonType);
+        return true;
+      case PendingReasonType.NON_CRITICAL_DISCONTINUATION:
+        this._showReasonDialog(operationStatus.pendingReason);
+        return true;
+      case PendingReasonType.CHARACTERISTICS_ANSWER_NEEDED:
+        this._showCharacteristicDialog(operationStatus.uuid, operationStatus.characteristic, operationStatus.pendingReason, operationStatus.pendingReasonType);
+        return true;
+      case PendingReasonType.NONE:
+      default:
+        return true;
+    }
+  }
+
+  private async _handleHeaderOperationStatus(operationStatus: HeaderOperationStatus, transactionInfo: TransactionInfo): Promise<boolean> {
+    switch (operationStatus.pendingReasonType) {
+      case PendingReasonType.ABORTED:
+      case PendingReasonType.CANCELLED:
+        await this._showReasonDialog(operationStatus.pendingReason);
+        return false;
+      case PendingReasonType.CONFIRMATION_NEEDED:
+        return await this._confirmHeaderAction(transactionInfo.uuid, operationStatus.pendingReason, operationStatus.pendingReasonType);
+      case PendingReasonType.NONE:
+      default:
+        return true;
+    }
+  }
+
+  public async resolvePendingLineReason(pendingLineValues: ResolveLinePendingReasonRequest): Promise<void> {
+    const response: TransactionInfoResponse = await this.connector.resolvePendingLineReason(pendingLineValues);
+    // this.rememberCurrentTransaction(response);
+    this.handleLineOperationStatuses(response);
+  }
+
+  public async resolvePendingHeaderReason(pendingHeaderValues: ResolveHeaderPendingReasonRequest): Promise<boolean> {
+    const response: TransactionInfoResponse = await this.connector.resolvePendingHeaderReason(pendingHeaderValues);
+    // this.rememberCurrentTransaction(response);
+    return this.handleHeaderOperationStatuses(response);
+  }
+
+  private async _confirmAction(uuid: string, reason: string, type: PendingReasonType): Promise<void> {
+    const reasonRequest = new ResolveLinePendingReasonRequest(uuid, reason, type);
+    // const pendingReasonText: string = await this._getPendingReasonText(this.currentOperationStatus.pendingReason);
+    reasonRequest.confirmation = await this.dialogService.showYesNo('Action', reason);
+    await this.resolvePendingLineReason(reasonRequest);
+    // this._handleLineOperationStatus()
+  }
+
+  private async _showCharacteristicDialog(uuid: string, characteristics: TransactionLineCharacteristic, reason: string, type: PendingReasonType): Promise<void> {
+    const reasonRequest = new ResolveLinePendingReasonRequest(uuid, reason, type);
+    let char: string;
+    const response: DialogResponseInterface = await this.dialogService.showCharacteristics(
+      characteristics.question, characteristics.transactionLineCharacteristicChoices, characteristics.value);
+    if (response.button === AppPopupButtonType.Ok) {
+      char = response.output;
+    }
+    reasonRequest.textualUserInput = char;
+    await this.resolvePendingLineReason(reasonRequest);
+  }
+
+  private async _showWarehouseCcDialog(uuid: string, quantity: number, commissionCode: string, warehouseNr: number, reason: string, type: PendingReasonType): Promise<void> {
+    const reasonRequest = new ResolveLinePendingReasonRequest(uuid, reason, type);
+    const response: DialogResponseInterface = await this.dialogService.showWarehouseCC(quantity, commissionCode, warehouseNr);
+    if (response.button === AppPopupButtonType.Ok) {
+      reasonRequest.quantity = response.output.quantity;
+      reasonRequest.commissionCode = response.output.commissionCode;
+      reasonRequest.warehouseNr = response.output.warehouseNr;
+      await this.resolvePendingLineReason(reasonRequest);
+    } else {
+      this._cancelArticle(uuid);
+    }
+  }
+
+  private async _confirmHeaderAction(uuid: string, reason: string, type: PendingReasonType): Promise<boolean> {
+    const reasonRequest = new ResolveHeaderPendingReasonRequest(uuid, reason, type);
+    // const pendingReasonText: string = await this._getPendingReasonText(this.currentOperationStatus.pendingReason);
+    reasonRequest.confirmation = await this.dialogService.showYesNo('Action', reason);
+    return await this.resolvePendingHeaderReason(reasonRequest);
+  }
+
+  private async _showReasonDialog(reason: string): Promise<void> {
+    return this.dialogService.showInformation(reason);
+  }
+
+  private _setAmount(): void {
+    if (this.currentTransaction && this.currentTransaction.transactionLines) {
+      this.articleAmount = this.currentTransaction.transactionLines.filter(t => t.lineType === TransactionLineType.ArticleLine).length;
+    }
+  }
+
+  private async _cancelArticle(uuid: string): Promise<void> {
+    await this.cancelAddTransactionLine(uuid, false)
+      .then((response: TransactionInfoResponse) => {
+          this.rememberCurrentTransaction(response);
+        }
+      );
+  }
+
+  private _getRelation(relation: RelationSmallObject): void {
+    if (relation) {
+      this.relationService.getRelationNumber(relation.relationId).then((relationNr: string) => {
+        if (relation.relationType === RelationKind.Customer) {
+          this.relationService.getCustomerFullObject(parseInt(relationNr, 0)).then((customer: CustomerFullObject) => {
+            this.relation = customer;
+          });
+        } else if (relation.relationType === RelationKind.Supplier) {
+          this.relationService.getSupplierFullObject(parseInt(relationNr, 0)).then((supplier: SupplierFullObject) => {
+            this.relation = supplier;
+          });
+        }
+      });
+    }
+  }
+}