@colijnit/transaction 12.1.77 → 12.1.79

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

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

package/projects/transaction/src/lib/service/relation-connector.service.ts

@@ -0,0 +1,202 @@
+import {Injectable} from "@angular/core";
+import {OptionsService} from "./options.service";
+import {BusinessObjectFactory} from "@colijnit/ioneconnector/build/factory/business-object-factory";
+import {RelationApi} from "@colijnit/relationapi";
+import {CustomerFullObject} from "@colijnit/relationapi/build/model/customer-full-object.bo";
+import {SupplierFullObject} from "@colijnit/relationapi/build/model/supplier-full-object.bo";
+import {ErrorService} from "./error.service";
+import {DataServiceResponseData} from "@colijnit/ioneconnector/build/model/data-service-response-data";
+import {RelationRequest} from "@colijnit/relationapi/build/model/relation-request";
+import {RelationListObject} from "@colijnit/relationapi/build/model/relation-list-object.bo";
+import {BranchLov} from "@colijnit/relationapi/build/model/branch-lov.bo";
+import {ValidationResult} from "@colijnit/ioneconnector/build/model/validation-result";
+import {TransactionEventService} from "./transaction-event.service";
+
+@Injectable({
+  providedIn: "root"
+})
+export class RelationConnectorService {
+  public connector: RelationApi;
+
+  private _boFactory: BusinessObjectFactory = new BusinessObjectFactory();
+
+  constructor(
+    private _optionsService: OptionsService,
+    private _errorService: ErrorService,
+    private _transactionEventService: TransactionEventService
+  ) {
+    this._transactionEventService.connectionInitialized.subscribe((initialized: boolean) => {
+      if (initialized) {
+        this.connect();
+      }
+    })
+  }
+
+  public async connect(): Promise<void> {
+    this.connector = new RelationApi(this._optionsService.options);
+  }
+
+  public async getCustomerFullObject(relationNo: number): Promise<CustomerFullObject> {
+    const result: DataServiceResponseData = await this.connector.getCustomerFullObject(relationNo);
+    if (result.validationResult && result.validationResult.success) {
+      return this._boFactory.makeWithRawBackendData(CustomerFullObject, result.resultObject) as unknown as CustomerFullObject;
+    } else {
+      this._handleExceptionFromResponse(result);
+      return null;
+    }
+  }
+
+  public async getSupplierFullObject(relationNo: number): Promise<SupplierFullObject> {
+    const result: DataServiceResponseData = await this.connector.getSupplierFullObject(relationNo);
+    if (result.validationResult && result.validationResult.success) {
+      return this._boFactory.makeWithRawBackendData(SupplierFullObject, result.resultObject) as unknown as SupplierFullObject;
+    } else {
+      this._handleExceptionFromResponse(result);
+      return null;
+    }
+  }
+
+  public async getRelationListObjects(relationRequest: RelationRequest): Promise<RelationListObject[]> {
+    const result: DataServiceResponseData = await this.connector.getRelationListObjects(relationRequest);
+    if (result.validationResult && result.validationResult.success) {
+      return this._boFactory.makeBOArrayFromRawBackendDataArray(RelationListObject, result.resultObjects) as unknown as RelationListObject[];
+    } else {
+      this._handleExceptionFromResponse(result);
+      return [];
+    }
+  }
+
+  public async getRelationNumber(relationId: number): Promise<string> {
+    const result: DataServiceResponseData = await this.connector.getRelationNumber(relationId);
+    if (result.validationResult && result.validationResult.success) {
+      return result.resultObject;
+    } else {
+      this._handleExceptionFromResponse(result);
+      return "";
+    }
+  }
+
+  public async getBranches(branchNr?: string): Promise<BranchLov[]> {
+    const result: DataServiceResponseData = await this.connector.getBranches(branchNr);
+    if (result.validationResult && result.validationResult.success) {
+      return this._boFactory.makeBOArrayFromRawBackendDataArray(BranchLov, result.resultObjects) as unknown as BranchLov[];
+    } else {
+      this._handleExceptionFromResponse(result);
+      return [];
+    }
+  }
+
+  public async commit(): Promise<boolean> {
+    const result: DataServiceResponseData = await this.connector.commit();
+    if (result) {
+      return true;
+    } else {
+      this._handleExceptionFromResponse(result);
+      return false;
+    }
+  }
+
+  public lockCustomerFullObject(relationNr: number): Promise<ValidationResult> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.connector.lockCustomerById(relationNr).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public lockSupplierFullObject(relationNr: number): Promise<ValidationResult> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.connector.lockSupplierById(relationNr).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public lockEmployeeFullObject(relationNr: number): Promise<ValidationResult> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.connector.lockEmployeeById(relationNr).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public lockBranchFullObject(relationNr: number): Promise<ValidationResult> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.connector.lockBranchById(relationNr).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public lockCompanyFullObject(relationNr: number): Promise<ValidationResult> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.connector.lockCompanyById(relationNr).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public lockContactPerson(relationNr: number): Promise<ValidationResult> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.connector.lockContactPersonById(relationNr).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public async insertCustomer(relation: CustomerFullObject): Promise<CustomerFullObject> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.connector.insertCustomer(relation).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(this._boFactory.makeWithRawBackendData(CustomerFullObject, result.resultObject));
+        } else {
+          this._handleExceptionFromResponse(result);
+          reject(null);
+        }
+      });
+    });
+  }
+
+  public async updateCustomer(relation: CustomerFullObject): Promise<CustomerFullObject> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.connector.updateCustomer(relation).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(this._boFactory.makeWithRawBackendData(CustomerFullObject, result.resultObject));
+        } else {
+          this._handleExceptionFromResponse(result);
+          reject(null);
+        }
+      });
+    });
+  }
+
+  public async insertSupplier(relation: SupplierFullObject): Promise<SupplierFullObject> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.connector.insertSupplier(relation).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(this._boFactory.makeWithRawBackendData(SupplierFullObject, result.resultObject));
+        } else {
+          this._handleExceptionFromResponse(result);
+          reject(null);
+        }
+      });
+    });
+  }
+
+  public async updateSupplier(relation: SupplierFullObject): Promise<SupplierFullObject> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.connector.updateSupplier(relation).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(this._boFactory.makeWithRawBackendData(SupplierFullObject, result.resultObject));
+        } else {
+          this._handleExceptionFromResponse(result);
+          reject(null);
+        }
+      });
+    });
+  }
+
+  private _handleExceptionFromResponse(result: DataServiceResponseData): void {
+    this._errorService.showValidationError(result);
+  }
+}