@colijnit/transaction 261.20.51 → 261.20.52

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

@@ -0,0 +1,3336 @@
+import {Injectable} from '@angular/core';
+import {DiscountType} from '@colijnit/transactionapi/build/enum/discount-type.enum';
+import {SequenceName} from '@colijnit/transactionapi/build/enum/sequence-name.enum';
+import {ArticleFullObject} from '@colijnit/transactionapi/build/model/article-full-object';
+import {CashRegister} from '@colijnit/transactionapi/build/model/cash-register';
+import {CashOnDeliveryData} from '@colijnit/transactionapi/build/model/cash-on-delivery-data';
+import {ChangeHeaderCashOnDeliveryAmountRequest} from '@colijnit/transactionapi/build/model/change-header-cash-on-delivery-amount-request';
+import {CodeDescription} from '@colijnit/transactionapi/build/model/code-description';
+import {Country} from '@colijnit/transactionapi/build/model/country.bo';
+import {CustomerGroup} from '@colijnit/transactionapi/build/model/customer-group.bo';
+import {DeliveryMethod} from '@colijnit/transactionapi/build/model/delivery-method.bo';
+import {DeliveryOption} from '@colijnit/transactionapi/build/model/delivery-option.bo';
+import {Marketing} from '@colijnit/transactionapi/build/model/marketing.bo';
+import {OnHoldCode} from '@colijnit/transactionapi/build/model/on-hold-code.bo';
+import {PriceList} from '@colijnit/transactionapi/build/model/price-list';
+import {TransactionArticleWarehouse} from '@colijnit/transactionapi/build/model/transaction-article-warehouse.bo';
+import {TransactionInfoResponse} from '@colijnit/transactionapi/build/model/transaction-info-response.bo';
+import {TransactionLineInfo} from '@colijnit/transactionapi/build/model/transaction-line-info.bo';
+import {ValidationResult} from '@colijnit/ioneconnector/build/model/validation-result';
+import {Vat} from '@colijnit/transactionapi/build/model/vat';
+import {Warehouse} from '@colijnit/transactionapi/build/model/warehouse.bo';
+import {throwError} from 'rxjs';
+import {StandardText} from '../model/standard-text';
+import {PendingReasonService} from './pending-reason.service';
+import {ReceiveGoodsForOrderRequest} from '@colijnit/transactionapi/build/model/receive-goods-for-order-request.bo';
+import {ReceiveGoodsForPurchaseOrderCorrectionRequest} from '@colijnit/transactionapi/build/model/receive-goods-for-purchase-order-correction-request.bo';
+import {ArticleExtendedRequest} from '@colijnit/articleapi/build/model/article-extended-request';
+import {ArticleLight} from '@colijnit/articleapi/build/model/article-light.bo';
+import {TurnoverGroupImage} from '@colijnit/articleapi/build/model/turnover-group-image.bo';
+import {MainArticle} from '@colijnit/articleapi/build/model/main-article.bo';
+import {PurchasePortalLine} from '@colijnit/transactionapi/build/model/purchase-portal-line.bo';
+import {GetPurchaseOrderConfirmation} from '@colijnit/transactionapi/build/model/get-purchase-order-confirmation';
+import {Tag} from '@colijnit/mainapi/build/model/tag';
+import {CoDomainValue} from '@colijnit/mainapi/build/model/co-domain-value.bo';
+import {RelationPrivacySetting} from '@colijnit/relationapi/build/model/relation-privacy-setting.bo';
+import {SalesPerson} from '@colijnit/relationapi/build/model/sales-person.bo';
+import {AvailableStock} from '@colijnit/transactionapi/build/model/available-stock.bo';
+import {AllocateGoodsForSalesOrderRequest} from '@colijnit/transactionapi/build/model/allocate-goods-for-sales-order-request';
+import {AllocateGoodsForSalesOrderCorrectionRequest} from '@colijnit/transactionapi/build/model/allocate-goods-for-sales-order-correction-request';
+import {ReportLayoutSelectionEmail} from '@colijnit/mainapi/build/model/report-layout-selection-email.bo';
+import {ReportLayoutSelectionPrint} from '@colijnit/mainapi/build/model/report-layout-selection-print.bo';
+import {CreateSalesOrderRequest} from '@colijnit/transactionapi/build/model/create-sales-order-request';
+import {CreateCashRegisterOrderRequest} from '@colijnit/transactionapi/build/model/create-cash-register-order-request';
+import {CreatePurchaseOrderRequest} from '@colijnit/transactionapi/build/model/create-purchase-order-request';
+import {CreateServiceOrderRequest} from '@colijnit/transactionapi/build/model/create-service-order-request';
+import {CreateSalesQuotationRequest} from '@colijnit/transactionapi/build/model/create-sales-quotation-request';
+import {TransactionKind} from '@colijnit/transactionapi/build/enum/transaction-kind.enum';
+import {CreateTransactionRequest} from '@colijnit/transactionapi/build/model/create-transaction-request';
+import {RelationKind} from '@colijnit/articleapi/build/enum/relation-kind.enum';
+import {PurchaseAdviceLine} from '@colijnit/transactionapi/build/model/purchase-advice-line.bo';
+import {PurchaseAdviceFilters} from '@colijnit/transactionapi/build/model/purchase-advice-filters';
+import {EmailDeliveryNoteRequest} from '@colijnit/transactionapi/build/model/email-delivery-note-request';
+import {PdfDeliveryNoteRequest} from '@colijnit/transactionapi/build/model/pdf-delivery-note-request';
+import {PrintDeliveryNoteRequest} from '@colijnit/transactionapi/build/model/print-delivery-note-request';
+import {PrintDeliveryNotesRequest} from '@colijnit/transactionapi/build/model/print-delivery-notes-request';
+import {TransactionTypeCategory} from '../enum/transaction-type-category.enum';
+import {EmailInvoiceRequest} from '@colijnit/transactionapi/build/model/email-invoice-request';
+import {PdfInvoiceRequest} from '@colijnit/transactionapi/build/model/pdf-invoice-request';
+import {PrintInvoiceRequest} from '@colijnit/transactionapi/build/model/print-invoice-request';
+import {DialogResponseInterface} from '../interface/dialog-response.interface';
+import {AppPopupButtonType} from '../component/core/enum/app-popup-button-type.enum';
+import {PurchaseOrderLineReceiptDetails} from '@colijnit/transactionapi/build/model/purchase-order-line-receipt-details.bo';
+import {SalesOrderLineAllocationDetails} from '@colijnit/transactionapi/build/model/sales-order-line-allocation-details';
+import {TagTreeItem} from '@colijnit/mainapi/build/model/tag-tree-item.bo';
+import {GoodsReceiptHistory} from '@colijnit/transactionapi/build/model/goods-receipt-history.bo';
+import {GoodsAllocationHistory} from '@colijnit/transactionapi/build/model/goods-allocation-history.bo';
+import {TransactionInfoHistory} from '@colijnit/transactionapi/build/model/transaction-info-history.bo';
+import {LayoutCode} from '@colijnit/transactionapi/build/enum/layout-code.enum';
+import {HistoricReport} from '@colijnit/transactionapi/build/model/historic-report.bo';
+import {Printer} from '@colijnit/mainapi/build/model/printer.bo';
+import {Currency} from '@colijnit/mainapi/build/model/currency.bo';
+import {PaymentCondition} from '@colijnit/mainapi/build/model/payment-condition.bo';
+import {GoodsToBePickedForOrderRequest} from '@colijnit/transactionapi/build/model/goods-to-be-picked-for-order-request';
+import {GoodsToBePickedForOrderRequestLine} from '@colijnit/transactionapi/build/model/goods-to-be-picked-for-order-request-line';
+import {WarehouseStockInfo} from '@colijnit/transactionapi/build/model/warehouse-stock-info.bo';
+import {GoodsToBePickedHistory} from '@colijnit/transactionapi/build/model/goods-to-be-picked-history';
+import {GoodsPickedHistory} from '@colijnit/transactionapi/build/model/goods-picked-history';
+import {PurchaseHistory} from '@colijnit/transactionapi/build/model/purchase-history';
+import {PdfHistoricDeliveryNoteRequest} from '@colijnit/transactionapi/build/model/pdf-historic-delivery-note-request';
+import {EmailHistoricDeliveryNoteRequest} from '@colijnit/transactionapi/build/model/email-historic-delivery-note-request';
+import {PrintHistoricDeliveryNoteRequest} from '@colijnit/transactionapi/build/model/print-historic-delivery-note-request';
+import {BatchTransactionSendingRequest} from '@colijnit/transactionapi/build/model/batch-transaction-sending-request';
+import {BatchJobProgress} from '@colijnit/transactionapi/build/model/batch-job-progress.bo';
+import {EmailHistoricOrderConfirmationRequest} from '@colijnit/transactionapi/build/model/email-historic-order-confirmation-request';
+import {PdfHistoricInvoiceRequest} from '@colijnit/transactionapi/build/model/pdf-historic-invoice-request';
+import {PrintHistoricInvoiceRequest} from '@colijnit/transactionapi/build/model/print-historic-invoice-request';
+import {EmailHistoricInvoiceRequest} from '@colijnit/transactionapi/build/model/email-historic-invoice-request';
+import {PrintOrderConfirmationRequest} from '@colijnit/transactionapi/build/model/print-order-confirmation-request';
+import {PrintPurchaseOrderRequest} from '@colijnit/transactionapi/build/model/print-purchase-order-request';
+import {PdfPurchaseOrderRequest} from '@colijnit/transactionapi/build/model/pdf-purchase-order-request';
+import {PdfOrderConfirmationRequest} from '@colijnit/transactionapi/build/model/pdf-order-confirmation-request';
+import {EmailOrderConfirmationRequest} from '@colijnit/transactionapi/build/model/email-order-confirmation-request';
+import {EmailPurchaseOrderRequest} from '@colijnit/transactionapi/build/model/email-purchase-order-request';
+import {ObjectConfiguration} from '@colijnit/ioneconnector/build/model/object-configuration';
+import {CoDocument} from '@colijnit/mainapi/build/model/co-document.bo';
+import {GoodsPickedRequest} from '@colijnit/transactionapi/build/model/goods-picked-request';
+import {GoodsPickedRequestLine} from '@colijnit/transactionapi/build/model/goods-picked-request-line';
+import {DeleteGoodsPickedForOrderRequest} from '@colijnit/transactionapi/build/model/delete-goods-picked-for-order-request';
+import {DeleteGoodsToBePickedForOrderRequest} from '@colijnit/transactionapi/build/model/delete-goods-to-be-picked-for-order-request';
+import {CashDrawersRequest} from '@colijnit/transactionapi/build/model/cash-drawers-request';
+import {CashDrawer} from '@colijnit/transactionapi/build/model/cash-drawer.bo';
+import {PrintPosReceiptRequest} from '@colijnit/transactionapi/build/model/print-pos-receipt-request';
+import {PrintHistoricPosReceiptRequest} from '@colijnit/transactionapi/build/model/print-historic-pos-receipt-request';
+import {EmailPosReceiptRequest} from '@colijnit/transactionapi/build/model/email-pos-receipt-request';
+import {EmailHistoricPosReceiptRequest} from '@colijnit/transactionapi/build/model/email-historic-pos-receipt-request';
+import {TagCategory} from '@colijnit/mainapi/build/enum/tab-category.enum';
+import {EmailQuotationRequest} from '@colijnit/transactionapi/build/model/email-quotation-request';
+import {EmailHistoricQuotationRequest} from '@colijnit/transactionapi/build/model/email-historic-quotation-request';
+import {PdfQuotationRequest} from '@colijnit/transactionapi/build/model/pdf-quotation-request';
+import {PdfHistoricQuotationRequest} from '@colijnit/transactionapi/build/model/pdf-historic-quotation-request';
+import {PrintQuotationRequest} from '@colijnit/transactionapi/build/model/print-quotation-request';
+import {PrintHistoricQuotationRequest} from '@colijnit/transactionapi/build/model/print-historic-quotation-request';
+import {ChangeHeaderScoringChanceRequest} from '@colijnit/transactionapi/build/model/change-header-scoring-chance-request';
+import {ChangeHeaderExpectedScoringDateRequest} from '@colijnit/transactionapi/build/model/change-header-expected-scoring-date-request';
+import {ChangeHeaderRetailStadiumRequest} from '@colijnit/transactionapi/build/model/change-header-retail-stadium-request';
+import {RetailStadium} from '@colijnit/transactionapi/build/model/retail-stadium.bo';
+import {WorkFlowStatusName} from '@colijnit/transactionapi/build/model/workflow-status-name.bo';
+import {ArticleFlatTreeDTO} from '@colijnit/articleapi/build/model/article-flat-tree.bo';
+import {BusinessObjectFactory} from '@colijnit/ioneconnector/build/service/business-object-factory';
+import {ChangeLineQuantitySelectedLineRequest} from '@colijnit/transactionapi/build/model/change-line-quantity-selected-line-request';
+import {ExternalCatalogAddArticleRequest} from '@colijnit/transactionapi/build/model/external-catalog-add-article-request';
+import {OrderLineSetCategory} from '@colijnit/mainapi/build/model/order-line-set-category.bo';
+import {OrderLineSetDTO} from '@colijnit/transactionapi/build/model/order-line-set-dto';
+import {TransactionAddOrderLineSetTextLineRequest} from '@colijnit/transactionapi/build/model/transaction-add-order-line-set-text-line-request';
+import {TransactionSearchViewRequest} from '@colijnit/transactionapi/build/model/transaction-search-view-request';
+import {ArticleExtended} from '@colijnit/articleapi/build/model/article-extended.bo';
+import {CauseCode} from '@colijnit/transactionapi/build/model/cause-code.bo';
+import {PdfPosReceiptRequest} from '@colijnit/transactionapi/build/model/pdf-pos-receipt-request';
+import {OrderConfirmationTransactionLink} from '@colijnit/transactionapi/build/model/order-confirmation-transaction-link.bo';
+import {PdfPosReceiptResponse} from '@colijnit/transactionapi/build/model/pdf-pos-receipt-response.bo';
+import {ProjectCode} from '@colijnit/transactionapi/build/model/project-code.bo';
+import {CashType} from '@colijnit/transactionapi/build/model/cash-type.bo';
+import {PosGroup} from '@colijnit/transactionapi/build/model/pos-group.bo';
+import {PdfTransactionSearchOverviewResponse} from '@colijnit/transactionapi/build/model/pdf-transaction-search-overview-response';
+import {Activity} from '@colijnit/mainapi/build/model/activity.bo';
+import {TransactionMarginInfo} from '@colijnit/transactionapi/build/model/transaction-margin-info.bo';
+// import {
+//   TransactionLspInformationRequest
+// } from "@colijnit/transactionapi/build/model/transaction-lsp-information.request";
+// import {PackageLSP} from "@colijnit/transactionapi/build/model/package-lsp.bo";
+import {DataServiceResponseData} from '@colijnit/ioneconnector/build/model/data-service-response-data';
+import {OrderLinesPlannedRequest} from '@colijnit/transactionapi/build/model/order-lines-planned-request.bo';
+import {PlanOrderLine} from '@colijnit/transactionapi/build/model/plan-order-line.bo';
+import {PlanOrder} from '@colijnit/transactionapi/build/model/plan-order.bo';
+import {SupplierArticleStockForecast} from '@colijnit/transactionapi/build/model/supplier-article-stock-forecast';
+import {ServiceWizard} from '@colijnit/transactionapi/build/model/service-wizard';
+import {ChangeServiceHeaderReportMessageRequest} from '@colijnit/transactionapi/build/model/change-service-header-report-message-request';
+import {CreateServiceOrderWithSourceTransactionLineRequest} from '@colijnit/transactionapi/build/model/create-service-order-with-source-transaction-line-request';
+import {ServiceType} from '@colijnit/transactionapi/build/model/service-type';
+import {OrderReservationSalesOrderLinesRequest} from '@colijnit/transactionapi/build/model/order-reservation-sales-order-lines-request.bo';
+import {PurchaseReservation} from '@colijnit/transactionapi/build/model/purchase-reservation.bo';
+import {ProcessOrderReservationRequest} from '@colijnit/transactionapi/build/model/process-order-reservation-request.bo';
+import {RelationSmallObject} from '@colijnit/mainapi/build/model/relation-small-object.bo';
+import {AddHeaderImageRequest} from '@colijnit/transactionapi/build/model/add-header-image-request';
+import {DeleteHeaderImageRequest} from '@colijnit/transactionapi/build/model/delete-header-image-request';
+import {ChangeServiceHeaderCauseCodeRequest} from '@colijnit/transactionapi/build/model/change-service-headercause-code-request';
+import {ChangeServiceHeaderPriorityRequest} from '@colijnit/transactionapi/build/model/change-service-header-priority-request';
+import {ChangeServiceHeaderEntryTypeRequest} from '@colijnit/transactionapi/build/model/change-service-header-entry-type-request';
+import {TransactionLineSearchIndex} from '@colijnit/transactionapi/build/model/transaction-line-search-index.bo';
+import {ChangeServiceHeaderServiceTypeRequest} from '@colijnit/transactionapi/build/model/change-service-header-service-type-request';
+import {ChangeServiceHeaderWizardDataRequest} from '@colijnit/transactionapi/build/model/change-service-header-wizard-data-request';
+import {TransactionInfo} from '@colijnit/transactionapi/build/model/transaction-info.bo';
+import {SLAProduct} from '@colijnit/transactionapi/build/model/SLA-product';
+import {TransactionDeliveryCostLineInfo} from '@colijnit/transactionapi/build/model/transaction-delivery-cost-line-info.bo';
+import {TransactionLineCopyRequest} from '@colijnit/transactionapi/build/model/transaction-line-copy-request.bo';
+import {ReportingPdfBaseResponse} from '@colijnit/transactionapi/build/model/reporting-pdf-base-response.bo';
+import {PlanTimes} from '@colijnit/transactionapi/build/model/plan-times.bo';
+import {PackageLSP} from '@colijnit/transactionapi/build/model/package-lsp.bo';
+import {SupplierProduct} from '@colijnit/transactionapi/build/model/supplier-product.bo';
+import {GetDocsToSignForTransRequest} from '@colijnit/transactionapi/build/model/get-docs-to-sign-for-trans-request.bo';
+import {ReportListObject} from '@colijnit/transactionapi/build/model/report-list-object';
+import {PlannedResourceForTransactionLine} from '@colijnit/transactionapi/build/model/planned-resource-for-transaction-line.bo';
+import {PrintPackageStickerRequest} from '@colijnit/transactionapi/build/model/print-package-sticker-request.bo';
+import {PdfPackageStickerRequest} from '@colijnit/transactionapi/build/model/pdf-package-sticker-request.bo';
+import {PurchaseInfo} from '@colijnit/transactionapi/build/model/purchase-info';
+import {InternalDefault} from '@colijnit/mainapi/build/enum/internal-default.enum';
+import {Voucher} from '@colijnit/transactionapi/build/model/voucher.bo';
+import {UserRoleType} from '@colijnit/ioneconnector/build/enum/user-role-type.enum';
+import {AddExpenseToCashRegisterOrderRequest} from '@colijnit/transactionapi/build/model/add-expense-to-cash-register-order-request';
+import {AddReceiptToCashRegisterOrderRequest} from '@colijnit/transactionapi/build/model/add-receipt-to-cash-register-order-request';
+import {GeneratePurchaseOrdersForDirectSellSalesOrdersRequest} from '@colijnit/transactionapi/build/model/generate-purchase-orders-for-direct-sell-sales-orders-request';
+import {PrintReservationStickerRequest} from '@colijnit/transactionapi/build/model/print-reservation-sticker-request';
+import {PdfReservationStickerRequest} from '@colijnit/transactionapi/build/model/pdf-reservation-sticker-request';
+import {PrintOrderingStickerRequest} from '@colijnit/transactionapi/build/model/print-ordering-sticker-request';
+import {PdfOrderingStickerRequest} from '@colijnit/transactionapi/build/model/pdf-ordering-sticker-request';
+import {PrintServiceOrderRequest} from '@colijnit/transactionapi/build/model/print-service-order-request';
+import {EmailServiceOrderRequest} from '@colijnit/transactionapi/build/model/email-service-order-request';
+import {PdfServiceOrderRequest} from '@colijnit/transactionapi/build/model/pdf-service-order-request';
+import {PrintHistoricServiceOrderRequest} from '@colijnit/transactionapi/build/model/print-historic-service-order-request';
+import {EmailHistoricServiceOrderRequest} from '@colijnit/transactionapi/build/model/email-historic-service-order-request';
+import {PdfHistoricServiceOrderRequest} from '@colijnit/transactionapi/build/model/pdf-historic-service-order-request';
+import {District} from '@colijnit/transactionapi/build/model/district.bo';
+import {GenerateAndSendPurchaseOrdersRequest} from '@colijnit/transactionapi/build/model/generate-and-send-purchase-orders-request';
+import {ChangeHeaderRelationTransactionDateRequest} from '@colijnit/transactionapi/build/model/change-header-relation-transaction-date-request';
+import {PrintPurchaseOrderForTransactionRequest} from '@colijnit/mainapi/build/model/print-purchase-order-for-transaction-request';
+import {PrintLspPackageInfoRequest} from '@colijnit/transactionapi/build/model/print-lsp-package-info-request.bo';
+import {DropshipmentInfo} from '@colijnit/transactionapi/build/model/dropshipment-info';
+import {ChangeHeaderDropshipmentInfoRequest} from '@colijnit/transactionapi/build/model/change-header-dropshipment-info-request';
+import {GetRouteDepartureRequest} from '@colijnit/transactionapi/build/model/get-route-departure-request';
+import {InterBranchFilters} from '@colijnit/transactionapi/build/model/inter-branch-filters';
+import {StockReplenishment} from '@colijnit/transactionapi/build/model/stock-replenishment.bo';
+import {ChangeHeadersTransactionsDefinitiveRequest} from '@colijnit/transactionapi/build/model/change-headers-transactions-definitive-request';
+
+import {TransportNotificationInfo} from '@colijnit/transactionapi/build/model/transport-notification-info';
+import {TransportNotificationTotals} from '@colijnit/transactionapi/build/model/transport-notification-totals';
+import {Container} from '@colijnit/mainapi/build/model/container.bo';
+import {ContainerInfo} from '@colijnit/mainapi/build/model/container-info.bo';
+import {ContainerType} from '@colijnit/mainapi/build/model/container-type.bo';
+import {TransportNotificationLineSelectRequest} from '@colijnit/transactionapi/build/model/transport-notification-line-select-request';
+import {SetTransportNotificationOnSelectedLinesRequest} from '@colijnit/transactionapi/build/model/set-transport-notification-on-selected-lines-request';
+import {RenewTransportNotificationOnSelectedLinesRequest} from '@colijnit/transactionapi/build/model/renew-transport-notification-on-selected-lines-request';
+import {SetTransportNotificationLineRequest} from '@colijnit/transactionapi/build/model/set-transport-notification-line-request';
+import {SetTransportNotificationInContainerOnSelectedLinesRequest} from '@colijnit/transactionapi/build/model/set-transport-notification-in-container-on-selected-lines-request';
+import {SetTransportNotificationLineInContainerRequest} from '@colijnit/transactionapi/build/model/set-transport-notification-line-in-container-request';
+import {TableName} from '@colijnit/mainapi/build/enum/table-name.enum';
+import {ContactMoment} from '@colijnit/transactionapi/build/model/contact-moment.bo';
+import {MergeContactMomentsRequest} from '@colijnit/transactionapi/build/model/merge-contact-moments-request';
+import {
+  PdfHistoricPurchaseOrderRequest
+} from '@colijnit/transactionapi/build/model/pdf-historic-purchase-order-request';
+import {
+  PrintHistoricPurchaseOrderRequest
+} from '@colijnit/transactionapi/build/model/print-historic-purchase-order-request';
+import {
+  EmailHistoricPurchaseOrderRequest
+} from '@colijnit/transactionapi/build/model/email-historic-purchase-order-request';
+import {PrintWorkOrderRequest} from '@colijnit/transactionapi/build/model/print-work-order-request';
+import {PrintHistoricWorkOrderRequest} from '@colijnit/transactionapi/build/model/print-historic-work-order-request';
+import {EmailWorkOrderRequest} from '@colijnit/transactionapi/build/model/email-work-order-request';
+import {EmailHistoricWorkOrderRequest} from '@colijnit/transactionapi/build/model/email-historic-work-order-request';
+import {PdfWorkOrderRequest} from '@colijnit/transactionapi/build/model/pdf-work-order-request';
+import {PdfWorkOrderResponse} from '@colijnit/transactionapi/build/model/pdf-work-order-response.bo';
+import {PdfHistoricWorkOrderRequest} from '@colijnit/transactionapi/build/model/pdf-historic-work-order-request';
+import {PdfHistoricWorkOrderResponse} from '@colijnit/transactionapi/build/model/pdf-historic-work-order-response.bo';
+import {TransactionLspInformationRequest} from '@colijnit/transactionapi/build/model/transaction-lsp-information-request';
+import {LspWmsDeliveryNotePrintRequest} from '@colijnit/transactionapi/build/model/lsp-wms-delivery-note-print-request';
+import {CreateSalesReturnRequest} from "@colijnit/transactionapi/build/model/create-sales-return-request";
+import {AddSalesReturnLineRequest} from "@colijnit/transactionapi/build/model/add-sales-return-line-request";
+import {DiscountCode} from '@colijnit/transactionapi/build/model/discount-code.bo';
+import {SetTransactionDiscountsRequest} from '@colijnit/transactionapi/build/model/set-transaction-discounts-request';
+import {ChangeLineDiscountRequest} from '@colijnit/transactionapi/build/model/change-line-discount-request';
+import {AgendaEvent, AgendaEventPerDay} from "@colijnit/sharedcomponents";
+import {PlanDaypart} from "@colijnit/transactionapi/build/model/plan-daypart.bo";
+import {
+  DoDeliveryPlanningRequestInputParams
+} from "@colijnit/transactionapi/build/model/do-delivery-planning-request-input-params.bo";
+import {PdfHistoricPosReceiptRequest} from "@colijnit/transactionapi/build/model/pdf-historic-pos-receipt-request";
+import {RoundUpRequest} from '@colijnit/transactionapi/build/model/round-up-request';
+
+type CreateTransactionFn = (request: CreateTransactionRequest) => Promise<boolean>;
+
+@Injectable({
+  providedIn: 'root'
+})
+export class TransactionService extends PendingReasonService {
+
+  public remainingAmount: number = 0;
+
+  private readonly _createTransactionMethods: Map<TransactionKind, CreateTransactionFn> = new Map<TransactionKind, CreateTransactionFn>([
+    [TransactionKind.SalesOrder, (request: CreateSalesOrderRequest) => this.createSalesOrder(request)],
+    [TransactionKind.PurchaseOrder, (request: CreatePurchaseOrderRequest) => this.createPurchaseOrder(request)],
+    [TransactionKind.SalesQuotation, (request: CreateSalesQuotationRequest) => this.createSalesQuotation(request)],
+    [TransactionKind.ServiceOrder, (request: CreateSalesQuotationRequest) => this.createServiceOrder(request)]
+  ]);
+
+  private readonly _relationKindFromTransactionKind: Map<TransactionKind, RelationKind> = new Map<TransactionKind, RelationKind>([
+    [TransactionKind.SalesOrder, RelationKind.Customer],
+    [TransactionKind.PurchaseOrder, RelationKind.Supplier],
+    [TransactionKind.SalesQuotation, RelationKind.Customer],
+    [TransactionKind.CashDesk, RelationKind.Customer],
+    [TransactionKind.ServiceOrder, RelationKind.Customer],
+    [TransactionKind.InternalDelivery, RelationKind.Branch]
+  ]);
+
+  private readonly _focusStatusIndex: Map<TransactionTypeCategory, number> = new Map<TransactionTypeCategory, number>([
+    [TransactionTypeCategory.SalesOrderPurchase, 0],
+    [TransactionTypeCategory.SalesOrderAllocation, 1],
+    [TransactionTypeCategory.SalesOrderDeliveryNote, 7],
+    [TransactionTypeCategory.SalesOrderInvoice, 8],
+    [TransactionTypeCategory.PurchaseOrderOrderConfirmation, 1],
+    [TransactionTypeCategory.PurchaseOrderReceivedGoods, 3]
+  ]);
+
+  private _restrictedUserRoles: UserRoleType[] = [UserRoleType.Customer, UserRoleType.SupplierContract, UserRoleType.SupplierContract, UserRoleType.DepartmentManager,
+    UserRoleType.CustomerContact, UserRoleType.CustomerAdminUser, UserRoleType.AbsenceSupservisor];
+
+  public set transForServiceFromSalesTransactionLine(value: TransactionInfoResponse) {
+    this._transForServiceFromSalesTransactionLine = value;
+  }
+
+  public get transForServiceFromSalesTransactionLine(): TransactionInfoResponse {
+    return this._transForServiceFromSalesTransactionLine;
+  }
+
+  public set loggedInUser(value: RelationSmallObject) {
+    this._loggedInUser = value;
+  }
+
+  public get loggedInUser(): RelationSmallObject {
+    return this._loggedInUser;
+  }
+
+  public set loggedInUserRole(value: UserRoleType) {
+    this._loggedInUserRole = value;
+  }
+
+  public get loggedInUserRole(): UserRoleType {
+    return this._loggedInUserRole;
+  }
+
+  public set lineNrForServiceFromSalesTransactionLine(value: number) {
+    this._lineNrForServiceFromSalesTransactionLine = value;
+  }
+
+  public get lineNrForServiceFromSalesTransactionLine(): number {
+    return this._lineNrForServiceFromSalesTransactionLine;
+  }
+
+  private _boFactory: BusinessObjectFactory = new BusinessObjectFactory();
+  private _transForServiceFromSalesTransactionLine: TransactionInfoResponse;
+  private _lineNrForServiceFromSalesTransactionLine: number;
+  private _loggedInUser: RelationSmallObject;
+  private _loggedInUserRole: UserRoleType;
+
+  public async logOut(): Promise<void> {
+    await this.connector.logOut();
+    this.resetCurrentTransaction();
+    this.logout.next();
+  }
+
+  public getFocusStatusIndex(category: TransactionTypeCategory): number {
+    return this._focusStatusIndex.get(category);
+  }
+
+  public getRelationKindFromTransactionKind(): RelationKind {
+    if (this._relationKindFromTransactionKind.has(this.transactionKind)) {
+      return this._relationKindFromTransactionKind.get(this.transactionKind);
+    } else {
+      return RelationKind.Customer;
+    }
+  }
+
+  public async showWarehouseLocationPopup(): Promise<string> {
+    if (this.currentTransaction.transactionLines) {
+      const linesThatShouldHaveLocation: TransactionLineInfo[] =
+        this.currentTransaction.transactionLines.filter(l => l.isLocationRequired && l.articleLineStatus.quantityToReceive > 0);
+      if (linesThatShouldHaveLocation.length > 0) {
+        const response: DialogResponseInterface = await this.dialogService.showWarehouseLocation(0, false, false, true);
+        if (response.button === AppPopupButtonType.Ok) {
+          linesThatShouldHaveLocation.forEach(l => {
+            l.locationNr = response.output;
+            this.transactionEventService.transactionLineChanged.next(l);
+          });
+          return response.output;
+        }
+      }
+    }
+  }
+
+  public async getCashOnDeliveryData(uuid: string): Promise<CashOnDeliveryData> {
+    return await this.connector.getCashOnDeliveryData(uuid);
+  }
+
+  public async changeHeaderCashOnDeliveryAmount(request: ChangeHeaderCashOnDeliveryAmountRequest): Promise<void> {
+    return await this.connector.changeHeaderCashOnDeliveryAmount(request);
+  }
+
+  public async deleteTransaction(): Promise<void> {
+    if (this.currentTransaction && this.currentTransaction.transactionInfo && this.currentTransaction.transactionInfo.id) {
+      const lockSuccess: boolean = await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+      if (lockSuccess) {
+        const response: DialogResponseInterface = await this.dialogService.showYesNo('DELETE', 'DELETE_TRANSACTION_QUESTION');
+        const shouldDelete: boolean = response.button === AppPopupButtonType.Yes;
+        if (shouldDelete) {
+          const response: TransactionInfoResponse = await this.connector.deleteTransactionByUuId(this.currentTransaction.transactionInfo.uuid);
+          let success: boolean = true;
+          if (!response.isSuccess) {
+            success = await this.handleHeaderOperationStatuses(response, false, false, false);
+          }
+          if (success) {
+            success = await this.commit();
+            if (success) {
+              this.resetCurrentTransaction();
+              this.transactionEventService.transactionDeleted.next();
+            }
+          }
+        }
+      }
+    }
+  }
+
+  public async cancelCashRegisterOrder(): Promise<void> {
+    if (this.currentTransaction) {
+      const response: DialogResponseInterface = await this.dialogService.showYesNo('CANCEL', 'CANCEL_TRANSACTION_QUESTION');
+      const shouldDelete: boolean = response.button === AppPopupButtonType.Yes;
+      if (shouldDelete) {
+        const lockSuccess: boolean = await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+        if (lockSuccess) {
+          const response: TransactionInfoResponse = await this.connector.cancelTransactionByUuId(this.currentTransaction.transactionInfo.uuid);
+          let success: boolean = await this.handleHeaderOperationStatuses(response, false);
+          if (success) {
+            success = await this.commit();
+            if (success) {
+              this.transactionEventService.transactionDeleted.next();
+              this.currentTransaction = undefined;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  public async updateHeaderTransactionDefinitive(uuid: string, definitive: boolean, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDefinitive(uuid, definitive);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderDiscountOnOrderLine(uuid: string, discount: boolean, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderDiscountOnOrderLine(uuid, discount);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderDeliveryAddress(uuid: string, newNawNr: number, saveTransaction: boolean = true): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderDeliveryAddress(uuid, newNawNr);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderInvoiceAddress(uuid: string, newNawNr: number, saveTransaction: boolean = true): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderInvoiceAddress(uuid, newNawNr);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDeliveryDate(uuid: string, date: Date, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDeliveryDate(uuid, date);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDeliveryDateDefinitive(uuid: string, definitive: boolean, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDeliveryDateDefinitive(uuid, definitive);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionRemark(uuid: string, remark: string, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionRemark(uuid, remark);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionReference(uuid: string, reference: string, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionReference(uuid, reference);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionRelationReference(uuid: string, reference: string, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionRelationReference(uuid, reference);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDepositAmount(uuid: string, amount: number, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderDepositAmount(uuid, amount);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDepositPercentage(uuid: string, amount: number, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse = await this.connector.changeHeaderDepositPercentage(uuid, amount);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateHeaderTransactionPreferredDeliveryDate(uuid: string, date: Date, saveTransaction: boolean, option: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionPreferredDeliveryDate(uuid, date, option);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionAssemblyDate(uuid: string, date: Date, saveTransaction: boolean, option: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderAssemblyDate(uuid, date, option);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDeliveryTime(uuid: string, time: Date, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDeliveryTime(uuid, time);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDeliveryMethod(uuid: string, method: string, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDeliveryMethod(uuid, method);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDeliveryOptions(uuid: string, options: string[], saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDeliveryOptions(uuid, options);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionPartialDelivery(uuid: string, allowPartial: boolean, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionPartialDelivery(uuid, allowPartial);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionBranch(uuid: string, branch: number, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionBranch(uuid, branch);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionOnHoldCodes(uuid: string, codes: string[], saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionOnHoldCodes(uuid, codes);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDivideEvenly(uuid: string, divideEvenly: boolean, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDivideEvenly(uuid, divideEvenly);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionAutoRecalculateDeposit(uuid: string, autoRecalculateDeposit: boolean, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderAutoRecalculateDeposit(uuid, autoRecalculateDeposit);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionUseDepositRule(uuid: string, useDepositRule: boolean, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderUseDepositRule(uuid, useDepositRule);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderContactPerson(uuid: string, relationId: number, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderContactPerson(uuid, relationId);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionAmountToSettle(uuid: string, amountToSettle: number, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionAmountToSettle(uuid, amountToSettle);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionPriceKind(uuid: string, priceKind: string, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionPriceKind(uuid, priceKind);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionPriceList(uuid: string, PriceList: string, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionPriceList(uuid, PriceList);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionAdmCoordinator(uuid: string, relation: number, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionAdmCoordinator(uuid, relation);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionSalesPerson(uuid: string, relation: number, saveTransaction: boolean): Promise<boolean> {
+    // not in middletier yet
+    // const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionSalesOrder(uuid, relation);
+    // if (response) {
+    //   return this.handleHeaderOperationStatuses(response);
+    // }
+    return true;
+  }
+
+  public async updateHeaderTransactionCurrency(uuid: string, currencyCode: string, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionCurrency(uuid, currencyCode);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return true;
+  }
+
+  public async changeHeaderTransactionType(uuid: string, transactionType: string, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionType(uuid, transactionType);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return true;
+  }
+
+  public async updateHeaderTransactionProjectCode(uuid: string, projectCode: number, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionProjectCode(uuid, projectCode);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return true;
+  }
+
+  public async updateHeaderTransactionPaymentCondition(uuid: string, condition: string, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionPaymentCondition(uuid, condition);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return true;
+  }
+
+  public async updateHeaderTransactionHanldedBy(uuid: string, handledBy: number, saveTransaction: boolean, lock?: boolean): Promise<boolean> {
+    if (lock) {
+      const locked = await this.tryToLockTransaction(
+        this.currentTransaction.transactionInfo.id,
+        this.currentTransaction.transactionInfo.version
+      );
+      if (!locked) {
+        return true;
+      }
+    }
+    const response = await this.connector.changeHeaderTransactionHandledBy(uuid, handledBy);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return true;
+  }
+
+  public async updateHeaderTransactionMarketing(uuid: string, code: string, saveTransaction: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionMarketing(uuid, code);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDiscount(uuid: string, type: DiscountType, amount: number, saveTransaction: boolean, reason: string = '', code: string = ''): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.changeHeaderTransactionDiscount(uuid, type, amount, reason, code);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateHeaderTransactionScoringChance(request: ChangeHeaderScoringChanceRequest, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.changeHeaderScoringChance(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateHeaderTransactionExpectedScoringDate(request: ChangeHeaderExpectedScoringDateRequest, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.changeHeaderExpectedScoringDate(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateHeaderTransactionRetailStadium(request: ChangeHeaderRetailStadiumRequest, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.changeHeaderRetailStadium(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateHeaderRelationTransactionDate(request: ChangeHeaderRelationTransactionDateRequest, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.changeHeaderRelationTransactionDate(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateServiceHeaderReportMessage(message: string, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      let request: ChangeServiceHeaderReportMessageRequest = new ChangeServiceHeaderReportMessageRequest();
+      request.transactionUuid = this.currentTransaction.transactionInfo.uuid;
+      request.newReportMessage = message;
+      const response: TransactionInfoResponse = await this.connector.changeServiceHeaderReportMessage(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateServiceHeaderCauseCode(code: string, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      let request: ChangeServiceHeaderCauseCodeRequest = new ChangeServiceHeaderCauseCodeRequest();
+      request.transactionUuid = this.currentTransaction.transactionInfo.uuid;
+      request.newCauseCode = code;
+      const response: TransactionInfoResponse = await this.connector.changeServiceHeaderCauseCode(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateServiceHeaderServiceType(type: string, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      let request: ChangeServiceHeaderServiceTypeRequest = new ChangeServiceHeaderServiceTypeRequest();
+      request.transactionUuid = this.currentTransaction.transactionInfo.uuid;
+      request.newServiceType = type;
+      const response: TransactionInfoResponse = await this.connector.changeServiceHeaderServiceType(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateServiceHeaderWizardData(code: string, type: string, qa: string, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      let request: ChangeServiceHeaderWizardDataRequest = new ChangeServiceHeaderWizardDataRequest();
+      request.transactionUuid = this.currentTransaction.transactionInfo.uuid;
+      request.newCauseCode = code;
+      request.newServiceType = type;
+      request.newWizardQuestionsAndAnswers = qa;
+      const response: TransactionInfoResponse = await this.connector.changeServiceHeaderWizardData(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateServiceHeaderPriority(priority: number, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      let request: ChangeServiceHeaderPriorityRequest = new ChangeServiceHeaderPriorityRequest();
+      request.transactionUuid = this.currentTransaction.transactionInfo.uuid;
+      request.newPriority = priority;
+      const response: TransactionInfoResponse = await this.connector.changeServiceHeaderPriority(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateServiceHeaderEntryType(entryType: string, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      let request: ChangeServiceHeaderEntryTypeRequest = new ChangeServiceHeaderEntryTypeRequest();
+      request.transactionUuid = this.currentTransaction.transactionInfo.uuid;
+      request.newEntryType = entryType;
+      const response: TransactionInfoResponse = await this.connector.changeServiceHeaderEntryType(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async addHeaderImage(image: CoDocument, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      let request: AddHeaderImageRequest = new AddHeaderImageRequest();
+      request.transactionUuid = this.currentTransaction.transactionInfo.uuid;
+      request.newHeaderImage = image;
+      const response: TransactionInfoResponse = await this.connector.addHeaderImage(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async deleteHeaderImage(image: CoDocument, saveTransaction: boolean): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      let request: DeleteHeaderImageRequest = new DeleteHeaderImageRequest();
+      request.transactionUuid = this.currentTransaction.transactionInfo.uuid;
+      request.fileName = image.fileName;
+      const response: TransactionInfoResponse = await this.connector.deleteHeaderImage(request);
+      this.transactionDirty = true;
+      return this.handleHeaderOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async updatePriceTransactionLine(uuid: string, lineUuid: string, price: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLinePrice(uuid, lineUuid, price);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updatePurchasePriceTransactionLine(uuid: string, lineUuid: string, price: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLinePurchasePrice(uuid, lineUuid, price);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updatePurchaseDescriptionTransactionLine(uuid: string, lineUuid: string, description: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLinePurchaseDescription(uuid, lineUuid, description);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateReferenceTransactionLine(uuid: string, lineUuid: string, reference: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineReference(uuid, lineUuid, reference);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateLineSupplierArticleNumber(uuid: string, lineUuid: string, artNr: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeLineSupplierArticleNumber(uuid, lineUuid, artNr);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateGoodDescriptionTransactionLine(uuid: string, lineUuid: string, goodDescription: string): Promise<boolean> {
+    if (this.autoSave && (this.transactionKind !== TransactionKind.CashDesk)) {  // TODO: fix this nasty thing (and figure out why is was added in the first place)
+      await this._checkAndAddRelationTransaction();
+    }
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineGoodDescription(uuid, lineUuid, goodDescription);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateQuantitySelectedForAllLines(transactionInfo: TransactionInfo,
+    transactionLines: TransactionLineInfo[], deliveryCostLines: TransactionDeliveryCostLineInfo[], selected: boolean): Promise<void> {
+    if (transactionInfo && transactionInfo.uuid && transactionLines) {
+      const linesRequest: ChangeLineQuantitySelectedLineRequest[] = [];
+      let selectedLines: TransactionLineInfo[] = transactionLines.filter(l => selected ? l.selected : true);
+      if (deliveryCostLines) {
+        selectedLines = selectedLines.concat(deliveryCostLines);
+      }
+      for (let i = 0; i < selectedLines.length; i++) {
+        const selectedLine: TransactionLineInfo = selectedLines[i];
+        const request: ChangeLineQuantitySelectedLineRequest = new ChangeLineQuantitySelectedLineRequest();
+        request.lineUuid = selectedLine.uuid;
+        request.newQuantitySelected = selected ? selectedLine.amountSelected : 0;
+        linesRequest.push(request);
+      }
+      const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineQuantitySelected(transactionInfo.uuid, linesRequest);
+      if (response) {
+        this.transactionDirty = true;
+        await this.handleLineOperationStatuses(response, false, false);
+        this.transactionEventService.quantitySelectedLineChanged.next(true);
+      }
+    }
+  }
+
+  public async updateQuantitySelectedTransactionLine(uuid: string, lines: ChangeLineQuantitySelectedLineRequest[],
+    saveTransaction: boolean = true, rememberTransaction: boolean = true): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineQuantitySelected(uuid, lines);
+    if (response) {
+      this.transactionDirty = true;
+      await this.handleLineOperationStatuses(response, saveTransaction, rememberTransaction);
+      this.transactionEventService.quantitySelectedLineChanged.next(true);
+      return true;
+    }
+    return false;
+  }
+
+  public async updateQuantitySelectNone(uuid: string, saveTransaction: boolean = true, rememberTransaction: boolean = true): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineQuantitySelectNone(uuid);
+    if (response) {
+      this.transactionDirty = true;
+      await this.handleLineOperationStatuses(response, saveTransaction, rememberTransaction);
+      this.transactionEventService.quantitySelectedLineChanged.next(true);
+      return true;
+    }
+    return false;
+  }
+
+  public async updateDeliveryDateTransactionLine(uuid: string, lineUuid: string, date: Date): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineDeliveryDate(uuid, lineUuid, date);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updatePriceListTransactionLine(uuid: string, lineUuid: string, priceList: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLinePriceList(uuid, lineUuid, priceList);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateVatTransactionLine(uuid: string, lineUuid: string, id: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineVat(uuid, lineUuid, id);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateCommissionCodeTransactionLine(uuid: string, lineUuid: string, code: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineCommissionCode(uuid, lineUuid, code);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateDirectSellTransactionLine(transactionUuid: string, lineUuid: string, newDirectSell: boolean,
+    newSupplierId: number, newPurchaseOrderNumber: string, newStockForecastDeliveryDate: Date): Promise<boolean> {
+    const response: TransactionInfoResponse = await this.connector.changeTransactionLineDirectSell(transactionUuid, lineUuid, newDirectSell,
+      newSupplierId, newPurchaseOrderNumber, newStockForecastDeliveryDate);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateSupplierTransactionLine(uuid: string, lineUuid: string, id: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineSupplier(uuid, lineUuid, id);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateWarehouseTransactionLine(uuid: string, lineUuid: string, warehouseNumber: number, saveTransaction: boolean = true): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineWarehouse(uuid, lineUuid, warehouseNumber);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async updateTransactionLineInterBranchSourceWarehouse(uuid: string, lineUuid: string, interBranchSourceWarehouseNr: number, saveTransaction: boolean = true): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineInterBranchSourceWarehouse(uuid, lineUuid, interBranchSourceWarehouseNr);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response, saveTransaction);
+    }
+    return false;
+  }
+
+  public async changeLineWarehouseAndSetInterBranchSourceWarehouse(uuid: string, lineUuid: string, warehouse: number, sourceWarehouse: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeLineWarehouseAndSetInterBranchSourceWarehouse(uuid, lineUuid, warehouse, sourceWarehouse);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async changeLineWarehouseAndClearInterBranchSourceWarehouse(uuid: string, lineUuid: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeLineWarehouseAndClearInterBranchSourceWarehouse(uuid, lineUuid);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateDeliveryMethodTransactionLine(uuid: string, lineUuid: string, method: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineDeliveryMethod(uuid, lineUuid, method);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateDiscountTransactionLine(uuid: string, lineUuid: string, type: DiscountType, discount: number, reason: string = '', code: string = ''): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineLineDiscount(uuid, lineUuid, type, discount, reason, code);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateDropShipmentTransactionLine(uuid: string, lineUuid: string, newDropShipment: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineDropShipment(uuid, lineUuid, newDropShipment);
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async saveRelation(commitTransaction: boolean = true, alsoInitialiseTransAndAdd: boolean = true): Promise<boolean> {
+    // this._cleanRelationBeforeSave();
+    if (alsoInitialiseTransAndAdd) {
+      this.initializeRelation();
+    }
+
+    if (!this.relation.relationId) {
+      this.relation = await this.transactionRelationService.insertRelation(this._relationKindFromTransactionKind.get(this.transactionKind), this.relation);
+    } else {
+      const locked: ValidationResult = await this.transactionRelationService.lockRelation(this.relation.relationType, parseInt(this.relation.relationNumber));
+      if (!locked || !locked.success) {
+        this.dialogService.showInformation('RELATION_ALREADY_LOCKED', true);
+      }
+      try {
+        this.relation = await this.transactionRelationService.updateRelation(this._relationKindFromTransactionKind.get(this.transactionKind), this.relation);
+      } catch (e) {
+        return false;
+      }
+    }
+    // await this.relationService.commit();
+    if (alsoInitialiseTransAndAdd && !this.currentTransaction.transactionInfo.relation) {
+      return await this.addRelationToTransaction(this.relation.relationId);
+    }
+    return true;
+  }
+
+  public getSequenceValue(): Promise<number> {
+    return this.connector.getSequenceValue(SequenceName.RelationId);
+  }
+
+  public getRelationPrivacySettings(): Promise<RelationPrivacySetting[]> {
+    return this.connector.getRelationPrivacySettings();
+  }
+
+  public getArticleBoundTextLinesOfArticleLine(articleLineUuid: string): Promise<TransactionLineInfo[]> {
+    return this.connector.getArticleBoundTextLinesOfArticleLine(articleLineUuid);
+  }
+
+  public async createSalesOrder(request: CreateSalesOrderRequest): Promise<boolean> {
+    await this.checkBranch();
+    if (!this.currentBranch) {
+      return Promise.reject();
+    }
+    request.branchNr = this.currentBranch;
+    const response: TransactionInfoResponse = await this.connector.createSalesOrder(request);
+    await this.rememberCurrentTransaction(response);
+    return true;
+  }
+
+  public async createSalesReturn(request: CreateSalesReturnRequest): Promise<boolean> {
+    const response: TransactionInfoResponse = await this.connector.createSalesReturn(request);
+    if (response) {
+      return await this.handleHeaderOperationStatuses(response, false);
+    } else {
+      return false;
+    }
+  }
+
+  public async addSalesReturnLine(request: AddSalesReturnLineRequest): Promise<boolean> {
+    let lockSuccess: boolean = true;
+    if (this.currentTransaction.transactionInfo.id) {
+      lockSuccess = await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    }
+
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.addSalesReturnLine(request);
+      if (response) {
+          await this.rememberCurrentTransaction(response);
+          return await this.handleLineOperationStatuses(response);
+      } else {
+        return false;
+      }
+   } else {
+     return false;
+   }
+  }
+
+  public async createCashRegisterOrder(request: CreateCashRegisterOrderRequest, saveTransaction: boolean = true): Promise<boolean> {
+    return new Promise<boolean>((resolve: Function) => {
+      this.connector.createCashRegisterOrder(request).then(async (response: TransactionInfoResponse) => {
+        this.transactionEventService.transactionLoaded.next();
+        await this.rememberCurrentTransaction(response);
+        resolve(await this.handleHeaderOperationStatuses(response, saveTransaction, saveTransaction));
+      });
+    });
+  }
+
+  public async createPurchaseOrder(request: CreatePurchaseOrderRequest): Promise<boolean> {
+    await this.checkBranch();
+    if (!this.currentBranch) {
+      return Promise.reject();
+    }
+    request.branchNr = this.currentBranch;
+    const response: TransactionInfoResponse = await this.connector.createPurchaseOrder(request);
+    await this.rememberCurrentTransaction(response);
+    return true;
+  }
+
+  public async createServiceOrder(request: CreateServiceOrderRequest): Promise<boolean> {
+    return new Promise<boolean>(async (resolve: Function, reject: Function) => {
+      await this.checkBranch();
+      if (!this.currentBranch) {
+        return reject();
+      }
+      if (this._transForServiceFromSalesTransactionLine && !isNaN(this._lineNrForServiceFromSalesTransactionLine)) {
+        resolve(await this.createServiceOrderWithSourceTransactionLineRequest());
+      } else {
+        resolve(await this.createRegularServiceOrder(request));
+      }
+    });
+  }
+
+  public async createRegularServiceOrder(request: CreateServiceOrderRequest): Promise<boolean> {
+    return new Promise<boolean>(async (resolve: Function, reject: Function) => {
+      request.branchNr = this.currentBranch;
+      this.connector.createServiceOrder(request).then((response: TransactionInfoResponse) => {
+        this.rememberCurrentTransaction(response);
+        resolve(true);
+      });
+    });
+  }
+
+  public async copyTransactionLine(request: TransactionLineCopyRequest) {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+
+    if (lockSuccess) {
+      const response = await this.connector.createCopyTransactionLine(request);
+
+      if (response) {
+        this.transactionDirty = true;
+        return this.handleLineOperationStatuses(response);
+      }
+      return false;
+    }
+  }
+
+  public async createServiceOrderWithSourceTransactionLineRequest(): Promise<boolean> {
+    return new Promise<boolean>(async (resolve: Function, reject: Function) => {
+      let request: CreateServiceOrderWithSourceTransactionLineRequest = new CreateServiceOrderWithSourceTransactionLineRequest();
+      request.branchNr = this.currentBranch;
+      request.customerRelationId = this._transForServiceFromSalesTransactionLine.transactionInfo.relation.relationId;
+      request.sourceTransId = this._transForServiceFromSalesTransactionLine.transactionInfo.id;
+      request.sourceLineNr = this._lineNrForServiceFromSalesTransactionLine;
+
+      this.connector.createServiceOrderWithSourceTransactionLine(request).then((response: TransactionInfoResponse) => {
+        this.rememberCurrentTransaction(response);
+        resolve(true);
+      });
+    });
+  }
+
+  public async createSalesQuotation(request: CreateSalesQuotationRequest): Promise<boolean> {
+    await this.checkBranch();
+    if (!this.currentBranch) {
+      return Promise.reject();
+    }
+    request.branchNr = this.currentBranch;
+    const response: TransactionInfoResponse = await this.connector.createSalesQuotation(request);
+    await this.rememberCurrentTransaction(response);
+    return true;
+  }
+
+  public async addRelationToTransaction(relationId: number): Promise<boolean> {
+    const created: boolean = await this._checkAndCreateTransaction(false);
+    if (!created) {
+      return false;
+    }
+
+    if (!this._transForServiceFromSalesTransactionLine) {
+      const response: TransactionInfoResponse = await this.connector.addRelationToTransaction(this.currentTransaction.transactionInfo.uuid, relationId);
+
+      if (response) {
+        this.transactionDirty = true;
+        return this.handleHeaderOperationStatuses(response);
+      }
+
+      return false;
+    } else {
+      this.resetDataForServiceFromSalesTransactionLine();
+      return true;
+    }
+
+  }
+
+  public async doDeliveryPlanningRequest(inputs: DoDeliveryPlanningRequestInputParams): Promise<boolean> {
+    let response: DataServiceResponseData = await this.connector.doDeliveryPlanningRequest(inputs);
+    return (response && response.validationResult && response.validationResult.success);
+  }
+
+  public getCommissionCodes(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getCommissionCodes(languageCode);
+  }
+
+  public getContactTypes(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getContactTypes(languageCode);
+  }
+
+  public getYesNo(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getYesNoCollection(languageCode);
+  }
+
+  public getPriceKind(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getPriceKindCollection(languageCode);
+  }
+
+  public async getPriority(languageCode: string): Promise<CoDomainValue[]> {
+    let priolist: CoDomainValue[] = await this.connector.getPriorityCollection(languageCode);
+    return priolist.sort((a, b) => a.codeAsNumber < b.codeAsNumber ? -1 : 1);
+  }
+
+  public getEntryTypes(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getEntryTypes(languageCode);
+  }
+
+  public getDomainTypes(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getDomainTypes(languageCode);
+  }
+
+  public getCauseCodes(): Promise<CauseCode[]> {
+    return this.connector.getCauseCodes();
+  }
+
+  public getInOutCollection(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getInOutCollection(languageCode);
+  }
+
+  public getSLATypes(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getSLATypes(languageCode);
+  }
+
+  public getTurnoverGroups(): Promise<TurnoverGroupImage[]> {
+    return this.articleConnector.getTurnoverGroups();
+  }
+
+  public getTransactionArticleWarehouses(goodId: number): Promise<TransactionArticleWarehouse[]> {
+    return this.connector.getTransactionArticleWarehouses(goodId);
+  }
+
+  public getMarketingCodes(): Promise<Marketing[]> {
+    return this.connector.getMarketingCodes();
+  }
+
+  public getArticles(request: ArticleExtendedRequest): Promise<ArticleLight[]> {
+    return this.articleConnector.searchArticles(request);
+  }
+
+  public getArticleListWithBarcodeArticleNrEanCode(search: string): Promise<ArticleLight[]> {
+    return this.articleConnector.getArticleListWithBarcodeArticleNrEanCode(search);
+  }
+
+  public getMainArticles(): Promise<MainArticle[]> {
+    return this.articleConnector.getMainArticles();
+  }
+
+  public getDeliveryMethods(): Promise<DeliveryMethod[]> {
+    return this.connector.getDeliveryMethods();
+  }
+
+  public getDeliveryMethodsForReturns(): Promise<DeliveryMethod[]> {
+    return this.connector.getDeliveryMethodsForReturns();
+  }
+
+  public getDeliveryOptions(): Promise<DeliveryOption[]> {
+    return this.connector.getDeliveryOptions();
+  }
+
+  public getDiscountCodes(): Promise<DiscountCode[]> {
+    return this.connector.getDiscountCodes(this.transactionKind);
+  }
+
+  public async setTransactionDiscounts(request: SetTransactionDiscountsRequest): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.setTransactionDiscounts(request);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response, true);
+    } else {
+      return false;
+    }
+  }
+
+  public async changeLineDiscount(request: ChangeLineDiscountRequest): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.changeLineDiscount(request);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response, true);
+    } else {
+      return false;
+    }
+  }
+
+  public getSalesPersons(date?: Date): Promise<SalesPerson[]> {
+    return this.connector.getSalesPersons(date);
+  }
+
+  public getRetailStadiums(): Promise<RetailStadium[]> {
+    return this.connector.getRetailStadiums();
+  }
+
+  public async addWebSessionTransactionLine(transactionUuid: string, articleNumber: string, quantity: number): Promise<void> {
+    const response: TransactionInfoResponse = await this.connector.addWebSessionTransactionLine(transactionUuid, articleNumber, quantity);
+    this.handleLineOperationStatuses(response);
+  }
+
+  public async getArticleExtended(articleNr: string): Promise<ArticleExtended> {
+    return this.connector.getArticleExtended(articleNr);
+  }
+
+  public async addArticle(articleNo: string, quantity: number = 1, aboveLineNr: number = 0, belowLineNr: number = 0, saveTransaction: boolean = true, showLoader: boolean = false): Promise<boolean> {
+    const response: TransactionInfoResponse = await this.addTransactionLine(articleNo, quantity, aboveLineNr, belowLineNr, showLoader);
+    if (response !== null) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response, saveTransaction);
+    } else {
+      return false;
+    }
+  }
+
+  public async addTransactionLine(articleNo: string, quantity: number = 1, aboveLineNr: number = 0, belowLineNr: number = 0, showLoader: boolean = false): Promise<TransactionInfoResponse> {
+    const created: boolean = await this._checkAndCreateTransaction();
+    if (!created) {
+      return null;
+    }
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      this.transactionLineAdded = true;
+      const response: TransactionInfoResponse = await this.connector.addTransactionLine(
+        this.currentTransaction.transactionInfo.uuid, articleNo, quantity, aboveLineNr, belowLineNr, showLoader);
+      return response;
+    } else {
+      return null;
+    }
+  }
+
+  public async addCatFarmArticle(catalogId: number, jsonArticleString: string): Promise<void> {
+    const jsonArticleObject: any = JSON.parse(jsonArticleString);
+    const articleTree: ArticleFlatTreeDTO = this._boFactory.makeWithRawBackendData(ArticleFlatTreeDTO, jsonArticleObject.articleTree) as ArticleFlatTreeDTO;
+    let artNr: string = await this.articleConnector.storeCatFarmCompositionArticle(catalogId, articleTree);
+    await this.addArticle(artNr, jsonArticleObject.quantity);
+  }
+
+  public async addExternalCatalogArticle(request: ExternalCatalogAddArticleRequest, showLoader: boolean = false): Promise<void> {
+    await this.addExternalCatalogArticleWithRawData(request.catalogId, request.articleJson, showLoader);
+  }
+
+  public async addExternalCatalogArticleFromGoodId(jsonArticleString: string, showLoader: boolean = false): Promise<void> {
+    const jsonArticleObject: any = JSON.parse(jsonArticleString);
+    const response: TransactionInfoResponse = await this.addTransactionLine(jsonArticleObject.sku, jsonArticleObject.quantity, 0, 0, showLoader);
+    const handled: boolean = await this.handleLineOperationStatuses(response, true);
+    if (handled && jsonArticleObject.price !== undefined) {
+      await this.updatePriceTransactionLine(response.transactionInfo.uuid, response.lineOperationStatuses[0].uuid, jsonArticleObject.price);
+    }
+  }
+
+  public async addExternalCatalogArticleWithRawData(catalogId: number, jsonArticleString: string, showLoader: boolean = false): Promise<void> {
+    const created: boolean = await this._checkAndCreateTransaction();
+    if (!created) {
+      return null;
+    }
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      this.transactionLineAdded = true;
+      const response: TransactionInfoResponse = await this.connector.addExternalCatalogArticlesToTransaction(
+        this.currentTransaction.transactionInfo.uuid, catalogId, jsonArticleString, showLoader);
+      await this.handleLineOperationStatuses(response, true);
+    }
+  }
+
+  public async addExpenseToCashRegisterOrder(request: AddExpenseToCashRegisterOrderRequest): Promise<void> {
+    const created: boolean = await this._checkAndCreateTransaction();
+    if (!created) {
+      return null;
+    }
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      this.transactionLineAdded = true;
+      const response: TransactionInfoResponse = await this.connector.addExpenseToCashRegisterOrder(request);
+      await this.handleLineOperationStatuses(response, true);
+    }
+  }
+
+  public async addReceiptToCashRegisterOrder(request: AddReceiptToCashRegisterOrderRequest): Promise<void> {
+    const created: boolean = await this._checkAndCreateTransaction();
+    if (!created) {
+      return null;
+    }
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      this.transactionLineAdded = true;
+      const response: TransactionInfoResponse = await this.connector.addReceiptToCashRegisterOrder(request);
+      await this.handleLineOperationStatuses(response, true);
+    }
+  }
+
+  public async addTextLine(showOnDocuments: number, text: string, amount: number, articleBound: boolean, refArticleLineNr: number, aboveLineNr?: number, belowLineNr?: number): Promise<boolean> {
+    const created: boolean = await this._checkAndCreateTransaction();
+    if (!created) {
+      return false;
+    }
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.addTextLineToTransaction(
+        this.currentTransaction.transactionInfo.uuid, showOnDocuments, text, amount, articleBound, refArticleLineNr, aboveLineNr, belowLineNr);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateTextLine(uuid: string, lineUuid: string, showOnDocuments: number, text: string): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.updateTextLine(uuid, lineUuid, showOnDocuments, text);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    } else {
+      return false;
+    }
+  }
+
+  public async changeLineSequence(lineUuid: string, aboveLineNr?: number, belowLineNr?: number): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.changeLineSequence(this.currentTransaction.transactionInfo.uuid, lineUuid, aboveLineNr, belowLineNr);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    } else {
+      return false;
+    }
+  }
+
+  public async deleteTransactionLine(transactionLineUuid: string): Promise<boolean> {
+    if (this.autoSave && (this.transactionKind !== TransactionKind.CashDesk)) {  // TODO: fix this nasty thing (and figure out why is was added in the first place)
+      await this._checkAndAddRelationTransaction();
+    }
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.deleteTransactionLine(this.currentTransaction.transactionInfo.uuid, transactionLineUuid);
+      if (response) {
+        this.transactionDirty = true;
+        return this.handleLineOperationStatuses(response);
+      }
+      if (!this.manualSaveActive) {
+        await this.rollback();
+      }
+    }
+    return false;
+  }
+
+  public async checkLockandChangeTransactionLineQuantity(transactionUuid: string, lineUuid: string, newQuantity: number): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      return await this.changeTransactionLineQuantity(transactionUuid, lineUuid, newQuantity);
+    }
+    return false;
+  }
+
+  public async changeTransactionLineQuantity(transactionUuid: string, lineUuid: string, newQuantity: number): Promise<boolean> {
+    if (this.autoSave && (this.transactionKind !== TransactionKind.CashDesk)) { // TODO: fix this nasty thing (and figure out why is was added in the first place)
+      await this._checkAndAddRelationTransaction();
+    }
+    const response: TransactionInfoResponse = await this.connector.changeTransactionLineQuantity(transactionUuid, lineUuid, newQuantity)
+      .catch(() => {
+        return null;
+      });
+    if (response) {
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    }
+    if (!this.manualSaveActive) {
+      await this.rollback();
+    }
+    return false;
+  }
+
+  public async changeTransactionLineAssemblyTime(uuid: string, lineUuid: string, time: number): Promise<TransactionInfoResponse> {
+    return this.connector.changeTransactionLineAssemblyTime(uuid, lineUuid, time);
+  }
+
+  public async changeLineShippingCost(uuid: string, lineUuid: string, newShippingCost: number): Promise<TransactionInfoResponse> {
+    return this.connector.changeLineShippingCost(uuid, lineUuid, newShippingCost);
+  }
+
+  public async changeLineManufacturingPriceAPiece(uuid: string, lineUuid: string, newManufacturingPriceAPiece: number): Promise<TransactionInfoResponse> {
+    return this.connector.changeLineManufacturingPriceAPiece(uuid, lineUuid, newManufacturingPriceAPiece);
+  }
+
+  public async getGoodsReceiptHistory(transId: number, lineNr: number): Promise<GoodsReceiptHistory> {
+    return await this.connector.getGoodsReceiptHistory(transId, lineNr);
+  }
+
+  public async receiveGoodsForPurchaseOrder(transactionId: number, version: number, request: ReceiveGoodsForOrderRequest): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingPurchaseOrderReceiveGoods.next(true);
+      const response: TransactionInfoResponse = await this.connector.receiveGoodsForPurchaseOrder(request);
+      this.transactionEventService.updatingPurchaseOrderReceiveGoods.next(false);
+      let success: boolean = false;
+      if (response) {
+        this.transactionDirty = true;
+        success = await this.handleHeaderOperationStatuses(response);
+      }
+      return success;
+    }
+  }
+
+  public async receiveGoodsForPurchaseOrderCorrection(transactionId: number, version: number, request: ReceiveGoodsForPurchaseOrderCorrectionRequest): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingPurchaseOrderReceiveGoods.next(true);
+      let response: TransactionInfoResponse = await this.connector.receiveGoodsForPurchaseOrderCorrection(request);
+      this.transactionEventService.updatingPurchaseOrderReceiveGoods.next(false);
+      let success: boolean = true;
+      if (response) {
+        this.transactionDirty = true;
+        success = await this.handleHeaderOperationStatuses(response);
+      }
+      return success;
+    }
+  }
+
+  public async receiveGoodsForInterBranchOrder(transactionId: number, version: number, request: ReceiveGoodsForOrderRequest): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingInterbranchOrderReceiveGoods.next(true);
+      const response: TransactionInfoResponse = await this.connector.receiveGoodsForInterBranchOrder(request);
+      this.transactionEventService.updatingInterbranchOrderReceiveGoods.next(false);
+      let success: boolean = false;
+      if (response) {
+        this.transactionDirty = true;
+        success = await this.handleHeaderOperationStatuses(response);
+      }
+      return success;
+    }
+  }
+
+  public async printPackageSticker(printRequest: PrintPackageStickerRequest): Promise<void> {
+    return await this.connector.printPackageSticker(printRequest);
+  }
+
+  public async pdfPackageSticker(pdfRequest: PdfPackageStickerRequest, localPrint: boolean = false): Promise<void> {
+    return await this.connector.pdfPackageSticker(pdfRequest, localPrint);
+  }
+
+  public async printReservationSticker(printRequest: PrintReservationStickerRequest): Promise<void> {
+    return await this.connector.printReservationSticker(printRequest);
+  }
+
+  public async pdfReservationSticker(pdfRequest: PdfReservationStickerRequest, localPrint: boolean = false): Promise<void> {
+    return await this.connector.pdfReservationSticker(pdfRequest, localPrint);
+  }
+
+  public async printOrderingSticker(printRequest: PrintOrderingStickerRequest): Promise<void> {
+    return await this.connector.printOrderingSticker(printRequest);
+  }
+
+  public async pdfOrderingSticker(pdfRequest: PdfOrderingStickerRequest, localPrint: boolean = false): Promise<void> {
+    return await this.connector.pdfOrderingSticker(pdfRequest, localPrint);
+  }
+
+  public async allocateGoodsForSalesOrder(transactionId: number, version: number, request: AllocateGoodsForSalesOrderRequest): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingPurchaseOrderAllocateGoods.next(true);
+      const response: TransactionInfoResponse = await this.connector.allocateGoodsForSalesOrder(request);
+      this.transactionEventService.updatingPurchaseOrderAllocateGoods.next(false);
+      let success: boolean = true;
+      if (response) {
+        this.transactionDirty = true;
+        success = await this.handleHeaderOperationStatuses(response);
+      }
+      return success;
+    }
+  }
+
+  public async allocateGoodsForSalesOrderCorrection(transactionId: number, version: number, request: AllocateGoodsForSalesOrderCorrectionRequest): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingPurchaseOrderAllocateGoods.next(true);
+      const response: TransactionInfoResponse = await this.connector.allocateGoodsForSalesOrderCorrection(request);
+      this.transactionEventService.updatingPurchaseOrderAllocateGoods.next(false);
+      let success: boolean = true;
+      if (response) {
+        this.transactionDirty = true;
+        success = await this.handleHeaderOperationStatuses(response);
+      }
+      return success;
+    }
+  }
+
+  public async setGoodsToBePickedForSalesOrder(transactionId: number, version: number, request: GoodsToBePickedForOrderRequest): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingSalesOrderGoodsToBePicked.next(true);
+      const response: TransactionInfoResponse = await this.connector.setGoodsToBePickedForSalesOrder(request);
+      this.transactionEventService.updatingSalesOrderGoodsToBePicked.next(false);
+      let success: boolean = true;
+      if (response) {
+        this.transactionDirty = true;
+        success = await this.handleHeaderOperationStatuses(response);
+      }
+      return success;
+    }
+  }
+
+  public async setGoodsPickedForOrder(transactionId: number, version: number, request: GoodsPickedRequest): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingSalesOrderGoodsPicked.next(true);
+      const response: TransactionInfoResponse = await this.connector.setGoodsPickedForOrder(request);
+      this.transactionEventService.updatingSalesOrderGoodsPicked.next(false);
+      let success: boolean = true;
+      if (response) {
+        this.transactionDirty = true;
+        success = await this.handleHeaderOperationStatuses(response);
+      }
+      return success;
+    }
+  }
+
+  public async deleteGoodsPicked(transactionId: number, version: number, deleteGoodsPickedForOrderRequest: DeleteGoodsPickedForOrderRequest): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.deleteGoodsPicked(deleteGoodsPickedForOrderRequest);
+      let success: boolean = true;
+      if (response) {
+        this.transactionDirty = true;
+        success = await this.handleHeaderOperationStatuses(response);
+      }
+      return success;
+    }
+  }
+
+  public async deleteGoodsToBePicked(transactionId: number, version: number, deleteGoodsToBePickedForOrderRequest: DeleteGoodsToBePickedForOrderRequest): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.deleteGoodsToBePicked(deleteGoodsToBePickedForOrderRequest);
+      let success: boolean = true;
+      if (response) {
+        this.transactionDirty = true;
+        success = await this.handleHeaderOperationStatuses(response);
+      }
+      return success;
+    }
+  }
+
+  public async purchaseOrderConfirmation(
+    transactionId: number,
+    version: number,
+    purchaseOrderConfirmation: GetPurchaseOrderConfirmation,
+    analysisId: number,
+    selectedLines: TransactionLineInfo[]
+  ): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingPurchaseOrderConfirmation.next(true);
+      let success: boolean = await this.connector.purchaseOrderConfirmation(purchaseOrderConfirmation);
+      success = await this._checkAndSaveLinesForAIConfirmation(transactionId, analysisId, selectedLines);
+      if (success) {
+        this.transactionEventService.orderConfirmationDropped.next(undefined);
+        this.transactionEventService.orderConfirmationReset.next();
+        success = await this.commit();
+        await this.getTransactionById(transactionId);
+      }
+      this.transactionEventService.updatingPurchaseOrderConfirmation.next(false);
+      return success;
+    }
+  }
+
+  public async updatePurchasePortalLines(transactionId: number, version: number, purchasePortalLine: PurchasePortalLine): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(transactionId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingPurchaseOrderConfirmation.next(true);
+      let success: boolean = await this.connector.updatePurchasePortalLines(purchasePortalLine);
+      if (success) {
+        success = await this.commit();
+        await this.getTransactionById(transactionId);
+      }
+      this.transactionEventService.updatingPurchaseOrderConfirmation.next(false);
+      return success;
+    }
+  }
+
+  public getTextTypes(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getTextTypes(languageCode);
+  }
+
+  public getStandardTexts(languageCode: string): Promise<StandardText[]> {
+    return this.connector.getStandardTexts(languageCode);
+  }
+
+  public getArticleFullObject(goodId: number): Promise<ArticleFullObject> {
+    return this.connector.getArticleFullObject(goodId);
+  }
+
+  public getGoodIdFromArticleNr(sku: string): Promise<number> {
+    return this.connector.getGoodIdFromArticleNr(sku);
+  }
+
+  public getCountry(countryCode: string): Promise<Country> {
+    return this.connector.getCountry(countryCode);
+  }
+
+  public getCashRegisters(branch?: string, group?: number): Promise<CashRegister[]> {
+    return this.connector.getCashRegisters(branch, group, this.cashRegistersDirty);
+  }
+
+  public getCashDrawers(cashDrawersRequest: CashDrawersRequest): Promise<CashDrawer[]> {
+    return this.connector.getCashDrawers(cashDrawersRequest, this.cashRegistersDirty);
+  }
+
+  public getPriceLists(): Promise<PriceList[]> {
+    return this.connector.getPriceLists();
+  }
+
+  public getVatLists(): Promise<Vat[]> {
+    return this.connector.getVatList();
+  }
+
+  public getTransVatCodes(type: string, date: Date): Promise<Vat[]> {
+    return this.connector.getTransVatCodes(type, date);
+  }
+
+  public getTags(category: number): Promise<Tag[]> {
+    return this.connector.getTags(category);
+  }
+
+  public getOnHoldCodes(): Promise<OnHoldCode[]> {
+    return this.connector.getOnHoldCodes();
+  }
+
+  public getWarehouses(): Promise<Warehouse[]> {
+    return this.connector.getWarehouses(this.currentBranch);
+  }
+
+  public getWarehouseStockInfoByGoodAndBranch(goodId: number, transactionInfo?: TransactionInfo): Promise<WarehouseStockInfo[]> {
+    let transactionBranch: string;
+
+    if (transactionInfo && transactionInfo.branch) {
+      transactionBranch = transactionInfo.branch.relationNr;
+    } else if (this.currentTransaction && this.currentTransaction.transactionInfo && this.currentTransaction.transactionInfo.branch) {
+      transactionBranch = this.currentTransaction.transactionInfo.branch.relationNr;
+    } else {
+      transactionBranch = this.currentBranch;
+    }
+
+    return this.connector.getWarehouseStockInfoByGoodAndBranch(goodId, transactionBranch);
+  }
+
+  public getMaxConfirmedDeliveryDateForPurchaseOrder(transId: number): Promise<Date> {
+    return this.connector.getMaxConfirmedDeliveryDateForPurchaseOrder(transId);
+  }
+
+  public getHistoricStateValues(): Promise<CodeDescription[]> {
+    return this.connector.getHistoricStateValues();
+  }
+
+  public getCustomerGroups(): Promise<CustomerGroup[]> {
+    return this.connector.getCustomerGroups();
+  }
+
+  public getWorkFlowStatusNames(transactionKind: TransactionKind): Promise<WorkFlowStatusName[]> {
+    return this.connector.getWorkFlowStatusNames(transactionKind);
+  }
+
+  public async lockPurchasePortalLines(transIdPurchase: number, lineId: number): Promise<boolean> {
+    return await this.connector.lockPurchasePortalLines(transIdPurchase, lineId);
+  }
+
+  public async getAvailableStockGroupedByWLBSByTransIdLineNr(transId: number, lineNr: number): Promise<AvailableStock[]> {
+    return await this.connector.getAvailableStockGroupedByWLBSByTransIdLineNr(transId, lineNr);
+  }
+
+  public async getAvailableStockForSupplier(goodId: number, supplierRelationId: number): Promise<SupplierArticleStockForecast> {
+    return await this.connector.getAvailableStockForSupplier(goodId, supplierRelationId);
+  }
+
+  public async getGoodsAllocationHistory(transId: number, lineNr: number): Promise<GoodsAllocationHistory> {
+    return await this.connector.getGoodsAllocationHistory(transId, lineNr);
+  }
+
+  public async getGoodsToBePickedHistory(transId: number, lineNr: number): Promise<GoodsToBePickedHistory> {
+    return await this.connector.getGoodsToBePickedHistory(transId, lineNr);
+  }
+
+  public async getGoodsPickedHistory(transId: number, lineNr: number): Promise<GoodsPickedHistory> {
+    return await this.connector.getGoodsPickedHistory(transId, lineNr);
+  }
+
+  public async getLinePurchaseHistory(transId: number, lineNr: number): Promise<PurchaseHistory> {
+    return await this.connector.getLinePurchaseHistory(transId, lineNr);
+  }
+
+  public async getLinePurchaseInfo(transId: number, lineNr: number): Promise<PurchaseInfo[]> {
+    return await this.connector.getLinePurchaseInfo(transId, lineNr);
+  }
+
+  public async getOrderConfirmationEmailLayouts(transactionUUID: string): Promise<ReportLayoutSelectionEmail[]> {
+    return await this.connector.getOrderConfirmationEmailLayouts(transactionUUID);
+  }
+
+  public async getOrderConfirmationPrintLayouts(transactionUUID: string): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getOrderConfirmationPrintLayouts(transactionUUID);
+  }
+
+  public async getOrderConfirmationDefaultSendMethod(relationId: number): Promise<number> {
+    return await this.connector.getOrderConfirmationDefaultSendMethod(relationId);
+  }
+
+  public async getDefaultEmailAddressListForOrderConfirmation(transactionUUID): Promise<string[]> {
+    return await this.connector.getDefaultEmailAddressListForOrderConfirmation(transactionUUID);
+  }
+
+  public async printOrderConfirmation(request: PrintOrderConfirmationRequest): Promise<CoDocument | boolean> {
+    this.transactionEventService.updatingSalesOrderConfirmation.next(true);
+    const result: CoDocument | boolean = await this.connector.printOrderConfirmation(request);
+    if (result && !(result instanceof CoDocument)) {
+      await this.commitAndRefreshTransaction();
+    }
+    this.transactionEventService.updatingSalesOrderConfirmation.next(false);
+    return result;
+  }
+
+  public async printHistoricOrderConfirmation(request: PrintHistoricDeliveryNoteRequest): Promise<void> {
+    return await this.connector.printHistoricOrderConfirmation(request);
+  }
+
+  public async startOrderConfirmationBatch(request: BatchTransactionSendingRequest): Promise<void> {
+    return await this.connector.startOrderConfirmationBatch(request);
+  }
+
+  public async startPurchaseOrderFormBatch(request: BatchTransactionSendingRequest): Promise<void> {
+    return await this.connector.startPurchaseOrderFormBatch(request);
+  }
+
+  public async startToAllocateUnAllocatedLinesBatch(transIds: number[]): Promise<void> {
+    return await this.connector.startToAllocateUnAllocatedLinesBatch(transIds);
+  }
+
+  public async startGoodsToBePickedBatch(request: BatchTransactionSendingRequest): Promise<void> {
+    return await this.connector.startGoodsToBePickedBatch(request);
+  }
+
+  public async startGoodsPickedBatch(transIds: number[]): Promise<void> {
+    return await this.connector.startGoodsPickedBatch(transIds);
+  }
+
+  public async startDeliveryNotesBatch(request: BatchTransactionSendingRequest): Promise<void> {
+    return await this.connector.startDeliveryNotesBatch(request);
+  }
+
+  public async startInvoiceBatch(request: BatchTransactionSendingRequest): Promise<void> {
+    return await this.connector.startInvoiceBatch(request);
+  }
+
+  public async getBatchJobProgressesForTheUser(): Promise<BatchJobProgress[]> {
+    return await this.connector.getBatchJobProgressesForTheUser();
+  }
+
+  public async deleteBatchJob(batchJobProgressId: number): Promise<void> {
+    return await this.connector.deleteBatchJob(batchJobProgressId);
+  }
+
+  public async retryBatchJob(batchJobProgressId: number): Promise<void> {
+    return await this.connector.retryBatchJob(batchJobProgressId);
+  }
+
+  public async emailOrderConfirmation(request: EmailOrderConfirmationRequest): Promise<CoDocument | boolean> {
+    this.transactionEventService.updatingSalesOrderConfirmation.next(true);
+    const result: CoDocument | boolean = await this.connector.emailOrderConfirmation(request);
+    if (result && !(result instanceof CoDocument)) {
+      await this.commitAndRefreshTransaction();
+    }
+    this.transactionEventService.updatingSalesOrderConfirmation.next(false);
+    return result;
+  }
+
+  public async emailHistoricOrderConfirmation(request: EmailHistoricOrderConfirmationRequest): Promise<void> {
+    return await this.connector.emailHistoricOrderConfirmation(request);
+  }
+
+  public async pdfOrderConfirmation(request: PdfOrderConfirmationRequest, localPrint: boolean = false): Promise<CoDocument | boolean> {
+    this.transactionEventService.updatingSalesOrderConfirmation.next(true);
+    const result: CoDocument | boolean = await this.connector.pdfOrderConfirmation(request, localPrint);
+    if (result && !(result instanceof CoDocument)) {
+      await this.commitAndRefreshTransaction();
+    }
+    this.transactionEventService.updatingSalesOrderConfirmation.next(false);
+    return result;
+  }
+
+  // public async pdfContentsOrderConfirmation(request: PdfOrderConfirmationRequest): Promise<CoDocument | boolean> {
+  //   this.transactionEventService.updatingSalesOrderConfirmation.next(true);
+  //   const result: any = await this.connector.pdfContentsOrderConfirmation(request);
+  //   if (result && !(result instanceof CoDocument)) {
+  //     await this.commitAndRefreshTransaction();
+  //   }
+  //   this.transactionEventService.updatingSalesOrderConfirmation.next(false);
+  //   return result;
+  // }
+
+  public async previewOrderConfirmation(request: PdfOrderConfirmationRequest): Promise<ReportingPdfBaseResponse> {
+    return await this.connector.previewOrderConfirmation(request);
+  }
+
+  public async previewHistoricOrderConfirmation(request: PdfOrderConfirmationRequest): Promise<ReportingPdfBaseResponse> {
+    return await this.connector.previewHistoricOrderConfirmation(request);
+  }
+
+  public async previewDeliveryNote(request: PdfDeliveryNoteRequest): Promise<ReportingPdfBaseResponse> {
+    return await this.connector.previewDeliveryNote(request);
+  }
+
+  public async previewHistoricDeliveryNote(request: PdfHistoricDeliveryNoteRequest): Promise<ReportingPdfBaseResponse> {
+    return await this.connector.previewHistoricDeliveryNote(request);
+  }
+
+  public async previewInvoice(request: PdfInvoiceRequest): Promise<ReportingPdfBaseResponse> {
+    return await this.connector.previewInvoice(request);
+  }
+
+  public async previewHistoricInvoice(request: PdfHistoricInvoiceRequest): Promise<ReportingPdfBaseResponse> {
+    return await this.connector.previewHistoricInvoice(request);
+  }
+
+  public async previewPurchaseOrder(request: PdfPurchaseOrderRequest): Promise<ReportingPdfBaseResponse> {
+    return await this.connector.previewPurchaseOrder(request);
+  }
+
+  public async previewHistoricPurchaseOrder(request: PdfHistoricPurchaseOrderRequest): Promise<ReportingPdfBaseResponse> {
+    return await this.connector.previewHistoricPurchaseOrder(request);
+  }
+
+  public async pdfHistoricOrderConfirmation(request: PdfHistoricDeliveryNoteRequest, localPrint: boolean = false): Promise<void | boolean> {
+    return await this.connector.pdfHistoricOrderConfirmation(request, localPrint);
+  }
+
+  public async printPurchaseOrder(request: PrintPurchaseOrderRequest): Promise<void> {
+    const result: boolean = await this.connector.printPurchaseOrder(request);
+    if (result) {
+      await this.commitAndRefreshTransaction();
+    }
+  }
+
+  public async printHistoricPurchaseOrder(request: PrintHistoricPurchaseOrderRequest): Promise<void> {
+    return await this.connector.printHistoricPurchaseOrder(request);
+  }
+
+  public async emailPurchaseOrder(request: EmailPurchaseOrderRequest): Promise<void> {
+    const result: boolean = await this.connector.emailPurchaseOrder(request);
+    if (result) {
+      await this.commitAndRefreshTransaction();
+    }
+  }
+
+  public async emailHistoricPurchaseOrder(request: EmailHistoricPurchaseOrderRequest): Promise<void> {
+    return await this.connector.emailHistoricPurchaseOrder(request);
+  }
+
+  public async pdfPurchaseOrder(request: PdfPurchaseOrderRequest, localPrint: boolean = false): Promise<void> {
+    const result: boolean = await this.connector.pdfPurchaseOrder(request, localPrint);
+    if (result) {
+      await this.commitAndRefreshTransaction();
+    }
+  }
+
+  public async pdfHistoricPurchaseOrder(request: PdfHistoricPurchaseOrderRequest, localPrint: boolean = false): Promise<void | boolean> {
+    return await this.connector.pdfHistoricPurchaseOrder(request, localPrint);
+  }
+
+  public async generateWebServiceOrder(transactionId: number): Promise<boolean> {
+    return await this.connector.generateWebServiceOrder(transactionId);
+  }
+
+  public async canPurchaseOrderBeSendByWebservice(transactionId: number): Promise<boolean> {
+    return await this.connector.canPurchaseOrderBeSendByWebservice(transactionId);
+  }
+
+  public async getPurchaseOrderEmailLayouts(transactionUUID: string): Promise<ReportLayoutSelectionEmail[]> {
+    return await this.connector.getPurchaseOrderEmailLayouts(transactionUUID);
+  }
+
+  public async getPurchaseOrderPrintLayouts(transactionUUID: string): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getPurchaseOrderPrintLayouts(transactionUUID);
+  }
+
+  public async getPurchaseOrderDefaultSendMethod(relationId: number): Promise<number> {
+    return await this.connector.getPurchaseOrderDefaultSendMethod(relationId);
+  }
+
+  public async isPrintIsDefaultSendMethodForPurchaseOrder(transactionId: number): Promise<boolean> {
+    return await this.connector.isPrintIsDefaultSendMethodForPurchaseOrder(transactionId);
+  }
+
+  public async generateAndSendPurchaseOrdersForSalesOrder(request: PrintPurchaseOrderForTransactionRequest, version: number, localPrint: boolean = false): Promise<Object | boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(request.transId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingSalesOrderGeneratePurchaseOrders.next(true);
+      // get lineNumbers
+      request.lineNumbers = this.currentTransaction.transactionLines.filter(l => l.selected).map(l => l.lineNr);
+      let success: Object | boolean = await this.connector.generateAndSendPurchaseOrdersForSalesOrder(request, localPrint);
+      let commitSuccess: boolean = await this.commit();
+      if (commitSuccess) {
+        await this.getTransactionById(request.transId);
+      }
+      this.transactionEventService.updatingSalesOrderGeneratePurchaseOrders.next(false);
+
+      if (success && commitSuccess) {
+        return success;
+      } else {
+        return false;
+      }
+    }
+  }
+
+  public async generateAndSendPurchaseOrdersForDirectSellSalesOrder(request: GeneratePurchaseOrdersForDirectSellSalesOrdersRequest, version: number): Promise<boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, version);
+    if (lockSuccess) {
+      let success: boolean = await this.connector.generateAndSendPurchaseOrdersForDirectSellSalesOrder(request);
+      if (success) {
+        success = await this.commit();
+        if (success) {
+          await this.getTransactionById(request.transId);
+        }
+      }
+      return success;
+    }
+  }
+
+  public async generateAndSendPurchaseOrdersForInterBranchOrder(request: PrintPurchaseOrderForTransactionRequest, version: number, localPrint: boolean = false): Promise<Object | boolean> {
+    const lockSuccess: boolean = await this.tryToLockTransaction(request.transId, version);
+    if (lockSuccess) {
+      this.transactionEventService.updatingSalesOrderGeneratePurchaseOrders.next(true);
+      // get lineNumbers
+      request.lineNumbers = this.currentTransaction.transactionLines.filter(l => l.selected).map(l => l.lineNr);
+      let success: Object | boolean = await this.connector.generateAndSendPurchaseOrdersForInterBranchOrder(request, localPrint);
+      let commitSuccess: boolean = await this.commit();
+      if (commitSuccess) {
+        await this.getTransactionById(request.transId);
+      }
+      this.transactionEventService.updatingSalesOrderGeneratePurchaseOrders.next(false);
+
+      if (success && commitSuccess) {
+        return success;
+      } else {
+        return false;
+      }
+    }
+  }
+
+  public async getPurchaseAdviceLines(filters: PurchaseAdviceFilters, goodId?: number, showLoader?: boolean): Promise<PurchaseAdviceLine[]> {
+    return await this.connector.getPurchaseAdviceLines(filters, goodId, showLoader);
+  }
+
+  public async getStockReplenishment(filters: InterBranchFilters, goodId: number, amount: number, showLoader?: boolean): Promise<StockReplenishment[]> {
+    return await this.connector.getStockReplenishment(filters, goodId, amount, showLoader);
+  }
+
+  public async generateAndSendPurchaseOrders(purchaseAdviceLines: GenerateAndSendPurchaseOrdersRequest): Promise<boolean> {
+    return await this.connector.generateAndSendPurchaseOrders(purchaseAdviceLines);
+  }
+
+  public async emailDeliveryNote(emailDeliveryNoteRequest: EmailDeliveryNoteRequest): Promise<CoDocument | boolean> {
+    this.transactionEventService.updatingSalesOrderDelivery.next(true);
+    let result: CoDocument | boolean = await this.connector.emailDeliveryNote(emailDeliveryNoteRequest);
+    if (result && !(result instanceof CoDocument)) {
+      await this.commitAndRefreshTransaction();
+    }
+    this.transactionEventService.updatingSalesOrderDelivery.next(false);
+    return result;
+  }
+
+  public async emailHistoricDeliveryNote(emailHistoricDeliveryNoteRequest: EmailHistoricDeliveryNoteRequest): Promise<boolean> {
+    let success: boolean = await this.connector.emailHistoricDeliveryNote(emailHistoricDeliveryNoteRequest);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    return success;
+  }
+
+  public async pdfDeliveryNote(pdfDeliveryNoteRequest: PdfDeliveryNoteRequest, localPrint: boolean = false): Promise<boolean> {
+    this.transactionEventService.updatingSalesOrderDelivery.next(true);
+    let success: boolean = await this.connector.pdfDeliveryNote(pdfDeliveryNoteRequest, localPrint);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    this.transactionEventService.updatingSalesOrderDelivery.next(false);
+    return success;
+  }
+
+  public async pdfHistoricDeliveryNote(pdfHistoricDeliveryNoteRequest: PdfHistoricDeliveryNoteRequest, localPrint: boolean = false): Promise<boolean> {
+    let success: boolean = await this.connector.pdfHistoricDeliveryNote(pdfHistoricDeliveryNoteRequest, localPrint);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    return success;
+  }
+
+  public async printDeliveryNote(printDeliveryNoteRequest: PrintDeliveryNoteRequest): Promise<CoDocument | boolean> {
+    this.transactionEventService.updatingSalesOrderDelivery.next(true);
+    let result: CoDocument | boolean = await this.connector.printDeliveryNote(printDeliveryNoteRequest);
+    if (result && !(result instanceof CoDocument)) {
+      await this.commitAndRefreshTransaction();
+    }
+    this.transactionEventService.updatingSalesOrderDelivery.next(false);
+    return result;
+  }
+
+  public async printDeliveryNotes(printDeliveryNotesRequest: PrintDeliveryNotesRequest): Promise<CoDocument | boolean> {
+    this.transactionEventService.updatingSalesOrderDelivery.next(true);
+    let result: CoDocument | boolean = await this.connector.printDeliveryNotes(printDeliveryNotesRequest);
+    this.transactionEventService.updatingSalesOrderDelivery.next(false);
+    return result;
+  }
+
+  public async printHistoricDeliveryNote(printHistoricDeliveryNoteRequest: PrintHistoricDeliveryNoteRequest): Promise<boolean> {
+    let success: boolean = await this.connector.printHistoricDeliveryNote(printHistoricDeliveryNoteRequest);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    return success;
+  }
+
+  public async getDeliveryNoteDefaultSendMethod(relationId: number): Promise<number> {
+    return await this.connector.getDeliveryNoteDefaultSendMethod(relationId);
+  }
+
+  public async getDeliveryNoteEmailLayouts(transactionUUID: string): Promise<ReportLayoutSelectionEmail[]> {
+    return await this.connector.getDeliveryNoteEmailLayouts(transactionUUID);
+  }
+
+  public async getDeliveryNotePrintLayouts(transactionUUID: string): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getDeliveryNotePrintLayouts(transactionUUID);
+  }
+
+  public async getDefaultEmailAddressListForInvoice(transactionUUID): Promise<string[]> {
+    return await this.connector.getDefaultEmailAddressListForInvoice(transactionUUID);
+  }
+
+  public async emailInvoice(emailInvoiceRequest: EmailInvoiceRequest): Promise<CoDocument | boolean> {
+    this.transactionEventService.updatingInvoice.next(true);
+    let result: CoDocument | boolean = await this.connector.emailInvoice(emailInvoiceRequest);
+    if (result && !(result instanceof CoDocument)) {
+      await this.commitAndRefreshTransaction();
+    }
+    this.transactionEventService.updatingInvoice.next(false);
+    return result;
+  }
+
+  public async emailHistoricInvoice(emailHistoricInvoiceRequest: EmailHistoricInvoiceRequest): Promise<boolean> {
+    let success: boolean = await this.connector.emailHistoricInvoice(emailHistoricInvoiceRequest);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    return success;
+  }
+
+  public async pdfInvoice(pdfInvoiceRequest: PdfInvoiceRequest, localPrint: boolean = false): Promise<boolean> {
+    this.transactionEventService.updatingInvoice.next(true);
+    let success: boolean = await this.connector.pdfInvoice(pdfInvoiceRequest, localPrint);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    this.transactionEventService.updatingInvoice.next(false);
+    return success;
+  }
+
+  public async pdfHistoricInvoice(pdfHistoricInvoiceRequest: PdfHistoricInvoiceRequest, localPrint: boolean = false): Promise<boolean> {
+    let success: boolean = await this.connector.pdfHistoricInvoice(pdfHistoricInvoiceRequest, localPrint);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    return success;
+  }
+
+  public async printInvoice(printInvoiceRequest: PrintInvoiceRequest): Promise<CoDocument | boolean> {
+    this.transactionEventService.updatingInvoice.next(true);
+    let result: CoDocument | boolean = await this.connector.printInvoice(printInvoiceRequest);
+    if (result && !(result instanceof CoDocument)) {
+      await this.commitAndRefreshTransaction();
+    }
+    this.transactionEventService.updatingInvoice.next(false);
+    return result;
+  }
+
+  public async printHistoricInvoice(printHistoricInvoiceRequest: PrintHistoricInvoiceRequest): Promise<boolean> {
+    let success: boolean = await this.connector.printHistoricInvoice(printHistoricInvoiceRequest);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    return success;
+  }
+
+  public async getInvoiceDefaultSendMethod(relationId: number): Promise<number> {
+    return await this.connector.getInvoiceDefaultSendMethod(relationId);
+  }
+
+  public async getDropshipmentInfosByRelationId(relationId: number): Promise<DropshipmentInfo[]> {
+    return await this.connector.getDropshipmentInfosByRelationId(relationId);
+  }
+
+  public async insertNewDropshipmentInfo(request: DropshipmentInfo): Promise<void> {
+    return await this.connector.insertNewDropshipmentInfo(request);
+  }
+
+  public async changeHeaderDropshipmentInfo(request: ChangeHeaderDropshipmentInfoRequest): Promise<TransactionInfoResponse> {
+    return await this.connector.changeHeaderDropshipmentInfo(request);
+  }
+
+  public async pdfPosReceipt(pdfPosReceiptRequest: PdfPosReceiptRequest, localPrint: boolean = false): Promise<boolean> {
+    return await this.connector.pdfPosReceipt(pdfPosReceiptRequest, localPrint);
+  }
+
+  public async pdfHistoricPosReceipt(pdfHistoricPosReceiptRequest: PdfHistoricPosReceiptRequest, localPrint: boolean = false): Promise<boolean> {
+    return await this.connector.pdfHistoricPosReceipt(pdfHistoricPosReceiptRequest, localPrint);
+  }
+
+  public async printPosReceipt(printPosReceiptRequest: PrintPosReceiptRequest): Promise<boolean> {
+    return await this.connector.printPosReceipt(printPosReceiptRequest);
+  }
+
+  public async printHistoricPosReceipt(printHistoricPosReceiptRequest: PrintHistoricPosReceiptRequest): Promise<boolean> {
+    return await this.connector.printHistoricPosReceipt(printHistoricPosReceiptRequest);
+  }
+
+  public async emailPosReceipt(emailPosReceiptRequest: EmailPosReceiptRequest): Promise<boolean> {
+    return await this.connector.emailPosReceipt(emailPosReceiptRequest);
+  }
+
+  public async emailHistoricPosReceipt(emailHistoricPosReceiptRequest: EmailHistoricPosReceiptRequest): Promise<boolean> {
+    return await this.connector.emailHistoricPosReceipt(emailHistoricPosReceiptRequest);
+  }
+
+  public async getPosReceiptEmailLayouts(transactionUUID: string): Promise<ReportLayoutSelectionEmail[]> {
+    return await this.connector.getPosReceiptEmailLayouts(transactionUUID);
+  }
+
+  public async getPosReceiptPrintLayouts(transactionUUID: string): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getPosReceiptPrintLayouts(transactionUUID);
+  }
+
+  public async getDefaultEmailAddressListForPosReceipt(transactionUUID: string): Promise<string[]> {
+    return await this.connector.getDefaultEmailAddressListForPosReceipt(transactionUUID);
+  }
+
+  public async getInvoiceEmailLayouts(transactionUUID: string): Promise<ReportLayoutSelectionEmail[]> {
+    return await this.connector.getInvoiceEmailLayouts(transactionUUID);
+  }
+
+  public async getInvoicePrintLayouts(transactionUUID: string): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getInvoicePrintLayouts(transactionUUID);
+  }
+
+  public async getQuotationDefaultSendMethod(relationId: number): Promise<number> {
+    return await this.connector.getQuotationDefaultSendMethod(relationId);
+  }
+
+  public async emailQuotation(emailQuotationRequest: EmailQuotationRequest): Promise<CoDocument | boolean> {
+    this.transactionEventService.updatingSalesOrderQuotation.next(true);
+    let result: CoDocument | boolean = await this.connector.emailQuotation(emailQuotationRequest);
+    if (result && !(result instanceof CoDocument)) {
+      await this.commitAndRefreshTransaction();
+    }
+    this.transactionEventService.updatingSalesOrderQuotation.next(false);
+    return result;
+  }
+
+  public async emailHistoricQuotation(emailHistoricQuotationRequest: EmailHistoricQuotationRequest): Promise<boolean> {
+    let success: boolean = await this.connector.emailHistoricQuotation(emailHistoricQuotationRequest);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    return success;
+  }
+
+  public async pdfQuotation(pdfQuotationRequest: PdfQuotationRequest, localPrint: boolean = false): Promise<boolean> {
+    this.transactionEventService.updatingSalesOrderQuotation.next(true);
+    let success: boolean = await this.connector.pdfQuotation(pdfQuotationRequest, localPrint);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    this.transactionEventService.updatingSalesOrderQuotation.next(false);
+    return success;
+  }
+
+  public async pdfHistoricQuotation(pdfHistoricQuotationRequest: PdfHistoricQuotationRequest, localPrint: boolean = false): Promise<boolean> {
+    let success: boolean = await this.connector.pdfHistoricQuotation(pdfHistoricQuotationRequest, localPrint);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    return success;
+  }
+
+  public async printQuotation(printQuotationRequest: PrintQuotationRequest): Promise<CoDocument | boolean> {
+    this.transactionEventService.updatingSalesOrderQuotation.next(true);
+    let result: CoDocument | boolean = await this.connector.printQuotation(printQuotationRequest);
+    if (result && !(result instanceof CoDocument)) {
+      await this.commitAndRefreshTransaction();
+    }
+    this.transactionEventService.updatingSalesOrderQuotation.next(false);
+    return result;
+  }
+
+  public async printHistoricQuotation(printHistoricQuotationRequest: PrintHistoricQuotationRequest): Promise<boolean> {
+    let success: boolean = await this.connector.printHistoricQuotation(printHistoricQuotationRequest);
+    if (success) {
+      success = await this.commit();
+      await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+    }
+    return success;
+  }
+
+  public async getQuotationEmailLayouts(transactionUUID: string): Promise<ReportLayoutSelectionEmail[]> {
+    return await this.connector.getQuotationEmailLayouts(transactionUUID);
+  }
+
+  public async getQuotationPrintLayouts(transactionUUID: string): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getQuotationPrintLayouts(transactionUUID);
+  }
+
+  public async getDefaultEmailAddressListForQuotation(transactionUUID: string): Promise<string[]> {
+    return await this.connector.getDefaultEmailAddressListForQuotation(transactionUUID);
+  }
+
+  public async getPackageStickerPrintLayouts(): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getPackageStickerPrintLayouts();
+  }
+
+  public async getReservationStickerPrintLayouts(): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getReservationStickerPrintLayouts();
+  }
+
+  public async getOrderingStickerPrintLayouts(): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getOrderingStickerPrintLayouts();
+  }
+
+  public async getDocsToSignForTrans(request: GetDocsToSignForTransRequest): Promise<ReportListObject[]> {
+    return await this.connector.getDocsToSignForTrans(request);
+  }
+
+  public async getPrinters(): Promise<Printer[]> {
+    return await this.connector.getPrinters();
+  }
+
+  public async getDefaultPrinter(reportId: number, type: string): Promise<string> {
+    return await this.connector.getDefaultPrinter(reportId, type);
+  }
+
+  public async getPrinterCopiesAmount(reportId: number, type: string, printerName: string): Promise<string> {
+    return await this.connector.getPrinterCopiesAmount(reportId, type, printerName);
+  }
+
+  public async getPackageInformation(transactionUUID: string, lineUUID: string): Promise<PackageLSP[]> {
+    return this.connector.getPackageInformation(transactionUUID, lineUUID);
+  }
+
+  public async getCashTypes(type: string): Promise<CashType[]> {
+    return await this.connector.getCashTypes(type);
+  }
+
+  public async getPosGroups(): Promise<PosGroup[]> {
+    return await this.connector.getPosGroups();
+  }
+
+  public async getCurrencies(active: boolean = true): Promise<Currency[]> {
+    return await this.connector.getCurrencies(active);
+  }
+
+  public async getProjectCodes(date: Date): Promise<ProjectCode[]> {
+    return await this.connector.getProjectCodes(date);
+  }
+
+  public async getAllProjectCodes(): Promise<ProjectCode[]> {
+    return await this.connector.getAllProjectCodes();
+  }
+
+  public async addProjectCode(projectCode: ProjectCode): Promise<ProjectCode> {
+    return await this.connector.addProjectCode(projectCode);
+  }
+
+  public async getPaymentConditions(name?: string): Promise<PaymentCondition[]> {
+    return await this.connector.getPaymentConditions(name);
+  }
+
+  public async getOrderLineSetCategories(): Promise<OrderLineSetCategory[]> {
+    return await this.connector.getOrderLineSetCategories();
+  }
+
+  public async getServiceWizard(): Promise<ServiceWizard> {
+    return await this.connector.getServiceWizard();
+  }
+
+  public async upsertServiceWizard(request: ServiceWizard): Promise<void> {
+    return await this.connector.upsertServiceWizard(request);
+  }
+
+  public async getServiceTypes(): Promise<ServiceType[]> {
+    return await this.connector.getServiceTypes();
+  }
+
+  public async addOrderLineSet(request: TransactionAddOrderLineSetTextLineRequest): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.addOrderLineSet(request);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    } else {
+      return false;
+    }
+  }
+
+  public async updateOrderLineSet(request: OrderLineSetDTO): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.updateOrderLineSet(request);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    } else {
+      return false;
+    }
+  }
+
+  public async changeTransactionLineOrderLineSet(uuid: string, lineUuid: string, code: string): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineOrderLineSet(uuid, lineUuid, code);
+      if (response) {
+        this.transactionDirty = true;
+        return this.handleLineOperationStatuses(response);
+      }
+      return false;
+    }
+  }
+
+  public async getJoinedTags(table: string, key: string): Promise<TagTreeItem[]> {
+    return await this.connector.getJoinedTags(table, key);
+  }
+
+  public async mergeJoinedTags(table: string, key: string, tags: TagTreeItem[]): Promise<boolean> {
+    return await this.connector.mergeJoinedTags(table, key, tags);
+  }
+
+  public async getTagsFullTree(category: TagCategory, includeTags: boolean): Promise<TagTreeItem[]> {
+    return await this.connector.getTagsFullTree(category, includeTags);
+  }
+
+  public async getInternalDefault(param: InternalDefault): Promise<string> {
+    return await this.connector.getInternalDefaultValue(param);
+  }
+
+  public async getObjectConfiguration(screenCfgModule: string, params?: string | string[], insertMode?: boolean): Promise<ObjectConfiguration[]> {
+    return await this.connector.getObjectConfiguration(screenCfgModule, params, insertMode);
+  }
+
+  public async getHistoricDocuments(transId: number, documentCode: LayoutCode, headerOnly: boolean = true): Promise<HistoricReport[]> {
+    return await this.connector.getHistoricDocuments(transId, documentCode, headerOnly);
+  }
+
+  public async getReportHeadersByTransIdAndLayoutCode(transId: number, documentCode: LayoutCode): Promise<HistoricReport[]> {
+    return await this.connector.getReportHeadersByTransIdAndLayoutCode(transId, documentCode);
+  }
+
+  public async undoDeliveryByReportId(reportId: number): Promise<DataServiceResponseData> {
+    return await this.connector.undoDeliveryByReportId(reportId);
+  }
+
+  public async getDefaultEmailAddressListForPurchaseOrder(uuid: string): Promise<string[]> {
+    return await this.connector.getDefaultEmailAddressListForPurchaseOrder(uuid);
+  }
+
+  public createReceiveOrderRequest(date: Date, packingSlipNr: string): ReceiveGoodsForOrderRequest {
+    const selectedLines: TransactionLineInfo[] = this.currentTransaction.transactionLines.filter((line) => line.selected);
+    if (selectedLines.length > 0) {
+      const receivedGoodsRequest: ReceiveGoodsForOrderRequest = new ReceiveGoodsForOrderRequest();
+      receivedGoodsRequest.transId = this.currentTransaction.transactionInfo.id;
+      receivedGoodsRequest.receivedDate = date;
+      receivedGoodsRequest.packingSlipNr = packingSlipNr;
+      receivedGoodsRequest.orderLineReceiptDetailsDTOS = [];
+      selectedLines.forEach((line) => {
+        const detail: PurchaseOrderLineReceiptDetails = new PurchaseOrderLineReceiptDetails();
+        detail.lineNr = line.lineNr;
+        detail.quantityToReceive = line.articleLineStatus.quantityToReceive;
+        detail.warehouseNr = line.warehouseNumber;
+        detail.locationNr = line.locationNr;
+        detail.batchNr = line.batchNr;
+        detail.numberOfColli = line.chosenPackageAmount;
+        detail.quantityOfStickersPerColli = line.quantityOfStickersPerColli;
+        detail.printerName = line.printerName;
+        detail.reportId = line.reportId;
+        receivedGoodsRequest.orderLineReceiptDetailsDTOS.push(detail);
+      });
+      return receivedGoodsRequest;
+    } else {
+      this.dialogService.showError('SELECTED_LINES_NOT_FOUND', true);
+      return null;
+    }
+  }
+
+  public createReceiveInterbranchOrderRequest(date: Date, packingSlipNr: string): ReceiveGoodsForOrderRequest {
+    const selectedLines: TransactionLineInfo[] = this.currentTransaction.transactionLines.filter((line) => line.selected);
+    if (selectedLines.length > 0) {
+      const receivedGoodsRequest: ReceiveGoodsForOrderRequest = new ReceiveGoodsForOrderRequest();
+      receivedGoodsRequest.transId = this.currentTransaction.transactionInfo.id;
+      receivedGoodsRequest.receivedDate = date;
+      receivedGoodsRequest.packingSlipNr = packingSlipNr;
+      receivedGoodsRequest.orderLineReceiptDetailsDTOS = [];
+      selectedLines.forEach((line) => {
+        const detail: PurchaseOrderLineReceiptDetails = new PurchaseOrderLineReceiptDetails();
+        detail.lineNr = line.lineNr;
+        detail.quantityToReceive = line.articleLineStatus.quantityToReceive;
+        detail.warehouseNr = this.currentTransaction.transactionInfo.targetWarehouseNumber;
+        detail.locationNr = line.locationNr;
+        detail.batchNr = line.batchNr;
+        detail.numberOfColli = line.chosenPackageAmount;
+        detail.printerName = line.printerName;
+        detail.reportId = line.reportId;
+        receivedGoodsRequest.orderLineReceiptDetailsDTOS.push(detail);
+      });
+      return receivedGoodsRequest;
+    } else {
+      this.dialogService.showError('SELECTED_LINES_NOT_FOUND', true);
+      return null;
+    }
+  }
+
+  public async handleReceiveSelectedPurchaseOrders(date: Date, packingSlipNr: string): Promise<boolean> {
+    const selectedLines: TransactionLineInfo[] = this.currentTransaction.transactionLines.filter((line) => line.selected);
+    if (selectedLines.length > 0) {
+      const receivedGoodsRequest: ReceiveGoodsForOrderRequest = new ReceiveGoodsForOrderRequest();
+      receivedGoodsRequest.transId = this.currentTransaction.transactionInfo.id;
+      receivedGoodsRequest.receivedDate = date;
+      receivedGoodsRequest.packingSlipNr = packingSlipNr;
+      //receivedGoodsRequest.printerName = this.currentTransaction.transactionInfo.printerName;
+      //receivedGoodsRequest.reportId = this.currentTransaction.transactionInfo.reportId;
+      //receivedGoodsRequest.saveDefaultPrinterForAllUsers = this.currentTransaction.transactionInfo.saveDefaultPrinterForAllUsers;
+      //receivedGoodsRequest.saveDefaultPrinterForUser = this.currentTransaction.transactionInfo.saveDefaultPrinterForUser;
+      receivedGoodsRequest.orderLineReceiptDetailsDTOS = [];
+      selectedLines.forEach((line) => {
+        const detail: PurchaseOrderLineReceiptDetails = new PurchaseOrderLineReceiptDetails();
+        detail.lineNr = line.lineNr;
+        detail.quantityToReceive = line.articleLineStatus.quantityToReceive;
+        detail.warehouseNr = line.warehouseNumber;
+        detail.locationNr = line.locationNr;
+        detail.batchNr = line.batchNr;
+        detail.numberOfColli = line.chosenPackageAmount;
+        //detail.numberOfStickers = line.stickerAmount;
+        detail.printerName = line.printerName;
+        detail.reportId = line.reportId;
+        receivedGoodsRequest.orderLineReceiptDetailsDTOS.push(detail);
+      });
+      return this.receiveGoodsForPurchaseOrder(
+        this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version, receivedGoodsRequest);
+    }
+    return false;
+  }
+
+  public async handleAllocateSelectedPurchaseOrders(): Promise<boolean> {
+    const selectedLines: TransactionLineInfo[] = this.currentTransaction.transactionLines.filter((line) => line.selected);
+    if (selectedLines.length > 0) {
+      const allocateGoodsRequest: AllocateGoodsForSalesOrderRequest = new AllocateGoodsForSalesOrderRequest();
+      allocateGoodsRequest.transId = this.currentTransaction.transactionInfo.id;
+      allocateGoodsRequest.salesOrderLineAllocationDetailsDTOS = [];
+      selectedLines.forEach((line) => {
+        const detail: SalesOrderLineAllocationDetails = new SalesOrderLineAllocationDetails();
+        detail.lineNr = line.lineNr;
+        detail.quantityToAllocate = line.quantityToAllocate;
+        detail.warehouseNr = line.warehouseNumber;
+        detail.locationNr = line.locationNr;
+        allocateGoodsRequest.salesOrderLineAllocationDetailsDTOS.push(detail);
+      });
+      return this.allocateGoodsForSalesOrder(
+        this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version, allocateGoodsRequest);
+    }
+    return false;
+  }
+
+  public async handleSetSelectedLinesToBePicked(pickingDate: Date): Promise<void> {
+    const selectedLines: TransactionLineInfo[] = this.currentTransaction.transactionLines.filter((line) => line.selected && line.quantityToBePicked > 0);
+    if (selectedLines.length > 0) {
+      const goodsToBePickedRequest: GoodsToBePickedForOrderRequest = new GoodsToBePickedForOrderRequest();
+      goodsToBePickedRequest.transId = this.currentTransaction.transactionInfo.id;
+      goodsToBePickedRequest.toBePickedDate = pickingDate;
+      goodsToBePickedRequest.lines = [];
+      selectedLines.forEach((line) => {
+        const detail: GoodsToBePickedForOrderRequestLine = new GoodsToBePickedForOrderRequestLine();
+        detail.lineNr = line.lineNr;
+        detail.quantity = line.quantityToBePicked;
+        goodsToBePickedRequest.lines.push(detail);
+      });
+      this.setGoodsToBePickedForSalesOrder(
+        this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version, goodsToBePickedRequest);
+    }
+  }
+
+  public async handleSetSelectedLinesToPick(): Promise<void> {
+    const selectedLines: TransactionLineInfo[] = this.currentTransaction.transactionLines.filter((line) => line.selected && line.quantityPicked > 0);
+    if (selectedLines.length > 0) {
+      const goodsPickedRequest: GoodsPickedRequest = new GoodsPickedRequest();
+      goodsPickedRequest.transId = this.currentTransaction.transactionInfo.id;
+      goodsPickedRequest.lines = [];
+      selectedLines.forEach((line) => {
+        const detail: GoodsPickedRequestLine = new GoodsPickedRequestLine();
+        detail.lineNr = line.lineNr;
+        detail.quantity = line.quantityPicked;
+        goodsPickedRequest.lines.push(detail);
+      });
+      this.setGoodsPickedForOrder(
+        this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version, goodsPickedRequest);
+    }
+  }
+
+  public getPurchaseOrderForTransactionLine(transId: number, lineNr: number): Promise<TransactionInfoHistory[]> {
+    return this.getTransactionInfo(transId, lineNr);
+  }
+
+  public async commitAndRefreshTransaction(): Promise<void> {
+    await this.commit();
+    await this.getTransactionById(this.currentTransaction.transactionInfo.id);
+  }
+
+  public async checkBranch(): Promise<void> {
+    // Be able to create purchase orders for other branches
+    if (this.currentBranch && this.transactionKind !== TransactionKind.PurchaseOrder) {
+      return;
+    }
+    const response: DialogResponseInterface = await this.dialogService.showBranch();
+    if (response.button !== AppPopupButtonType.Cancel) {
+      this.currentBranch = response.output ? response.output.toString() : undefined;
+    }
+  }
+
+  public async getTransactionMarginInfo(transactionUUID: string): Promise<TransactionMarginInfo> {
+    return await this.connector.getTransactionMarginInfo(transactionUUID);
+  }
+
+  public async printSalesOrdersOverview(request: TransactionSearchViewRequest): Promise<PdfTransactionSearchOverviewResponse> {
+    return this.connector.printSalesOrdersOverview(request);
+  }
+
+  public async loadDocumentsOfTransaction(key: string): Promise<CoDocument[]> {
+    return this.connector.loadDocumentsOfTransaction(key);
+  }
+
+  public async loadDocumentContent(docId: number, thumbnail: boolean = true): Promise<string> {
+    return this.connector.loadDocumentContent(docId, thumbnail);
+  }
+
+  public async mergeDocumentOnTransaction(key: string, document: CoDocument): Promise<CoDocument> {
+    return this.connector.mergeDocumentOnTransaction(key, document);
+  }
+
+  public async deleteDocument(documentId: number): Promise<ValidationResult> {
+    return this.connector.deleteDocument(documentId);
+  }
+
+  /*  public lockDocument(documentId: number): Promise<boolean> {
+      return this.connector.lockDocument(CoDocument, documentId);
+    }*/
+
+  public async getOrderLinesPlanned(request: OrderLinesPlannedRequest): Promise<PlanOrderLine[]> {
+    return this.connector.getOrderLinesPlanned(request);
+  }
+
+  public async getPlanOrder(transId: number): Promise<PlanOrder> {
+    return await this.connector.getPlanOrder(transId);
+  }
+
+  public async getDistricts(): Promise<District[]> {
+    return await this.connector.getDistricts();
+  }
+
+  public async insertActivity(activity: Activity): Promise<ValidationResult> {
+    return await this.connector.insertActivity(activity);
+  }
+
+  public async updateActivity(activity: Activity): Promise<boolean> {
+    return await this.connector.updateActivity(activity);
+  }
+
+  public async deleteActivity(activity: Activity): Promise<boolean> {
+    return await this.connector.deleteActivity(activity);
+  }
+
+  public async getActivitiesForTransaction(transactionId: number): Promise<Activity[]> {
+    const activeActivities: Activity[] = await this.connector.getComponentActivitiesWithoutRelationFiltering(transactionId);
+    const historicActivities: Activity[] = await this.connector.getHistoricActivities(transactionId);
+    if (activeActivities && activeActivities.length !== 0 && historicActivities && historicActivities.length !== 0) {
+      return activeActivities.concat(historicActivities);
+    } else if (activeActivities && activeActivities.length !== 0) {
+      return activeActivities;
+    } else if (historicActivities && historicActivities.length !== 0) {
+      return historicActivities;
+    } else {
+      return null;
+    }
+  }
+
+  public async getHistoricActivities(transactionId: number): Promise<Activity[]> {
+    return await this.connector.getHistoricActivities(transactionId);
+  }
+
+  public async getComponentActivitiesWithoutRelationFiltering(transactionId: number): Promise<Activity[]> {
+    return await this.connector.getComponentActivitiesWithoutRelationFiltering(transactionId);
+  }
+
+  public async fireTrigger(workFlowProcessId: number, sequence: number, triggerId: number): Promise<ValidationResult> {
+    return await this.connector.fireTrigger(workFlowProcessId, sequence, triggerId);
+  }
+
+  public async fireGenericTrigger(workFlowProcessId: number, genericTransitionId: number, relationId: number): Promise<ValidationResult> {
+    return await this.connector.fireGenericTrigger(workFlowProcessId, genericTransitionId, relationId);
+  }
+
+  public async lockTask(id: number): Promise<boolean> {
+    return await this.connector.lockTask(id);
+  }
+
+  public async getLineIndicesByTransId(transId: number): Promise<TransactionLineSearchIndex[]> {
+    return await this.connector.getLineIndicesByTransId(transId);
+  }
+
+  public async convertCashRegisterOrderToSalesOrder(): Promise<void> {
+    if (this.currentTransaction.transactionInfo.uuid) {
+      const response: DialogResponseInterface = await this.dialogService.showYesNo(
+        'CONVERT_CASH_REGISTER_ORDER_TO_SALESORDER_HEAD',
+        'CONVERT_CASH_REGISTER_ORDER_TO_SALESORDER_QUESTION');
+      const shouldConvert: boolean = response.button === AppPopupButtonType.Yes;
+      if (shouldConvert) {
+        const lockSuccess: boolean =
+          await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+        if (lockSuccess) {
+          const response: TransactionInfoResponse = await this.connector.convertCashRegisterOrderToSalesOrder(this.currentTransaction.transactionInfo.uuid);
+          let success: boolean = await this.handleHeaderOperationStatuses(response, false);
+          if (success) {
+            // return response.transactionInfo.transactionNr;
+            this.saveTransactionAndCommit().then(saved => {
+              if (saved) {
+                this.transactionEventService.createdSalesOrderFromCashRegisterOrder.next(response.transactionInfo.transactionNr);
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+
+  public async reprintCashRegisterReceipt(): Promise<void> {
+    this.dialogService.showReprintCashRegisterReceiptPopup(this.currentTransaction);
+  }
+
+  public resetDataForServiceFromSalesTransactionLine() {
+    this._transForServiceFromSalesTransactionLine = null;
+    this._lineNrForServiceFromSalesTransactionLine = null;
+  }
+
+  public async getSalesOrderLines(request: OrderReservationSalesOrderLinesRequest): Promise<PurchaseReservation[]> {
+    return await this.connector.getSalesOrderLines(request);
+  }
+
+  public async processReservation(request: ProcessOrderReservationRequest): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.processReservation(request);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response);
+    } else {
+      return false;
+    }
+  }
+
+  public async undoReservation(transId: number, lineId: number): Promise<boolean> {
+    return await this.connector.undoReservation(transId, lineId);
+  }
+
+  public async getSLACategories(): Promise<SLAProduct[]> {
+    return await this.connector.getSLACategories();
+  }
+
+  public async getSLAProducts(): Promise<SLAProduct[]> {
+    return await this.connector.getSLAProducts();
+  }
+
+  public async getTermsAndConditionsForm(transId: number): Promise<void> {
+    return await this.connector.getTermsAndConditionsForm(transId);
+  }
+
+  public async getTransactionPlanPeriods(transId: number): Promise<PlanTimes[]> {
+    return await this.connector.getTransactionPlanPeriods(transId);
+  }
+
+  public async getAgendaEventsPerDayForPreferredPlanning(transId: number): Promise<AgendaEventPerDay[]> {
+    let planTimes: PlanTimes[] = await this.getTransactionPlanPeriods(transId);
+    return this._createEventsPerDayFromPlanTimes(planTimes);
+  }
+
+  private _createEventsPerDayFromPlanTimes(planTimes: PlanTimes[]):AgendaEventPerDay[] {
+    const eventsPerDay: AgendaEventPerDay[] = [];
+    if (planTimes && planTimes.length > 0) {
+      const len: number = planTimes.length;
+      for (let i: number = 0; i < len; i++) {
+        eventsPerDay.push(this._createAgendaEventPerDayFromPlanTimes(planTimes[i]));
+      }
+    }
+    return eventsPerDay;
+  }
+
+  private _createAgendaEventPerDayFromPlanTimes(planTimes: PlanTimes): AgendaEventPerDay {
+    const agendaEvent: AgendaEventPerDay = new AgendaEventPerDay();
+    agendaEvent.date = new Date(planTimes.planDate);
+    agendaEvent.events = [];
+    const len: number = planTimes.dayParts.length;
+    for (let i: number = 0; i < len; i++) {
+      const dayPart: PlanDaypart = planTimes.dayParts[i];
+      if (dayPart.available) {
+        agendaEvent.events.push(this._createAgendaEventFromDayPart(dayPart, agendaEvent.date));
+      }
+    }
+    return agendaEvent;
+  }
+
+  private _createAgendaEventFromDayPart(dayPart: PlanDaypart, date: Date): AgendaEvent {
+    const event: AgendaEvent = new AgendaEvent();
+    event.id = dayPart.dayPartId;
+    event.dayPartNo = dayPart.dayPartNo;
+    event.checked = dayPart.active;
+    event.showCheckbox = true;
+    event.date = new Date(date);
+    const from: Date = new Date(date);
+    from.setHours(dayPart.timeHourStart);
+    event.from = from;
+    const to: Date = new Date(date);
+    to.setHours(dayPart.timeHourStop);
+    event.to = to;
+    event.fromString = event.from.toLocaleTimeString();
+    event.toString = event.to.toLocaleTimeString();
+    event.fromToRepresentation = event.fromString + " - " + event.toString;
+    event.timeWindow = dayPart.onlinePlanning;
+    event.description = dayPart.dayPartDescription;
+    return event;
+  }
+
+  public async getSupplierProducts(transId: number): Promise<SupplierProduct[]> {
+    return await this.connector.getSupplierProducts(transId);
+  }
+
+  public async getDeliveryDateForSupplierProduct(goodId: number, supplierId: number): Promise<Date> {
+    return await this.connector.getDeliveryDateForSupplierProduct(goodId, supplierId);
+  }
+
+  public async getPlannedResourcesForTransactionLine(transId: number, lineNr: number): Promise<PlannedResourceForTransactionLine[]> {
+    return await this.connector.getPlannedResourcesForTransactionLine(transId, lineNr);
+  }
+
+  public async getVoucherInfo(voucherCode: string, toCurrencyCode?: string): Promise<Voucher> {
+    return await this.connector.getVoucherInfo(voucherCode, toCurrencyCode);
+  }
+
+  public async getFirstConfirmedDeliveryDateForTransactionLine(transId: number, lineNr: number): Promise<Date> {
+    return await this.connector.getFirstConfirmedDeliveryDateForTransactionLine(transId, lineNr);
+  }
+
+  public async getServiceOrderEmailLayouts(transactionUUID: string): Promise<ReportLayoutSelectionEmail[]> {
+    return await this.connector.getServiceOrderEmailLayouts(transactionUUID);
+  }
+
+  public async getServiceOrderPrintLayouts(transactionUUID: string): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getServiceOrderPrintLayouts(transactionUUID);
+  }
+
+  public async getDefaultEmailAddressListForServiceOrder(transactionUUID): Promise<string[]> {
+    return await this.connector.getDefaultEmailAddressListForServiceOrder(transactionUUID);
+  }
+
+  public async printServiceOrder(request: PrintServiceOrderRequest): Promise<void> {
+    return await this.connector.printServiceOrder(request);
+  }
+
+  public async printHistoricServiceOrder(request: PrintHistoricServiceOrderRequest): Promise<boolean> {
+    return await this.connector.printHistoricServiceOrder(request);
+  }
+
+  public async emailServiceOrder(request: EmailServiceOrderRequest): Promise<void> {
+    return await this.connector.emailServiceOrder(request);
+  }
+
+  public async emailHistoricServiceOrder(request: EmailHistoricServiceOrderRequest): Promise<boolean> {
+    return await this.connector.emailHistoricServiceOrder(request);
+  }
+
+  public async pdfServiceOrder(request: PdfServiceOrderRequest, localPrint: boolean = false): Promise<void> {
+    return await this.connector.pdfServiceOrder(request, localPrint);
+  }
+
+  public async pdfHistoricServiceOrder(request: PdfHistoricServiceOrderRequest, localPrint: boolean = false): Promise<boolean> {
+    return await this.connector.pdfHistoricServiceOrder(request, localPrint);
+  }
+
+  public async getServiceOrderDefaultSendMethod(relationId: number): Promise<number> {
+    return await this.connector.getServiceOrderDefaultSendMethod(relationId);
+  }
+
+  public async getCashRegistersForTransaction(transactionUUID: string): Promise<CashRegister[]> {
+    return await this.connector.getCashRegistersForTransaction(transactionUUID);
+  }
+
+  public async getLspPackageInfoPrintLayouts(showLoader?: boolean): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getLspPackageInfoPrintLayouts(showLoader);
+  }
+
+  public async printLspPackageInfo(request: PrintLspPackageInfoRequest, showLoader?: boolean): Promise<void> {
+    return await this.connector.printLspPackageInfo(request);
+  }
+
+  public async printDeliveryNoteForLspPackage(request: LspWmsDeliveryNotePrintRequest, showLoader?: boolean): Promise<void> {
+    return await this.connector.printDeliveryNoteForLspPackage(request);
+  }
+
+  public async getRouteDeparture(request: GetRouteDepartureRequest, showLoader?: boolean): Promise<string> {
+    return await this.connector.getRouteDeparture(request);
+  }
+
+  public async changeHeadersTransactionsDefinitive(request: ChangeHeadersTransactionsDefinitiveRequest, showLoader?: boolean): Promise<void> {
+    return await this.connector.changeHeadersTransactionsDefinitive(request);
+  }
+
+  public async generateInterbranchOrders(selectionList: StockReplenishment[], showLoader?: boolean): Promise<boolean> {
+    let success: boolean = await this.connector.generateInterbranchOrders(selectionList);
+    if (success) {
+      success = await this.commit();
+    }
+    return success;
+  }
+
+  public async setTransportNotificationOnSelectedLines(request: SetTransportNotificationOnSelectedLinesRequest): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      request = this.addSelectedLineDetailsToTransportNotificationRequest(request);
+      const response: TransactionInfoResponse = await this.connector.setTransportNotificationOnSelectedLines(request);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response, true);
+    } else {
+      return false;
+    }
+  }
+
+  public async renewTransportNotificationOnSelectedLines(request: RenewTransportNotificationOnSelectedLinesRequest): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      request = this.addSelectedLineDetailsToTransportNotificationRequest(request);
+      const response: TransactionInfoResponse = await this.connector.renewTransportNotificationOnSelectedLines(request);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response, true);
+    } else {
+      return false;
+    }
+  }
+
+  private addSelectedLineDetailsToTransportNotificationRequest(request: SetTransportNotificationOnSelectedLinesRequest | RenewTransportNotificationOnSelectedLinesRequest): SetTransportNotificationOnSelectedLinesRequest | RenewTransportNotificationOnSelectedLinesRequest {
+    const selectedLines: TransactionLineInfo[] = this.currentTransaction.transactionLines.filter((line) => line.selected);
+    request.selectedLines = [];
+    if (selectedLines.length > 0) {
+      selectedLines.forEach((line) => {
+        const lineRequest: TransportNotificationLineSelectRequest = new TransportNotificationLineSelectRequest();
+        lineRequest.lineNr = line.lineNr;
+        lineRequest.arrivalDate = line.arrivalDateForTransportNotification;
+        lineRequest.reference = line.referenceForTransportNotification;
+        lineRequest.quantity = line.quantityForTransportNotification;
+        request.selectedLines.push(lineRequest);
+      });
+    }
+    return request;
+  }
+
+  public async setTransportNotification(request: SetTransportNotificationLineRequest): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.setTransportNotification(request);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response, true);
+    } else {
+      return false;
+    }
+  }
+
+  public async setTransportNotificationInContainerOnSelectedLines(request: SetTransportNotificationInContainerOnSelectedLinesRequest): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.setTransportNotificationInContainerOnSelectedLines(request);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response, true);
+    } else {
+      return false;
+    }
+  }
+
+  public async setTransportNotificationInContainer(request: SetTransportNotificationLineInContainerRequest): Promise<boolean> {
+    const lockSuccess: boolean =
+      await this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version);
+    if (lockSuccess) {
+      const response: TransactionInfoResponse = await this.connector.setTransportNotificationInContainer(request);
+      this.transactionDirty = true;
+      return this.handleLineOperationStatuses(response, true);
+    } else {
+      return false;
+    }
+  }
+
+  public async getTransportNotificationInfosByTransactionLine(lineUuid: string, showLoader?: boolean): Promise<TransportNotificationInfo[]> {
+    return await this.connector.getTransportNotificationInfosByTransactionLine(lineUuid);
+  }
+
+  public async getTransportNotificationTotalsByTransactionLine(lineUuid: string, showLoader?: boolean): Promise<TransportNotificationTotals> {
+    return await this.connector.getTransportNotificationTotalsByTransactionLine(lineUuid);
+  }
+
+  public async getContainers(showLoader?: boolean): Promise<Container[]> {
+    return await this.connector.getContainers();
+  }
+
+  public async getContainer(containerId: number, showLoader?: boolean): Promise<Container> {
+    return await this.connector.getContainer(containerId);
+  }
+
+  public async getContainerInfo(containerId: number, showLoader?: boolean): Promise<ContainerInfo> {
+    return await this.connector.getContainerInfo(containerId);
+  }
+
+  public async getContainerTypes(showLoader?: boolean): Promise<ContainerType[]> {
+    return await this.connector.getContainerTypes();
+  }
+
+  public async createContainer(container: Container, showLoader?: boolean): Promise<Container> {
+    return await this.connector.createContainer(container);
+  }
+
+  public async updateContainer(container: Container, showLoader?: boolean): Promise<Container> {
+    return await this.connector.updateContainer(container);
+  }
+
+  public async getCashPaymentValueByTransId(transId: number, showLoader?: boolean): Promise<number> {
+    return await this.connector.getCashPaymentValueByTransId(transId);
+  }
+
+  public async getContactMoments(table: TableName, key: string, showLoader?: boolean): Promise<ContactMoment[]> {
+    return await this.connector.getContactMoments(table, key);
+  }
+
+  public async mergeContactMoments(mergeContactMomentsRequest: MergeContactMomentsRequest, showLoader?: boolean): Promise<ContactMoment[]> {
+    return await this.connector.mergeContactMoments(mergeContactMomentsRequest);
+  }
+
+  public async printWorkOrder(printWorkOrderRequest: PrintWorkOrderRequest, showLoader?: boolean): Promise<CoDocument | boolean> {
+    return await this.connector.printWorkOrder(printWorkOrderRequest);
+  }
+
+  public async printHistoricWorkOrder(printHistoricWorkOrderRequest: PrintHistoricWorkOrderRequest, showLoader?: boolean): Promise<boolean> {
+    return await this.connector.printHistoricWorkOrder(printHistoricWorkOrderRequest);
+  }
+
+  public async startWorkOrderBatch(batchTransactionSendingRequest: BatchTransactionSendingRequest, showLoader?: boolean): Promise<void> {
+    return await this.connector.startWorkOrderBatch(batchTransactionSendingRequest);
+  }
+
+  public async emailWorkOrder(emailWorkOrderRequest: EmailWorkOrderRequest, showLoader?: boolean): Promise<CoDocument | boolean> {
+    return await this.connector.emailWorkOrder(emailWorkOrderRequest);
+  }
+
+  public async emailHistoricWorkOrder(emailHistoricWorkOrderRequest: EmailHistoricWorkOrderRequest, showLoader?: boolean): Promise<boolean> {
+    return await this.connector.emailHistoricWorkOrder(emailHistoricWorkOrderRequest);
+  }
+
+  public async pdfWorkOrder(pdfWorkOrderRequest: PdfWorkOrderRequest, localPrint: boolean = false, showLoader?: boolean): Promise<boolean> {
+    return await this.connector.pdfWorkOrder(pdfWorkOrderRequest, localPrint);
+  }
+
+  public async pdfHistoricWorkOrder(pdfHistoricWorkOrderRequest: PdfHistoricWorkOrderRequest, showLoader?: boolean): Promise<boolean> {
+    return await this.connector.pdfHistoricWorkOrder(pdfHistoricWorkOrderRequest);
+  }
+
+  public async getWorkOrderEmailLayouts(transactionUUID: string, showLoader?: boolean): Promise<ReportLayoutSelectionEmail[]> {
+    return await this.connector.getWorkOrderEmailLayouts(transactionUUID);
+  }
+
+  public async getWorkOrderPrintLayouts(transactionUUID: string, showLoader?: boolean): Promise<ReportLayoutSelectionPrint[]> {
+    return await this.connector.getWorkOrderPrintLayouts(transactionUUID);
+  }
+
+  public async getWorkOrderDefaultSendMethod(relationId: number, showLoader?: boolean): Promise<number> {
+    return await this.connector.getWorkOrderDefaultSendMethod(relationId);
+  }
+
+  public async getDefaultEmailAddressListForWorkOrder(transactionUUID: string, showLoader?: boolean): Promise<string[]> {
+    return await this.connector.getDefaultEmailAddressListForWorkOrder(transactionUUID);
+  }
+
+  public async previewWorkOrder(pdfWorkOrderRequest: PdfWorkOrderRequest, showLoader?: boolean): Promise<PdfWorkOrderResponse> {
+    return await this.connector.previewWorkOrder(pdfWorkOrderRequest);
+  }
+
+  public async sendPackageInformationToLSP(request: TransactionLspInformationRequest): Promise<TransactionInfoResponse> {
+    return await this.connector.sendPackageInformationToLSP(request);
+  }
+
+  public async roundUp( amount: number , paymentMethodCode: string, showLoader?: boolean): Promise<number> {
+    return await this.connector.roundUp(amount, paymentMethodCode, showLoader)
+  }
+
+  protected async _handleBeforeRememberCurrentTransaction(transactionInfoResponse: TransactionInfoResponse): Promise<void> {
+    this.prepareManualSaveInternalParam();
+    this.prepareMLocatInternalParam();
+    this.preparePakBinnenInternalParam();
+    this.prepareDropShipmentInternalParam();
+    this.prepareReceiveGoodsWithDataTerminalInternalParam();
+    this.preparePrintColliStickerDefault();
+    this.prepareDirectSellInternalParam();
+    this.prepareCanChangeSalesOrderWhenFullyInvoicedParam();
+    this.prepareCanChangeRelationParam();
+  }
+
+  protected async _handleAfterRememberCurrentTransaction(): Promise<void> {
+    this.remainingAmount = 0;
+  }
+
+  private _checkAndSaveLinesForAIConfirmation(transactionId: number, analysisId: number, lines: TransactionLineInfo[]): Promise<boolean> {
+    if (transactionId && analysisId && lines && lines.length > 0) {
+      const selectedLinesForAI: TransactionLineInfo[] = lines.filter(l => l.linkedAnalysisResultId !== null && l.linkedAnalysisResultId !== undefined);
+      const orderConfirmationTransactionLinks: OrderConfirmationTransactionLink[] = [];
+      selectedLinesForAI.forEach(l => {
+        const orderConfirmationTransactionLink: OrderConfirmationTransactionLink = new OrderConfirmationTransactionLink();
+        orderConfirmationTransactionLink.transactionId = transactionId;
+        orderConfirmationTransactionLink.transactionLineNumber = l.lineNr;
+        orderConfirmationTransactionLink.orderConfirmationAnalysisResultId = l.linkedAnalysisResultId;
+        orderConfirmationTransactionLinks.push(orderConfirmationTransactionLink);
+      });
+      return this.connector.linkTransactionToOrderConfirmation(analysisId, orderConfirmationTransactionLinks);
+    }
+    return Promise.resolve(true);
+  }
+
+  private async _checkAndAddRelationTransaction(): Promise<boolean> {
+    if (this.currentTransaction && this.currentTransaction.transactionInfo && this.relation && !this.currentTransaction.transactionInfo.relation) {
+      return this.saveRelation();
+    }
+  }
+
+  private async _checkAndCreateTransaction(rememberTransaction: boolean = true): Promise<boolean> {
+    if (!this.currentTransaction || !this.currentTransaction.transactionInfo || !this.currentTransaction.transactionInfo.transactionNr) {
+      const createMethod: CreateTransactionFn = this._createTransactionMethods.get(this.transactionKind || TransactionKind.SalesOrder);
+      if (createMethod) {
+        const rememberRelation: boolean = this.getRelationOnRememberCurrentTransaction;
+        this.getRelationOnRememberCurrentTransaction = false;
+        const request: CreateTransactionRequest = new CreateTransactionRequest();
+        return await createMethod(request)
+          .then(() => {
+            this.getRelationOnRememberCurrentTransaction = rememberRelation;
+            return true;
+          })
+          .catch(() => {
+            this.getRelationOnRememberCurrentTransaction = rememberRelation;
+            return false;
+          });
+      } else {
+        throwError('Failed to create transaction');
+      }
+    } else {
+      return Promise.resolve(true);
+    }
+  }
+
+}