@colijnit/transaction 12.1.78 → 12.1.80

package/esm2015/lib/component/transaction-quick-access/transaction-quick-access-received-goods/transaction-quick-access-received-goods.component.js

@@ -0,0 +1,91 @@
+import { __awaiter } from "tslib";
+import { Component, HostBinding, Input, Output, ViewEncapsulation, EventEmitter } from "@angular/core";
+import { TransactionBaseComponent } from "../../core/base/transaction-base.component";
+import { TransactionEventService } from "../../../service/transaction-event.service";
+import { TransactionService } from "../../../service/transaction.service";
+import { IconCacheService } from "../../../service/icon-cache.service";
+import { Icon } from "../../../enum/icon.enum";
+import { TransactionReceiveGoodsService } from "../../transaction-line/transaction-receive-goods-line/service/transaction-receive-goods.service";
+export class TransactionQuickAccessReceivedGoodsComponent extends TransactionBaseComponent {
+    constructor(iconService, _transactionService, _transactionEventService, _receiveGoodsService) {
+        super(_transactionService);
+        this.iconService = iconService;
+        this._transactionService = _transactionService;
+        this._transactionEventService = _transactionEventService;
+        this._receiveGoodsService = _receiveGoodsService;
+        this.icons = Icon;
+        this.localCheckboxState = true;
+        this.awaitingResult = false;
+        this.resultSuccessful = false;
+        this.iconVisible = true;
+        // Route through event service instead
+        this.checkboxValueChanged = new EventEmitter();
+    }
+    showClass() {
+        return true;
+    }
+    ngOnInit() {
+        const timeElapsed = Date.now();
+        this.commitDate = new Date(timeElapsed);
+    }
+    handleCommitEvent(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.iconVisible = false;
+            this.resultSuccessful = false;
+            this.awaitingResult = true;
+            this.resultSuccessful = yield this._receiveGoodsService.handleReceiveSelectedPurchaseOrders(value);
+            this.awaitingResult = false;
+            setTimeout(() => {
+                this.iconVisible = true;
+            }, 600);
+        });
+    }
+    handleSelectAllLines(value) {
+        this._transactionEventService.selectAllLines.next(value);
+    }
+}
+TransactionQuickAccessReceivedGoodsComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-transaction-quick-access-received-goods",
+                template: `
+      <co-input-date
+                     [placeholder]="'CONFIRMED_DATE' | localize"
+                     [(model)]="this.commitDate"
+      ></co-input-date>
+      <co-input-text
+                     [placeholder]="'PACKING_SLIP' | localize"
+                     [(model)]="this.commitReferenceId"
+      ></co-input-text>
+      <co-input-checkbox
+        class="checkbox-wrapper"
+        [(model)]="localCheckboxState"
+        (modelChange)="handleSelectAllLines($event)"
+        ></co-input-checkbox>
+      <div class="buttons">
+        <div class="button-wrapper receive" (click)="handleCommitEvent({date: this.commitDate, id: this.commitReferenceId})">
+          <co-checkmark-overlay [successful]="resultSuccessful" [visible]="awaitingResult"></co-checkmark-overlay>
+          <co-icon class="button-icon" [iconData]="iconService.getIcon(icons.GearSolid)" [class.hidden]="!iconVisible"></co-icon>
+        </div>
+        <div class="button-wrapper print">
+          <co-icon class="button-icon" [iconData]="iconService.getIcon(icons.PrintSolid)"></co-icon>
+          <div class="dots-wrapper"><div class="dot"></div><div class="dot"></div><div class="dot"></div></div>
+        </div>
+      </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+TransactionQuickAccessReceivedGoodsComponent.ctorParameters = () => [
+    { type: IconCacheService },
+    { type: TransactionService },
+    { type: TransactionEventService },
+    { type: TransactionReceiveGoodsService }
+];
+TransactionQuickAccessReceivedGoodsComponent.propDecorators = {
+    commitDate: [{ type: Input }],
+    commitReferenceId: [{ type: Input }],
+    packingSlipId: [{ type: Input }],
+    checkboxValueChanged: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-transaction-quick-access-received-goods",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction-quick-access-received-goods.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/transaction-quick-access/transaction-quick-access-received-goods/transaction-quick-access-received-goods.component.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,YAAY,EAAoB,MAAM,eAAe,CAAC;AACxH,OAAO,EAAC,wBAAwB,EAAC,MAAM,4CAA4C,CAAC;AAEpF,OAAO,EAAC,uBAAuB,EAAC,MAAM,4CAA4C,CAAC;AACnF,OAAO,EAAC,kBAAkB,EAAC,MAAM,sCAAsC,CAAC;AACxE,OAAO,EAAC,gBAAgB,EAAC,MAAM,qCAAqC,CAAC;AACrE,OAAO,EAAC,IAAI,EAAC,MAAM,yBAAyB,CAAC;AAC7C,OAAO,EACL,8BAA8B,EAC/B,MAAM,iGAAiG,CAAC;AA+BzG,MAAM,OAAO,4CAA6C,SAAQ,wBAAwB;IA2BxF,YACS,WAA6B,EAC5B,mBAAuC,EACvC,wBAAiD,EACjD,oBAAoD;QAE5D,KAAK,CAAC,mBAAmB,CAAC,CAAC;QALpB,gBAAW,GAAX,WAAW,CAAkB;QAC5B,wBAAmB,GAAnB,mBAAmB,CAAoB;QACvC,6BAAwB,GAAxB,wBAAwB,CAAyB;QACjD,yBAAoB,GAApB,oBAAoB,CAAgC;QA9B9C,UAAK,GAAgB,IAAI,CAAC;QAWnC,uBAAkB,GAAY,IAAI,CAAC;QACnC,mBAAc,GAAY,KAAK,CAAC;QAChC,qBAAgB,GAAY,KAAK,CAAC;QAClC,gBAAW,GAAY,IAAI,CAAC;QAEnC,sCAAsC;QAE/B,yBAAoB,GACzB,IAAI,YAAY,EAAoD,CAAC;IAcvE,CAAC;IAXM,SAAS;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAWM,QAAQ;QACb,MAAM,WAAW,GAAW,IAAI,CAAC,GAAG,EAAE,CAAC;QACvC,IAAI,CAAC,UAAU,GAAG,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC;IAC1C,CAAC;IAEY,iBAAiB,CAAC,KAA+B;;YAC5D,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;YACzB,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAC9B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,IAAI,CAAC,gBAAgB,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACnG,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;YAC5B,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,WAAW,GAAG,IAAI,CAAA;YACzB,CAAC,EAAE,GAAG,CAAC,CAAC;QACV,CAAC;KAAA;IAEM,oBAAoB,CAAC,KAAc;QACxC,IAAI,CAAC,wBAAwB,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3D,CAAC;;;YAnFF,SAAS,SAAC;gBACT,QAAQ,EAAE,4CAA4C;gBACtD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;GAwBT;gBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;aACtC;;;YAlCO,gBAAgB;YADhB,kBAAkB;YADlB,uBAAuB;YAK7B,8BAA8B;;;yBAmC7B,KAAK;gCAGL,KAAK;4BAGL,KAAK;mCASL,MAAM;wBAIN,WAAW,SAAC,kDAAkD","sourcesContent":["import {Component, HostBinding, Input, Output, ViewEncapsulation, EventEmitter, OnInit, OnDestroy} from \"@angular/core\";\r\nimport {TransactionBaseComponent} from \"../../core/base/transaction-base.component\";\r\nimport {Subscription} from \"rxjs\";\r\nimport {TransactionEventService} from \"../../../service/transaction-event.service\";\r\nimport {TransactionService} from \"../../../service/transaction.service\";\r\nimport {IconCacheService} from \"../../../service/icon-cache.service\";\r\nimport {Icon} from \"../../../enum/icon.enum\";\r\nimport {\r\n  TransactionReceiveGoodsService\r\n} from \"../../transaction-line/transaction-receive-goods-line/service/transaction-receive-goods.service\";\r\n\r\n@Component({\r\n  selector: \"co-transaction-quick-access-received-goods\",\r\n  template: `\r\n      <co-input-date\r\n                     [placeholder]=\"'CONFIRMED_DATE' | localize\"\r\n                     [(model)]=\"this.commitDate\"\r\n      ></co-input-date>\r\n      <co-input-text\r\n                     [placeholder]=\"'PACKING_SLIP' | localize\"\r\n                     [(model)]=\"this.commitReferenceId\"\r\n      ></co-input-text>\r\n      <co-input-checkbox\r\n        class=\"checkbox-wrapper\"\r\n        [(model)]=\"localCheckboxState\"\r\n        (modelChange)=\"handleSelectAllLines($event)\"\r\n        ></co-input-checkbox>\r\n      <div class=\"buttons\">\r\n        <div class=\"button-wrapper receive\" (click)=\"handleCommitEvent({date: this.commitDate, id: this.commitReferenceId})\">\r\n          <co-checkmark-overlay [successful]=\"resultSuccessful\" [visible]=\"awaitingResult\"></co-checkmark-overlay>\r\n          <co-icon class=\"button-icon\" [iconData]=\"iconService.getIcon(icons.GearSolid)\" [class.hidden]=\"!iconVisible\"></co-icon>\r\n        </div>\r\n        <div class=\"button-wrapper print\">\r\n          <co-icon class=\"button-icon\" [iconData]=\"iconService.getIcon(icons.PrintSolid)\"></co-icon>\r\n          <div class=\"dots-wrapper\"><div class=\"dot\"></div><div class=\"dot\"></div><div class=\"dot\"></div></div>\r\n        </div>\r\n      </div>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class TransactionQuickAccessReceivedGoodsComponent extends TransactionBaseComponent implements OnInit {\r\n  public readonly icons: typeof Icon = Icon;\r\n\r\n  @Input()\r\n  public commitDate: Date;\r\n\r\n  @Input()\r\n  public commitReferenceId: string;\r\n\r\n  @Input()\r\n  public packingSlipId: string;\r\n\r\n  public localCheckboxState: boolean = true;\r\n  public awaitingResult: boolean = false;\r\n  public resultSuccessful: boolean = false;\r\n  public iconVisible: boolean = true;\r\n\r\n  // Route through event service instead\r\n  @Output()\r\n  public checkboxValueChanged: EventEmitter<{checkboxValue: boolean, date: Date, id: string}> =\r\n    new EventEmitter<{checkboxValue: boolean, date: Date, id: string}>();\r\n\r\n  @HostBinding(\"class.co-transaction-quick-access-received-goods\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  constructor(\r\n    public iconService: IconCacheService,\r\n    private _transactionService: TransactionService,\r\n    private _transactionEventService: TransactionEventService,\r\n    private _receiveGoodsService: TransactionReceiveGoodsService\r\n  ) {\r\n    super(_transactionService);\r\n  }\r\n\r\n  public ngOnInit(): void {\r\n    const timeElapsed: number = Date.now();\r\n    this.commitDate = new Date(timeElapsed);\r\n  }\r\n\r\n  public async handleCommitEvent(value: {date: Date, id: string}): Promise<void> {\r\n    this.iconVisible = false;\r\n    this.resultSuccessful = false;\r\n    this.awaitingResult = true;\r\n    this.resultSuccessful = await this._receiveGoodsService.handleReceiveSelectedPurchaseOrders(value);\r\n    this.awaitingResult = false;\r\n    setTimeout(() => {\r\n      this.iconVisible = true\r\n    }, 600);\r\n  }\r\n\r\n  public handleSelectAllLines(value: boolean): void {\r\n    this._transactionEventService.selectAllLines.next(value);\r\n  }\r\n}\r\n"]}

package/esm2015/lib/component/transaction-quick-access/transaction-quick-access-received-goods/transaction-quick-access-received-goods.module.js

@@ -0,0 +1,27 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { TransactionQuickAccessReceivedGoodsComponent } from "./transaction-quick-access-received-goods.component";
+import { IconModule, CheckmarkOverlayModule, InputCheckboxModule, InputDatePickerModule, InputTextModule } from "@colijnit/corecomponents_v12";
+import { PipeModule } from "../../../pipe/pipe.module";
+export class TransactionQuickAccessReceivedGoodsModule {
+}
+TransactionQuickAccessReceivedGoodsModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    IconModule,
+                    InputTextModule,
+                    PipeModule,
+                    InputCheckboxModule,
+                    InputDatePickerModule,
+                    CheckmarkOverlayModule
+                ],
+                declarations: [
+                    TransactionQuickAccessReceivedGoodsComponent
+                ],
+                exports: [
+                    TransactionQuickAccessReceivedGoodsComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/transaction-quick-access/transaction-quick-access-send-method-base.component.js

@@ -0,0 +1,110 @@
+import { __awaiter } from "tslib";
+import { Directive } from "@angular/core";
+import { CommunicationType } from "@colijnit/relationapi/build/enum/communication-type.enum";
+import { sendMethodsWithIcon } from "@colijnit/sharedcomponents";
+import { SendMethodType } from "@colijnit/mainapi/build/enum/send-method-type.enum";
+import { TransactionBaseComponent } from "../core/base/transaction-base.component";
+import { Icon } from "../../enum/icon.enum";
+import { TransactionService } from "../../service/transaction.service";
+export class TransactionQuickAccessSendMethodBaseComponent extends TransactionBaseComponent {
+    constructor(service) {
+        super(service);
+        this.service = service;
+        this.icons = Icon;
+        this.sendMethodType = SendMethodType;
+        this.emailLayouts = [];
+        this.printLayouts = [];
+        this.emailAddresses = [];
+        this.showSendMethodDialog = false;
+        this.sendMethods = sendMethodsWithIcon;
+        this.showLoader = false;
+    }
+    ngOnInit() {
+        this._getDefaultSendMethod();
+        this._getEmailLayouts();
+        this._getPrintLayouts();
+    }
+    transactionSet() {
+        this.reportDocumentEmailRequest.transId = this.transactionInfo.id;
+        this.reportDocumentPrintRequest.transId = this.transactionInfo.id;
+        this.reportDocumentPdfRequest.transId = this.transactionInfo.id;
+    }
+    relationSet() {
+        this.emailAddresses.length = 0;
+        const emailContactOptions = this.relation.contactOptions.filter(co => co.type === CommunicationType.Email);
+        const defaultEmailContactOption = emailContactOptions.find(co => co.lowestSequence);
+        this.emailAddresses = emailContactOptions.map(e => e.value);
+        this.getDefaultEmailAddressList().then((addresses) => {
+            if (addresses && addresses.length > 0) {
+                this.reportDocumentEmailRequest.toAddresses = addresses.join(';');
+                this.emailAddresses.push(...addresses);
+            }
+            else {
+                this.reportDocumentEmailRequest.toAddresses = defaultEmailContactOption ? defaultEmailContactOption.value : '';
+            }
+        });
+    }
+    handleSendMethodOkClick(method) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.showSendMethodDialog = false;
+            yield this.handleSend(method);
+            this._setDefaultMethod(method);
+        });
+    }
+    handleSend(method) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.showLoader = true;
+            switch (method) {
+                case SendMethodType.Print:
+                    yield this.printDocument(this.reportDocumentPrintRequest);
+                    this.showLoader = false;
+                    break;
+                case SendMethodType.Email:
+                    yield this.emailDocument(this.reportDocumentEmailRequest);
+                    this.showLoader = false;
+                    break;
+            }
+        });
+    }
+    _getDefaultSendMethod() {
+        this.getDefaultSendMethod().then((method) => {
+            this._setDefaultMethod(method.toString());
+        });
+    }
+    _setDefaultMethod(method) {
+        const sendMethod = this.sendMethods.find(sm => sm.code === method);
+        if (sendMethod) {
+            this.defaultSendMethod = sendMethod.code;
+            this.defaultSendMethodIcon = sendMethod.icon;
+        }
+    }
+    _getEmailLayouts() {
+        this.getEmailLayouts().then((layouts) => {
+            this.emailLayouts = layouts;
+            if (this.emailLayouts && this.emailLayouts.length > 0) {
+                const defaultLayout = this.emailLayouts.find(e => e.isDefault);
+                if (defaultLayout) {
+                    this.reportDocumentEmailRequest.reportId = defaultLayout.reportId;
+                }
+            }
+        });
+    }
+    _getPrintLayouts() {
+        this.getPrintLayouts().then((layouts) => {
+            this.printLayouts = layouts;
+            if (this.printLayouts && this.printLayouts.length > 0) {
+                const defaultLayout = this.printLayouts.find(p => p.isDefault);
+                if (defaultLayout) {
+                    this.reportDocumentPrintRequest.reportId = defaultLayout.reportId;
+                }
+            }
+        });
+    }
+}
+TransactionQuickAccessSendMethodBaseComponent.decorators = [
+    { type: Directive }
+];
+TransactionQuickAccessSendMethodBaseComponent.ctorParameters = () => [
+    { type: TransactionService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction-quick-access-send-method-base.component.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/component/transaction-quick-access/transaction-quick-access-send-method-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, OnInit} from \"@angular/core\";\r\nimport {ReportLayoutSelectionEmail} from \"@colijnit/mainapi/build/model/report-layout-selection-email.bo\";\r\nimport {ReportLayoutSelectionPrint} from \"@colijnit/mainapi/build/model/report-layout-selection-print.bo\";\r\nimport {CommunicationType} from \"@colijnit/relationapi/build/enum/communication-type.enum\";\r\nimport {ContactOption} from \"@colijnit/relationapi/build/model/contact-option.bo\";\r\nimport {sendMethodsWithIcon} from \"@colijnit/sharedcomponents\";\r\nimport {SendMethodType} from \"@colijnit/mainapi/build/enum/send-method-type.enum\";\r\nimport {ReportingDocumentEmailBaseRequest} from \"@colijnit/mainapi/build/model/reporting-document-email-base-request\";\r\nimport {ReportingDocumentPrintBaseRequest} from \"@colijnit/mainapi/build/model/reporting-document-print-base-request\";\r\nimport {ReportingDocumentPdfBaseRequest} from \"@colijnit/mainapi/build/model/reporting-document-pdf-base-request\";\r\nimport {TransactionBaseComponent} from \"../core/base/transaction-base.component\";\r\nimport {Icon} from \"../../enum/icon.enum\";\r\nimport {TransactionService} from \"../../service/transaction.service\";\r\n\r\n@Directive()\r\nexport abstract class TransactionQuickAccessSendMethodBaseComponent extends TransactionBaseComponent implements OnInit {\r\n  public readonly icons: typeof Icon = Icon;\r\n  public readonly sendMethodType: typeof SendMethodType = SendMethodType;\r\n\r\n  public emailLayouts: ReportLayoutSelectionEmail[] = [];\r\n  public printLayouts: ReportLayoutSelectionPrint[] = [];\r\n  public defaultSendMethod: string;\r\n  public defaultSendMethodIcon: string;\r\n  public emailAddresses: string[] = [];\r\n  public showSendMethodDialog: boolean = false;\r\n  public sendMethods = sendMethodsWithIcon;\r\n  public showLoader: boolean = false;\r\n\r\n  protected abstract reportDocumentEmailRequest: ReportingDocumentEmailBaseRequest;\r\n  protected abstract reportDocumentPrintRequest: ReportingDocumentPrintBaseRequest;\r\n  protected abstract reportDocumentPdfRequest: ReportingDocumentPdfBaseRequest;\r\n\r\n  constructor(\r\n    protected readonly service: TransactionService\r\n  ) {\r\n    super(service);\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this._getDefaultSendMethod();\r\n    this._getEmailLayouts();\r\n    this._getPrintLayouts();\r\n  }\r\n\r\n  public transactionSet(): void {\r\n    this.reportDocumentEmailRequest.transId = this.transactionInfo.id;\r\n    this.reportDocumentPrintRequest.transId = this.transactionInfo.id;\r\n    this.reportDocumentPdfRequest.transId = this.transactionInfo.id;\r\n  }\r\n\r\n  public relationSet(): void {\r\n    this.emailAddresses.length = 0;\r\n    const emailContactOptions: ContactOption[] = this.relation.contactOptions.filter(co => co.type === CommunicationType.Email);\r\n    const defaultEmailContactOption: ContactOption = emailContactOptions.find(co => co.lowestSequence);\r\n    this.emailAddresses = emailContactOptions.map(e => e.value);\r\n    this.getDefaultEmailAddressList().then((addresses: string[]) => {\r\n      if (addresses && addresses.length > 0) {\r\n        this.reportDocumentEmailRequest.toAddresses = addresses.join(';');\r\n        this.emailAddresses.push(...addresses);\r\n      } else {\r\n        this.reportDocumentEmailRequest.toAddresses = defaultEmailContactOption ? defaultEmailContactOption.value : '';\r\n      }\r\n    });\r\n  }\r\n\r\n  public async handleSendMethodOkClick(method: string): Promise<void> {\r\n    this.showSendMethodDialog = false;\r\n    await this.handleSend(method);\r\n    this._setDefaultMethod(method);\r\n  }\r\n\r\n  public async handleSend(method: string): Promise<void> {\r\n    this.showLoader = true;\r\n    switch (method) {\r\n      case SendMethodType.Print:\r\n        await this.printDocument(this.reportDocumentPrintRequest);\r\n        this.showLoader = false;\r\n        break;\r\n      case SendMethodType.Email:\r\n        await this.emailDocument(this.reportDocumentEmailRequest);\r\n        this.showLoader = false;\r\n        break;\r\n    }\r\n  }\r\n\r\n  protected abstract printDocument(request: ReportingDocumentPrintBaseRequest);\r\n  protected abstract emailDocument(request: ReportingDocumentEmailBaseRequest);\r\n  protected abstract pdfDocument(request: ReportingDocumentPdfBaseRequest);\r\n  protected abstract getEmailLayouts(): Promise<ReportLayoutSelectionEmail[]>;\r\n  protected abstract getPrintLayouts(): Promise<ReportLayoutSelectionPrint[]>;\r\n  protected abstract getDefaultEmailAddressList(): Promise<string[]>;\r\n  protected abstract getDefaultSendMethod(): Promise<number>;\r\n\r\n  private _getDefaultSendMethod(): void {\r\n    this.getDefaultSendMethod().then((method: number) => {\r\n      this._setDefaultMethod(method.toString());\r\n    });\r\n  }\r\n\r\n  private _setDefaultMethod(method: string): void {\r\n    const sendMethod = this.sendMethods.find(sm => sm.code === method);\r\n    if (sendMethod) {\r\n      this.defaultSendMethod = sendMethod.code;\r\n      this.defaultSendMethodIcon = sendMethod.icon;\r\n    }\r\n  }\r\n\r\n  private _getEmailLayouts(): void {\r\n    this.getEmailLayouts().then((layouts: ReportLayoutSelectionEmail[]) => {\r\n      this.emailLayouts = layouts;\r\n      if (this.emailLayouts && this.emailLayouts.length > 0) {\r\n        const defaultLayout: ReportLayoutSelectionEmail = this.emailLayouts.find(e => e.isDefault);\r\n        if (defaultLayout) {\r\n          this.reportDocumentEmailRequest.reportId = defaultLayout.reportId;\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  private _getPrintLayouts(): void {\r\n    this.getPrintLayouts().then((layouts: ReportLayoutSelectionPrint[]) => {\r\n      this.printLayouts = layouts;\r\n      if (this.printLayouts && this.printLayouts.length > 0) {\r\n        const defaultLayout: ReportLayoutSelectionPrint = this.printLayouts.find(p => p.isDefault);\r\n        if (defaultLayout) {\r\n          this.reportDocumentPrintRequest.reportId = defaultLayout.reportId;\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n}\r\n"]}

package/esm2015/lib/component/transaction-receiving-goods-history/transaction-receiving-goods-history.component.js

@@ -0,0 +1,78 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
+import { TransactionService } from "../../service/transaction.service";
+import { ReceiveGoodsForPurchaseOrderCorrectionRequest } from "@colijnit/transactionapi/build/model/receive-goods-for-purchase-order-correction-request.bo";
+import { PurchaseOrderLineReceiptCorrectionDetails } from "@colijnit/transactionapi/build/model/purchase-order-line-receipt-correction-details.bo";
+export class TransactionReceivingGoodsHistoryComponent {
+    constructor(_service) {
+        this._service = _service;
+        this.reloadReceivingGoodsHistory = new EventEmitter();
+    }
+    set goodsReceiptHistory(value) {
+        if (value) {
+            this._goodsReceiptHistory = value.reverse();
+        }
+    }
+    get goodsReceiptHistory() {
+        return this._goodsReceiptHistory;
+    }
+    showClass() {
+        return true;
+    }
+    handleDeleteSelectedRow(row) {
+        if (row && row.type !== 'correction') {
+            const request = new ReceiveGoodsForPurchaseOrderCorrectionRequest();
+            const correctionDetails = new PurchaseOrderLineReceiptCorrectionDetails();
+            request.allowedToRemovePickedAllocations = false;
+            request.transId = this.transactionInfo.id;
+            request.purchaseOrderLineReceiptCorrectionDetailsDTOS = [correctionDetails];
+            correctionDetails.lineNr = this.transactionLine.lineNr;
+            correctionDetails.quantityToCorrect = row.quantity;
+            correctionDetails.documentId = row.documentId;
+            correctionDetails.documentLineNr = row.lineNumber;
+            this._service.receiveGoodsForPurchaseOrderCorrection(request).then(() => {
+                this.reloadReceivingGoodsHistory.next();
+            });
+        }
+    }
+}
+TransactionReceivingGoodsHistoryComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-transaction-receiving-goods-history",
+                template: `
+    <co-transaction-history-grid
+      [collection]="goodsReceiptHistory"
+      (deleteSelectedRow)="handleDeleteSelectedRow($event)"
+    >
+      <co-simple-grid-column [headerText]="'WAREHOUSE' | localize" [order]="40">
+        <ng-template #template let-row="row">
+          <div class="row-container">
+            <span class="row" [textContent]="row.warehouseNumber"></span>
+            <span class="correction" *ngFor="let correction of row.corrections" [textContent]="correction.warehouseNumber"></span>
+          </div>
+        </ng-template>
+      </co-simple-grid-column>
+
+      <co-simple-grid-column [headerText]="'LOCATION' | localize" [order]="60">
+        <ng-template #template let-row="row">
+          <div class="row-container">
+            <span class="row" [textContent]="row.locationNumber"></span>
+            <span class="correction" *ngFor="let correction of row.corrections" [textContent]="correction.locationNumber"></span>
+          </div>
+        </ng-template>
+      </co-simple-grid-column>
+    </co-transaction-history-grid>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+TransactionReceivingGoodsHistoryComponent.ctorParameters = () => [
+    { type: TransactionService }
+];
+TransactionReceivingGoodsHistoryComponent.propDecorators = {
+    goodsReceiptHistory: [{ type: Input }],
+    transactionInfo: [{ type: Input }],
+    transactionLine: [{ type: Input }],
+    reloadReceivingGoodsHistory: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-transaction-receiving-goods-history",] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/transaction-receiving-goods-history/transaction-receiving-goods-history.module.js

@@ -0,0 +1,30 @@
+import { NgModule } from "@angular/core";
+import { CommonModule, DatePipe } from "@angular/common";
+import { CoreModule } from "../core/core.module";
+import { PipeModule } from "../../pipe/pipe.module";
+import { SimpleGridModule } from "@colijnit/corecomponents_v12";
+import { TransactionHistoryGridModule } from "../transaction-grid/transaction-history-grid/transaction-history-grid.module";
+import { TransactionReceivingGoodsHistoryComponent } from "./transaction-receiving-goods-history.component";
+export class TransactionReceivingGoodsHistoryModule {
+}
+TransactionReceivingGoodsHistoryModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    CoreModule,
+                    PipeModule,
+                    SimpleGridModule,
+                    TransactionHistoryGridModule
+                ],
+                declarations: [
+                    TransactionReceivingGoodsHistoryComponent
+                ],
+                exports: [
+                    TransactionReceivingGoodsHistoryComponent
+                ],
+                providers: [
+                    DatePipe
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/transaction-search/service/filter-request.service.js

@@ -0,0 +1,172 @@
+import { Injectable } from "@angular/core";
+import { TransactionService } from "../../../service/transaction.service";
+import { TransactionSearchService } from "./transaction-search.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./transaction-search.service";
+import * as i2 from "../../../service/transaction.service";
+export class FilterRequestService {
+    constructor(searchService, _transactionService) {
+        this.searchService = searchService;
+        this._transactionService = _transactionService;
+    }
+    /**
+     * @param collection collection of FilterItemViewmodels
+     * @param modelName name of the model, has to match with a property of TransactionSearchViewRequest
+     * @sets searchRequest in following format: modelName: "?='20191',?='27053'"
+     */
+    handleCollectionChangeForRange(collection, modelName) {
+        this.searchService.searchRequest[modelName] = this._getFilterRequestForCollectionRange(collection);
+    }
+    /**
+     * @param collection collection of FilterItemViewmodels
+     * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest
+     * @sets searchRequest in following format:  modelName: ['0', '1']
+     */
+    handleCollectionChangeForArray(collection, modelName) {
+        this.searchService.searchRequest[modelName] = this._getFilterRequestForCollectionArray(collection);
+    }
+    /**
+     * @param value value of selected item
+     * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest
+     * @sets searchRequest in following format:  modelName: 2
+     */
+    handleCollectionChangeForSingleNumber(value, modelName) {
+        this.searchService.searchRequest[modelName] = value;
+    }
+    /**
+     * @param collection collection of FilterItemViewmodels
+     * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest
+     * @sets searchRequest in following format:  modelName: 2
+     */
+    handleCollectionChangeForSingleSelect(collection, modelName) {
+        this.searchService.searchRequest[modelName] = this._getFilterRequestForSingleSelect(collection);
+    }
+    /**
+     * @param value value of (un)checked item
+     * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest
+     * @sets searchRequest in following format:  modelName: "?='J'"
+     */
+    handleCheckboxValueChangeForString(value, modelName) {
+        this.searchService.searchRequest[modelName] = this._getFilterRequestForBooleanToString(value);
+    }
+    /**
+     * @param value value of (un)checked item
+     * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest
+     * @sets searchRequest in following format:  modelName: 1
+     */
+    handleCheckboxValueChangeForNumber(value, modelName) {
+        this.searchService.searchRequest[modelName] = value ? 1 : 0;
+    }
+    /**
+     * @param dates an array with a startDate and an endDate
+     * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest
+     * @sets searchRequest in following format:  modelName: "?>='01-08-2022'& ?<='31-08-2022'"
+     */
+    handleDateRangeChange(dates, modelName) {
+        if (dates) {
+            let startDate = dates[0];
+            let endDate = dates[1];
+            this.searchService.searchRequest[modelName] = this._getFilterRequestForDateRange(startDate, endDate);
+        }
+    }
+    /**
+     * @param filterRequestRange a date range in string format
+     * @param index the index of which date should be returned
+     * @returns the requested date in Date format
+     */
+    getDateFromFilterRequestRange(filterRequestRange, index) {
+        if (filterRequestRange) {
+            const datePattern = new RegExp('\\d{2}\\-\\d{2}\\-\\d{4}');
+            let dateString = filterRequestRange
+                .split(',')[index]
+                .match(datePattern)[0];
+            const day = Number(dateString.match('^\\d{2}')[0]);
+            const month = Number(dateString.match('(?<=\\-)(\\d{2})(?=\\-)')[0]) - 1;
+            const year = Number(dateString.match('\\d{4}')[0]);
+            return new Date(year, month, day);
+        }
+    }
+    /**
+     * @param collection collection of FilterItemViewmodels
+     * @returns filterRequest in following format: "?='20191',?='27053'"
+     */
+    _getFilterRequestForCollectionRange(collection) {
+        let filterRequest = '';
+        collection === null || collection === void 0 ? void 0 : collection.forEach(item => {
+            if (item.checked) {
+                const formattedRequest = `?=\'${item.code}\'`;
+                filterRequest += (filterRequest ? ',' : '') + `${formattedRequest}`;
+            }
+        });
+        return filterRequest;
+    }
+    /**
+     * @param value value of (un)checked item
+     * @returns filterRequest in following format: "?='J'"
+     */
+    _getFilterRequestForBooleanToString(value) {
+        let filterRequest = '';
+        if (value) {
+            filterRequest = "?='J'";
+        }
+        else {
+            filterRequest = "?='N'";
+        }
+        return filterRequest;
+    }
+    /**
+     * @param collection collection of FilterItemViewmodels
+     * @returns filterRequest in following format: ['0', '1']
+     */
+    _getFilterRequestForCollectionArray(collection) {
+        let filterRequest = [];
+        collection === null || collection === void 0 ? void 0 : collection.forEach(item => {
+            if (item.checked) {
+                filterRequest.push(item.code.toString());
+            }
+        });
+        return filterRequest;
+    }
+    /**
+     * @param collection collection of FilterItemViewmodels
+     * @returns filterRequest in following format: 2
+     */
+    _getFilterRequestForSingleSelect(collection) {
+        let filterRequest = '';
+        const selectedItem = collection === null || collection === void 0 ? void 0 : collection.find(item => item.checked);
+        filterRequest = selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.code.toString();
+        return filterRequest;
+    }
+    /**
+     * @param startDate startDate of the date range
+     * @param endDate endDate of the date range
+     * @returns filterRequest in following format: "?>='01-08-2022'& ?<='31-08-2022'"
+     */
+    _getFilterRequestForDateRange(startDate, endDate) {
+        const startDateRequest = startDate ? this._formatDateToString(startDate) : '';
+        const endDateRequest = endDate ? this._formatDateToString(endDate) : '';
+        const filterRequest = `?>=\'${startDateRequest}\'& ?<=\'${endDateRequest}\'`;
+        return filterRequest;
+    }
+    /**
+     * @param date date in Date format
+     * @returns date in following string format: '01-08-2022'
+     */
+    _formatDateToString(date) {
+        let day = date.getDate().toString().padStart(2, '0');
+        let month = (date.getMonth() + 1).toString().padStart(2, '0');
+        let year = date.getFullYear();
+        return `${day}-${month}-${year}`;
+    }
+}
+FilterRequestService.ɵprov = i0.ɵɵdefineInjectable({ factory: function FilterRequestService_Factory() { return new FilterRequestService(i0.ɵɵinject(i1.TransactionSearchService), i0.ɵɵinject(i2.TransactionService)); }, token: FilterRequestService, providedIn: "root" });
+FilterRequestService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+FilterRequestService.ctorParameters = () => [
+    { type: TransactionSearchService },
+    { type: TransactionService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-request.service.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/transaction-search/service/filter-request.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { FilterItemViewmodel } from \"../../../model/filter-item.viewmodel\";\r\nimport { TransactionService } from \"../../../service/transaction.service\";\r\nimport { TransactionSearchService } from \"./transaction-search.service\";\r\n\r\n@Injectable({\r\n  providedIn: \"root\"\r\n})\r\nexport class FilterRequestService {\r\n\r\n  constructor(\r\n    public searchService: TransactionSearchService,\r\n    private _transactionService: TransactionService,\r\n  ) {\r\n  }\r\n\r\n  /**\r\n   * @param collection collection of FilterItemViewmodels\r\n   * @param modelName name of the model, has to match with a property of TransactionSearchViewRequest\r\n   * @sets searchRequest in following format: modelName: \"?='20191',?='27053'\"\r\n   */\r\n  public handleCollectionChangeForRange(collection: FilterItemViewmodel[], modelName: string): void {\r\n    this.searchService.searchRequest[modelName] = this._getFilterRequestForCollectionRange(collection);\r\n  }\r\n\r\n  /**\r\n   * @param collection collection of FilterItemViewmodels\r\n   * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest\r\n   * @sets searchRequest in following format:  modelName: ['0', '1']\r\n   */\r\n  public handleCollectionChangeForArray(collection: FilterItemViewmodel[], modelName: string): void {\r\n    this.searchService.searchRequest[modelName] = this._getFilterRequestForCollectionArray(collection);\r\n  }\r\n\r\n  /**\r\n   * @param value value of selected item\r\n   * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest\r\n   * @sets searchRequest in following format:  modelName: 2\r\n   */\r\n  public handleCollectionChangeForSingleNumber(value: number, modelName: string): void {\r\n    this.searchService.searchRequest[modelName] = value;\r\n  }\r\n\r\n  /**\r\n   * @param collection collection of FilterItemViewmodels\r\n   * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest\r\n   * @sets searchRequest in following format:  modelName: 2\r\n   */\r\n  public handleCollectionChangeForSingleSelect(collection: FilterItemViewmodel[], modelName: string): void {\r\n    this.searchService.searchRequest[modelName] = this._getFilterRequestForSingleSelect(collection);\r\n  }\r\n\r\n  /**\r\n   * @param value value of (un)checked item\r\n   * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest\r\n   * @sets searchRequest in following format:  modelName: \"?='J'\"\r\n   */\r\n  public handleCheckboxValueChangeForString(value: boolean, modelName: string): void {\r\n    this.searchService.searchRequest[modelName] = this._getFilterRequestForBooleanToString(value);\r\n  }\r\n\r\n  /**\r\n   * @param value value of (un)checked item\r\n   * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest\r\n   * @sets searchRequest in following format:  modelName: 1\r\n   */\r\n  public handleCheckboxValueChangeForNumber(value: boolean, modelName: string): void {\r\n    this.searchService.searchRequest[modelName] = value ? 1 : 0;\r\n  }\r\n\r\n  /**\r\n   * @param dates an array with a startDate and an endDate\r\n   * @param modelName name of the model, has to match with properties of TransactionSearchViewRequest\r\n   * @sets searchRequest in following format:  modelName: \"?>='01-08-2022'& ?<='31-08-2022'\"\r\n   */\r\n  public handleDateRangeChange(dates: Date[], modelName: string): void {\r\n    if (dates) {\r\n      let startDate = dates[0];\r\n      let endDate = dates[1];\r\n\r\n      this.searchService.searchRequest[modelName] = this._getFilterRequestForDateRange(startDate, endDate);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @param filterRequestRange a date range in string format\r\n   * @param index the index of which date should be returned\r\n   * @returns the requested date in Date format\r\n   */\r\n  public getDateFromFilterRequestRange(filterRequestRange: string, index: number): Date {\r\n    if (filterRequestRange) {\r\n\r\n      const datePattern = new RegExp('\\\\d{2}\\\\-\\\\d{2}\\\\-\\\\d{4}');\r\n      let dateString = filterRequestRange\r\n        .split(',')[index]\r\n        .match(datePattern)[0];\r\n\r\n      const day = Number(dateString.match('^\\\\d{2}')[0]);\r\n      const month = Number(dateString.match('(?<=\\\\-)(\\\\d{2})(?=\\\\-)')[0]) - 1;\r\n      const year = Number(dateString.match('\\\\d{4}')[0]);\r\n\r\n      return new Date(year, month, day);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @param collection collection of FilterItemViewmodels\r\n   * @returns filterRequest in following format: \"?='20191',?='27053'\"\r\n   */\r\n  private _getFilterRequestForCollectionRange(collection: FilterItemViewmodel[]): string {\r\n    let filterRequest: string = '';\r\n\r\n    collection?.forEach(item => {\r\n      if (item.checked) {\r\n        const formattedRequest = `?=\\'${item.code}\\'`;\r\n\r\n        filterRequest += (filterRequest ? ',' : '') + `${formattedRequest}`;\r\n      }\r\n    });\r\n    return filterRequest;\r\n  }\r\n\r\n  /**\r\n   * @param value value of (un)checked item\r\n   * @returns filterRequest in following format: \"?='J'\"\r\n   */\r\n  private _getFilterRequestForBooleanToString(value: boolean): string {\r\n    let filterRequest: string = '';\r\n\r\n    if (value) {\r\n      filterRequest = \"?='J'\";\r\n    } else {\r\n      filterRequest = \"?='N'\";\r\n    }\r\n\r\n    return filterRequest;\r\n  }\r\n\r\n  /**\r\n   * @param collection collection of FilterItemViewmodels\r\n   * @returns filterRequest in following format: ['0', '1']\r\n   */\r\n  private _getFilterRequestForCollectionArray(collection: FilterItemViewmodel[]): string[] {\r\n    let filterRequest: string[] = [];\r\n\r\n    collection?.forEach(item => {\r\n      if (item.checked) {\r\n        filterRequest.push(item.code.toString());\r\n      }\r\n    })\r\n\r\n    return filterRequest;\r\n  }\r\n\r\n  /**\r\n   * @param collection collection of FilterItemViewmodels\r\n   * @returns filterRequest in following format: 2\r\n   */\r\n  private _getFilterRequestForSingleSelect(collection: FilterItemViewmodel[]): string {\r\n    let filterRequest: string = '';\r\n\r\n    const selectedItem = collection?.find(item => item.checked);\r\n\r\n    filterRequest = selectedItem?.code.toString();\r\n    return filterRequest;\r\n\r\n}\r\n\r\n  /**\r\n   * @param startDate startDate of the date range\r\n   * @param endDate endDate of the date range\r\n   * @returns filterRequest in following format: \"?>='01-08-2022'& ?<='31-08-2022'\"\r\n   */\r\n  private _getFilterRequestForDateRange(startDate: Date, endDate: Date): string {\r\n    const startDateRequest = startDate ? this._formatDateToString(startDate) : '';\r\n    const endDateRequest = endDate ? this._formatDateToString(endDate) : '';\r\n\r\n    const filterRequest = `?>=\\'${startDateRequest}\\'& ?<=\\'${endDateRequest}\\'`;\r\n    return filterRequest;\r\n  }\r\n\r\n\r\n  /**\r\n   * @param date date in Date format\r\n   * @returns date in following string format: '01-08-2022'\r\n   */\r\n  private _formatDateToString(date: Date): string {\r\n    let day = date.getDate().toString().padStart(2, '0');\r\n    let month = (date.getMonth() + 1).toString().padStart(2, '0');\r\n    let year = date.getFullYear();\r\n\r\n    return `${day}-${month}-${year}`;\r\n  }\r\n}\r\n"]}