@colijnit/transaction 12.1.77 → 12.1.78

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

@@ -0,0 +1,848 @@
+import {Injectable} from "@angular/core";
+import {DiscountType} from "@colijnit/transactionapi/build/enum/discount-type.enum";
+import {PendingReasonType} from "@colijnit/transactionapi/build/enum/pending-reason-type.enum";
+import {SequenceName} from "@colijnit/transactionapi/build/enum/sequence-name.enum";
+import {TransactionLineType} from "@colijnit/transactionapi/build/enum/transaction-line-type.enum";
+import {ArticleFullObject} from "@colijnit/transactionapi/build/model/article-full-object";
+import {CashRegister} from "@colijnit/transactionapi/build/model/cash-register";
+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 {LineOperationStatus} from "@colijnit/transactionapi/build/model/line-operation-status.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 {TransactionSearchViewRequest} from "@colijnit/transactionapi/build/model/transaction-search-view-request";
+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 {ReceiveGoodsForPurchaseOrderRequest} from "@colijnit/transactionapi/build/model/receive-goods-for-purchase-order-request.bo";
+import {GoodsReceiptStatusWithHistory} from "@colijnit/transactionapi/build/model/goods-receipt-status-with-history.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 {GetPurchasePortalLine} from "@colijnit/transactionapi/build/model/get-purchase-portal-line";
+import {PurchasePortalLine} from "@colijnit/transactionapi/build/model/purchase-portal-line.bo";
+import {TransactionSearchResult} from "../model/transaction-search-result";
+import {GetPurchaseOrderConfirmation} from "@colijnit/transactionapi/build/model/get-purchase-order-confirmation";
+import {TransactionLockResult} from "@colijnit/transactionapi/build/model/transaction-lock-result.bo";
+import {DataServiceResponseData} from "@colijnit/ioneconnector/build/model/data-service-response-data";
+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 {DeliveryOrderStatus} from "@colijnit/transactionapi/build/model/delivery-order-status.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 {GoodsAllocationStatus} from "@colijnit/transactionapi/build/model/goods-allocation-status.bo";
+import {GoodsAllocationStatusWithHistory} from "@colijnit/transactionapi/build/model/goods-allocation-status-with-history.bo";
+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 {PrintOrderConfirmationRequest} from "@colijnit/mainapi/build/model/print-order-confirmation-request";
+import {EmailOrderConfirmationRequest} from "@colijnit/mainapi/build/model/email-order-confirmation-request";
+import {PdfOrderConfirmationRequest} from "@colijnit/mainapi/build/model/pdf-order-confirmation-request";
+import {PrintPurchaseOrderRequest} from "@colijnit/mainapi/build/model/print-purchase-order-request";
+import {EmailPurchaseOrderRequest} from "@colijnit/mainapi/build/model/email-purchase-order-request";
+import {PdfPurchaseOrderRequest} from "@colijnit/mainapi/build/model/pdf-purchase-order-request";
+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 {TransactionTypeCategory} from "../enum/transaction-type-category.enum";
+
+type CreateTransactionFn = (request: CreateSalesOrderRequest | CreatePurchaseOrderRequest) => Promise<boolean>;
+
+@Injectable({
+  providedIn: "root"
+})
+export class TransactionService extends PendingReasonService {
+
+  private readonly _createTransactionMethods: Map<TransactionKind, CreateTransactionFn> = new Map<TransactionKind, CreateTransactionFn>([
+    [TransactionKind.SalesOrder, (request: CreateSalesOrderRequest) => this.createSalesOrder(request)],
+    [TransactionKind.PurchaseOrder, (request: CreatePurchaseOrderRequest) => this.createPurchaseOrder(request)]
+  ])
+
+  private readonly _relationKindFromTransactionKind: Map<TransactionKind, RelationKind> = new Map<TransactionKind, RelationKind>([
+    [TransactionKind.SalesOrder, RelationKind.Customer],
+    [TransactionKind.PurchaseOrder, RelationKind.Supplier]
+  ]);
+
+  private readonly _focusStatusIndex: Map<TransactionTypeCategory, number> = new Map<TransactionTypeCategory, number>([
+    [TransactionTypeCategory.SalesOrderPurchase, 0],
+    [TransactionTypeCategory.SalesOrderAllocation, 1],
+    [TransactionTypeCategory.SalesOrderDeliveryNote, 7],
+    [TransactionTypeCategory.SalesOrderInvoice, 8]
+  ]);
+
+  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 pendingLineOperationStatus(lineOperationStatuses: LineOperationStatus[]): LineOperationStatus | undefined {
+    const status: LineOperationStatus = lineOperationStatuses.find(line => line.pendingReasonType !== PendingReasonType.NONE
+      && line.pendingReasonType !== PendingReasonType.NON_CRITICAL_DISCONTINUATION);
+    return status;
+  }
+
+  public async updatePriceTransactionLine(uuid: string, lineUuid: string, price: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLinePrice(uuid, lineUuid, price);
+    if (response) {
+      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) {
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateGoodDescriptionTransactionLine(uuid: string, lineUuid: string, goodDescription: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineGoodDescription(uuid, lineUuid, goodDescription);
+    if (response) {
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDefinitive(uuid: string, definitive: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDefinitive(uuid, definitive);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderDeliveryAddress(uuid: string, newNawNr: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderDeliveryAddress(uuid, newNawNr);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderInvoiceAddress(uuid: string, newNawNr: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderInvoiceAddress(uuid, newNawNr);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDeliveryDate(uuid: string, date: Date): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDeliveryDate(uuid, date);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDeliveryDateDefinitive(uuid: string, definitive: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDeliveryDateDefinitive(uuid, definitive);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionRemark(uuid: string, remark: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionRemark(uuid, remark);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionReference(uuid: string, reference: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionReference(uuid, reference);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionRelationReference(uuid: string, reference: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionRelationReference(uuid, reference);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDownpaymentAmount(uuid: string, amount: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderToDownPayAmount(uuid, amount);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDownpaymentPercentage(uuid: string, amount: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderToDownPayPercentage(uuid, amount);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionPreferredDeliveryDate(uuid: string, date: Date): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionPreferredDeliveryDate(uuid, date);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDeliveryMethod(uuid: string, method: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDeliveryMethod(uuid, method);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDeliveryOptions(uuid: string, options: string[]): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDeliveryOptions(uuid, options);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionPartialDelivery(uuid: string, allowPartial: boolean): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionPartialDelivery(uuid, allowPartial);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionBranch(uuid: string, branch: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionBranch(uuid, branch);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionAdmCoordinator(uuid: string, relation: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionAdmCoordinator(uuid, relation);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionMarketing(uuid: string, code: string): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionMarketing(uuid, code);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateHeaderTransactionDiscount(uuid: string, type: DiscountType, amount: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeHeaderTransactionDiscount(uuid, type, amount);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateQuantityTransactionLine(uuid: string, lineUuid: string, quantity: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineQuantity(uuid, lineUuid, quantity);
+    if (response) {
+      return this.handleLineOperationStatuses(response);
+    }
+    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) {
+      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) {
+      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) {
+      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) {
+      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) {
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async updateWarehouseTransactionLine(uuid: string, lineUuid: string, warehouseNumber: number): Promise<boolean> {
+    const response: TransactionInfoResponse | boolean = await this.connector.changeTransactionLineWarehouse(uuid, lineUuid, warehouseNumber);
+    if (response) {
+      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) {
+      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) {
+      return this.handleLineOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public async generateCommissionOrders(transId: number, onlyGenerateForDirectSellSuppliers: boolean): Promise<boolean> {
+    this.transactionEventService.generateCommissionOrders.next(true);
+    const response = await this.connector.generateCommissionOrders(transId, onlyGenerateForDirectSellSuppliers);
+    this.transactionEventService.generateCommissionOrders.next(false);
+    return response;
+  }
+
+  public searchTransactions(request: TransactionSearchViewRequest): Promise<TransactionSearchResult> {
+    return this.connector.searchTransactions(request);
+  }
+
+  public async saveRelation(): Promise<boolean> {
+    // this._cleanRelationBeforeSave();
+    this.initializeTransaction();
+    if (!this.relation.relationId) {
+      this.relation = await this.relationService.insertRelation(this._relationKindFromTransactionKind.get(this.transactionKind), this.relation);
+    } else {
+      this.relation = await this.relationService.updateRelation(this._relationKindFromTransactionKind.get(this.transactionKind), this.relation);
+    }
+    if (!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> {
+    return new Promise<boolean>((resolve: Function) => {
+      // todo fix this
+      request.branchNr = "1";
+      this.connector.createSalesOrder(request).then((response: TransactionInfoResponse) => {
+        this.rememberCurrentTransaction(response);
+        resolve(true);
+      });
+    });
+  }
+
+  public async createCashRegisterOrder(request: CreateCashRegisterOrderRequest): Promise<boolean> {
+    return new Promise<boolean>((resolve: Function) => {
+      this.connector.createCashRegisterOrder(request).then((response: TransactionInfoResponse) => {
+        this.rememberCurrentTransaction(response);
+        resolve(true);
+      });
+    });
+  }
+
+  public async createPurchaseOrder(request: CreatePurchaseOrderRequest): Promise<boolean> {
+    return new Promise<boolean>((resolve: Function) => {
+      // todo fix this
+      request.branchNr = "1";
+      this.connector.createPurchaseOrder(request).then((response: TransactionInfoResponse) => {
+        this.rememberCurrentTransaction(response);
+        resolve(true);
+      });
+    });
+  }
+
+  public async createServiceOrder(request: CreateServiceOrderRequest): Promise<boolean> {
+    return new Promise<boolean>((resolve: Function) => {
+      // todo fix this
+      request.branchNr = "1";
+      this.connector.createServiceOrder(request).then((response: TransactionInfoResponse) => {
+        this.rememberCurrentTransaction(response);
+        resolve(true);
+      });
+    });
+  }
+
+  public async createSalesQuotation(request: CreateSalesQuotationRequest): Promise<boolean> {
+    return new Promise<boolean>((resolve: Function) => {
+      this.connector.createSalesQuotation(request).then((response: TransactionInfoResponse) => {
+        this.rememberCurrentTransaction(response);
+        resolve(true);
+      });
+    });
+  }
+
+  public async getTransactionById(transactionId: number): Promise<void> {
+    const transactionInfoResponse: TransactionInfoResponse = await this.connector.getTransactionById(transactionId);
+    if (transactionInfoResponse.isSuccess) {
+      this.rememberCurrentTransaction(transactionInfoResponse);
+    }
+  }
+
+  public async tryToLockTransaction(id: number, version: number, secondAttempt: boolean = false): Promise<boolean> {
+    const lockResponse: TransactionLockResult = await this._lockTransaction(id, version);
+    if (lockResponse && !lockResponse.isLockSuccess) {
+      if (secondAttempt) { // something went wrong
+        this.dialogService.showError(this.dictionaryService.get("UNKNOWN_ERROR"));
+        return false;
+      }
+      if (!lockResponse.isLatestVersion) {
+        this.dialogService.showToast(this.dictionaryService.get("TRANSACTION_VERSION_MISMATCH"));
+        await this.getTransactionById(id);
+        this.dialogService.hideToastAfterMs(3000);
+        return this.tryToLockTransaction(this.currentTransaction.transactionInfo.id, this.currentTransaction.transactionInfo.version, true);
+      } else {
+        const lockDetails: string = `${this.dictionaryService.get("BY")}: ${lockResponse.lockedBy}
+              ${this.dictionaryService.get("SINCE", false)} ${lockResponse.lockedSince.toLocaleString()}`;
+        this.dialogService.showError(this.dictionaryService.get("TRANSACTION_ALREADY_LOCKED"), lockDetails);
+        return false;
+      }
+    }
+    return true;
+  }
+
+  public async addRelationToTransaction(relationId: number): Promise<boolean> {
+    await this._checkAndCreateTransaction();
+    const response: TransactionInfoResponse = await this.connector.addRelationToTransaction(this.currentTransaction.transactionInfo.uuid, relationId);
+    if (response) {
+      return this.handleHeaderOperationStatuses(response);
+    }
+    return false;
+  }
+
+  public getCommissionCodes(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getCommissionCodes(languageCode);
+  }
+
+  public getInOutCollection(languageCode: string): Promise<CoDomainValue[]> {
+    return this.connector.getInOutCollection(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 getMainArticles(): Promise<MainArticle[]> {
+    return this.articleConnector.getMainArticles();
+  }
+
+  public getDeliveryMethods(): Promise<DeliveryMethod[]> {
+    return this.connector.getDeliveryMethods();
+  }
+
+  public getDeliveryOptions(): Promise<DeliveryOption[]> {
+    return this.connector.getDeliveryOptions();
+  }
+
+  public getSalesPersons(date?: Date): Promise<SalesPerson[]> {
+    return this.connector.getSalesPersons(date);
+  }
+
+  public async addArticle(
+    articleNo: string,
+    isReturn: boolean = false,
+    aboveLineNr: number = 0,
+    belowLineNr: number = 0
+  ): Promise<boolean> {
+    await this._checkAndCreateTransaction();
+    const response: TransactionInfoResponse = await this.connector.addTransactionLine(
+      this.currentTransaction.transactionInfo.uuid, TransactionLineType.ArticleLine, articleNo, null, isReturn, aboveLineNr, belowLineNr);
+    return this.handleLineOperationStatuses(response);
+  }
+
+  public async addTransactionLine(lineType: TransactionLineType,
+                                  articleNo: string,
+                                  amount: number,
+                                  isReturn?: boolean,
+                                  aboveLineNr?: number,
+                                  belowLineNr?: number): Promise<TransactionInfoResponse> {
+    await this._checkAndCreateTransaction();
+    return new Promise<TransactionInfoResponse>((resolve, reject) => {
+      this.connector.addTransactionLine(this.currentTransaction.transactionInfo.uuid, lineType, articleNo, amount, isReturn, aboveLineNr, belowLineNr)
+        .then(async (response: TransactionInfoResponse) => {
+          this.rememberCurrentTransaction(response);
+          resolve(response);
+        }, (error) => {
+          reject(error);
+        })
+        .catch((reason: ValidationResult) => {
+          resolve(null);
+        });
+    });
+  }
+
+  public async addTextLine(
+    showOnDocuments: number,
+    text: string,
+    amount: number,
+    articleBound: boolean,
+    refArticleLineNr: number,
+    aboveLineNr?: number,
+    belowLineNr?: number): Promise<TransactionInfoResponse> {
+    await this._checkAndCreateTransaction();
+    return new Promise<TransactionInfoResponse>((resolve, reject) => {
+      this.connector.addTextLineToTransaction(this.currentTransaction.transactionInfo.uuid, showOnDocuments, text, amount, articleBound, refArticleLineNr, aboveLineNr, belowLineNr)
+        .then(async (response: TransactionInfoResponse) => {
+          this.rememberCurrentTransaction(response);
+          resolve(response);
+        }, (error) => {
+          reject(error);
+        })
+        .catch((reason: ValidationResult) => {
+          resolve(null);
+        });
+    });
+  }
+
+  public async addTextLineToTransaction(
+    transactionUuid: string,
+    showOnDocuments: number,
+    text: string,
+    amount: number,
+    articleBound: boolean,
+    refArticleLineNr: number,
+    aboveLineNr?: number,
+    belowLineNr?: number): Promise<TransactionInfoResponse> {
+    await this._checkAndCreateTransaction();
+    return new Promise<TransactionInfoResponse>((resolve, reject) => {
+      this.connector.addTextLineToTransaction(transactionUuid, showOnDocuments, text, amount, articleBound, refArticleLineNr, aboveLineNr, belowLineNr)
+        .then(async (response: TransactionInfoResponse) => {
+          resolve(response);
+        }, (error) => {
+          reject(error);
+        })
+        .catch((reason: ValidationResult) => {
+          resolve(null);
+        });
+    });
+  }
+
+  public async changeLineSequence(lineUuid: string, aboveLineNr?: number, belowLineNr?: number): Promise<boolean> {
+    const response: TransactionInfoResponse = await this.connector.changeLineSequence(this.currentTransaction.transactionInfo.uuid, lineUuid, aboveLineNr, belowLineNr);
+    return this.handleLineOperationStatuses(response);
+  }
+
+  public async deleteTransactionLine(transactionUuid: string, TransactionLineUuid: string): Promise<boolean> {
+    const response: TransactionInfoResponse = await this.connector.deleteTransactionLine(transactionUuid, TransactionLineUuid);
+    return this.handleLineOperationStatuses(response);
+  }
+
+  public async changeTransactionLineQuantity(transactionUuid: string, lineUuid: string, newQuantity: number): Promise<boolean> {
+    const response: TransactionInfoResponse = await this.connector.changeTransactionLineQuantity(transactionUuid, lineUuid, newQuantity);
+    return this.handleLineOperationStatuses(response);
+  }
+
+  public async setRelationByUser(username: string, password: string): Promise<boolean> {
+    return new Promise<boolean>((resolve: Function) => {
+      this.connector.setRelationByUser(this.currentTransaction.transactionInfo.uuid, username, password)
+        .then(async (isSuccess: boolean) => {
+          resolve(isSuccess);
+        }).catch((reason: ValidationResult) => {
+        resolve(false);
+      });
+    });
+  }
+
+  // public async setRelationByUser(username: string, password: string): Promise<boolean> {
+  //   const response: boolean = await this.connector.setRelationByUser(this.currentTransaction.uuid, username, password);
+  //   return response;
+  // }
+
+  public async getGoodsReceiptStatus(transId: number, lineNr: number): Promise<GoodsReceiptStatusWithHistory> {
+    return await this.connector.getGoodsReceiptStatus(transId, lineNr);
+  }
+
+  public async getGoodsReceiptStatusWithHistory(transId: number, lineNr: number): Promise<GoodsReceiptStatusWithHistory> {
+    return await this.connector.getGoodsReceiptStatusWithHistory(transId, lineNr);
+  }
+
+  public async receiveGoodsForPurchaseOrder(request: ReceiveGoodsForPurchaseOrderRequest): Promise<TransactionInfoResponse> {
+    return await this.connector.receiveGoodsForPurchaseOrder(request);
+  }
+
+  public async receiveGoodsForPurchaseOrderCorrection(request: ReceiveGoodsForPurchaseOrderCorrectionRequest): Promise<TransactionInfoResponse> {
+    return await this.connector.receiveGoodsForPurchaseOrderCorrection(request);
+  }
+
+  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);
+  }
+
+  public getPriceLists(): Promise<PriceList[]> {
+    return this.connector.getPriceLists();
+  }
+
+  public getVatLists(): Promise<Vat[]> {
+    return this.connector.getVatList();
+  }
+
+  public getTags(category: number): Promise<Tag[]> {
+    return this.connector.getTags(category);
+  }
+
+  public getOnHoldCodes(): Promise<OnHoldCode[]> {
+    return this.connector.getOnHoldCodes();
+  }
+
+  public getWarehouses(branchNr?: string): Promise<Warehouse[]> {
+    return this.connector.getWarehouses(branchNr);
+  }
+
+  public getHistoricStateValues(): Promise<CodeDescription[]> {
+    return this.connector.getHistoricStateValues();
+  }
+
+  public getCustomerGroups(): Promise<CustomerGroup[]> {
+    return this.connector.getCustomerGroups();
+  }
+
+  public async getPurchasePortalLines(request: GetPurchasePortalLine): Promise<PurchasePortalLine[]> {
+    return await this.connector.getPurchasePortalLines(request);
+  }
+
+  public async purchaseOrderConfirmation(purchaseOrderConfirmation: GetPurchaseOrderConfirmation): Promise<DataServiceResponseData> {
+    return await this.connector.purchaseOrderConfirmation(purchaseOrderConfirmation);
+  }
+
+  public async updatePurchasePortalLines(purchasePortalLine: PurchasePortalLine): Promise<DataServiceResponseData> {
+    return await this.connector.updatePurchasePortalLines(purchasePortalLine)
+  }
+
+  public async lockPurchasePortalLines(transIdPurchase: number, lineId: number): Promise<boolean> {
+    return await this.connector.lockPurchasePortalLines(transIdPurchase, lineId);
+  }
+
+  public async getDeliveryOrderStatus(transId: number, lineId: number): Promise<DeliveryOrderStatus> {
+    return await this.connector.getDeliveryOrderStatus(transId, lineId);
+  }
+
+  public async getAvailableStockGroupedByWLBSByTransIdLineNr(transId: number, lineNr: number): Promise<AvailableStock[]> {
+    return await this.connector.getAvailableStockGroupedByWLBSByTransIdLineNr(transId, lineNr);
+  }
+
+  public async allocateGoodsForSalesOrder(request: AllocateGoodsForSalesOrderRequest): Promise<boolean> {
+    return await this.connector.allocateGoodsForSalesOrder(request);
+  }
+
+  public async allocateGoodsForSalesOrderCorrection(request: AllocateGoodsForSalesOrderCorrectionRequest): Promise<boolean> {
+    return await this.connector.allocateGoodsForSalesOrderCorrection(request);
+  }
+
+  public async getGoodsAllocationStatus(transId: number, lineNr: number): Promise<GoodsAllocationStatus> {
+    return await this.connector.getGoodsAllocationStatus(transId, lineNr);
+  }
+
+  public async getGoodsAllocationStatusWithHistory(transId: number, lineNr: number): Promise<GoodsAllocationStatusWithHistory> {
+    return await this.connector.getGoodsAllocationStatusWithHistory(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<void> {
+    return await this.connector.printOrderConfirmation(request);
+  }
+
+  public async emailOrderConfirmation(request: EmailOrderConfirmationRequest): Promise<void> {
+    return await this.connector.emailOrderConfirmation(request);
+  }
+
+  public async pdfOrderConfirmation(request: PdfOrderConfirmationRequest): Promise<void> {
+    return await this.connector.pdfOrderConfirmation(request);
+  }
+
+  public async printPurchaseOrder(request: PrintPurchaseOrderRequest): Promise<void> {
+    return await this.connector.printPurchaseOrder(request);
+  }
+
+  public async emailPurchaseOrder(request: EmailPurchaseOrderRequest): Promise<void> {
+    return await this.connector.emailPurchaseOrder(request);
+  }
+
+  public async pdfPurchaseOrder(request: PdfPurchaseOrderRequest): Promise<void> {
+    return await this.connector.pdfPurchaseOrder(request);
+  }
+
+  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 generateAndSendPurchaseOrdersForSalesOrder(transactionId: number): Promise<void> {
+    return await this.connector.generateAndSendPurchaseOrdersForSalesOrder(transactionId);
+  }
+
+  public async getPurchaseAdviceLines(filters: PurchaseAdviceFilters, goodId?: number): Promise<PurchaseAdviceLine[]> {
+    return await this.connector.getPurchaseAdviceLines(filters, goodId);
+  }
+
+  public async generateAndSendPurchaseOrders(purchaseAdviceLines: PurchaseAdviceLine[]): Promise<boolean> {
+    return await this.connector.generateAndSendPurchaseOrders(purchaseAdviceLines);
+  }
+
+  private _lockTransaction(transId: number, version: number): Promise<TransactionLockResult> {
+    return this.connector.lockTransactionById(transId, version);
+  }
+  public async emailDeliveryNote(emailDeliveryNoteRequest: EmailDeliveryNoteRequest): Promise<boolean> {
+    return await this.connector.emailDeliveryNote(emailDeliveryNoteRequest);
+  }
+
+  public async pdfDeliveryNote(pdfDeliveryNoteRequest: PdfDeliveryNoteRequest): Promise<boolean> {
+    return await this.connector.pdfDeliveryNote(pdfDeliveryNoteRequest);
+  }
+
+  public async printDeliveryNote(printDeliveryNoteRequest: PrintDeliveryNoteRequest): Promise<boolean> {
+    return await this.connector.printDeliveryNote(printDeliveryNoteRequest);
+  }
+
+  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);
+  }
+
+
+// private _cleanRelationBeforeSave(): void {
+  //   ArrayUtils.RemoveElementsByFilter(this.currentTransaction.transactionInfo.relation.contactOptions, ((item: ContactOption) => {
+  //     return isNill(item.value);
+  //   }));
+  // }
+
+  private async _checkAndCreateTransaction(): Promise<void> {
+    if (!this.currentTransaction || !this.currentTransaction.transactionInfo || !this.currentTransaction.transactionInfo.transactionNr) {
+      const createMethod: CreateTransactionFn = this._createTransactionMethods.get(this.transactionKind);
+      if (createMethod) {
+        const request: CreateTransactionRequest = new CreateTransactionRequest();
+        return createMethod.call(this, request);
+      } else {
+        throwError("Failed to create transaction");
+      }
+    }
+  }
+}