@colijnit/transaction 12.1.5 → 12.1.8

package/esm2015/lib/component/checkout/checkout-overview-relation-edit/checkout-overview-relation-edit.component.js

@@ -0,0 +1,371 @@
+import { __awaiter } from "tslib";
+import { Component, EventEmitter, HostBinding, Input, Output, ViewChild, ViewEncapsulation } from "@angular/core";
+import { NULL_RELATION_OBJECT } from "@colijnit/transactionapi/build/model/nul-relation-object";
+import { CommunicationType } from "@colijnit/transactionapi/build/enum/communication-type.enum";
+import { ContactOption } from "@colijnit/transactionapi/build/model/contact-option.bo";
+import { isNill } from "@colijnit/transactionapi/build/utils/function/is-nill.function";
+import { RelationNameKind } from "@colijnit/transactionapi/build/enum/relation-name-kind.enum";
+import { AddressType } from "@colijnit/transactionapi/build/enum/address-type.enum";
+import { GenderType } from "@colijnit/transactionapi/build/enum/gender-type.enum";
+import { TransactionService } from "../../../service/transaction.service";
+import { BusinessObjectUtils } from "@colijnit/transactionapi/build/utils/business-object-utils";
+import { FormComponent } from "@colijnit/corecomponents_v12";
+import { FunctionUtils } from "@colijnit/transactionapi/build/utils/function-utils";
+import { ObjectUtils } from "@colijnit/transactionapi/build/utils/object-utils";
+import { Address } from "@colijnit/transactionapi/build/model/address.bo";
+import { animate, state, style, transition, trigger } from "@angular/animations";
+import { FormMasterService } from "@colijnit/corecomponents_v12";
+export class CheckoutOverviewRelationEditComponent {
+    constructor(_service, _formMaster) {
+        this._service = _service;
+        this._formMaster = _formMaster;
+        this.validSubmit = new EventEmitter();
+        this.invalidSubmit = new EventEmitter();
+        this.relationChange = new EventEmitter();
+        this.accountPassword = "";
+        this.hide = true;
+        this.gender = GenderType.Unspecified;
+        this.emailAddress = new ContactOption();
+        this.phoneNumber = new ContactOption();
+        this.relationSuggestions = [];
+        this.showRelationSidebar = false;
+        this.inviteToAccount = false;
+        this.relType = RelationNameKind;
+        this.genderType = GenderType;
+        this._relation = NULL_RELATION_OBJECT;
+        // fetches relation suggestions
+        this._relationNameChangeHandler = FunctionUtils.Throttle(() => {
+            return this._relationNameChangedHandlerFn();
+            // eslint-disable-next-line no-magic-numbers
+        }, 600);
+    }
+    set relation(value) {
+        this._relation = value;
+        this.preparePrimaryEmail();
+        this.preparePrimaryPhone();
+    }
+    showClass() {
+        return true;
+    }
+    get relation() {
+        return this._relation;
+    }
+    get relationAsCustomer() {
+        return this._relation && this._relation;
+    }
+    get editFirstAddress() {
+        const firstAddress = this._service.getFirstAddress(this.relation);
+        if (firstAddress) {
+            return firstAddress;
+        }
+        else if (this._relation) {
+            const address = new Address();
+            address.addressType = AddressType.DeliveryAddress;
+            address.startDate = new Date();
+            address.sequence = this._relation.getNextAddressSequence();
+            this._relation.addresses.push(address);
+            return address;
+        }
+    }
+    get applicationUser() {
+        return this._service.applicationUser;
+    }
+    ngOnInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._initForm();
+            this._relation.type = this.relType.Private;
+            this._relation.gender = this.gender;
+            yield this.loadPrivacySettings();
+        });
+    }
+    submit() {
+        // return this.relationForm.submit();
+        return this._formMaster.submitSlaves();
+    }
+    preparePrimaryEmail() {
+        if (this._relation) {
+            this.emailAddress = this._relation.getLowestSequenceOfContactOptionsWithType(CommunicationType.Email);
+            if (isNill(this.emailAddress)) {
+                this.emailAddress = new ContactOption();
+                this.emailAddress.type = CommunicationType.Email;
+                this.emailAddress.sequence = 0;
+                this._relation.addContactOption(this.emailAddress);
+            }
+            // if (this._transactionService.emailAddress) {
+            //   this.emailAddress.value = this._transactionService.emailAddress;
+            // }
+        }
+    }
+    preparePrimaryPhone() {
+        if (this._relation) {
+            this.phoneNumber = this._relation.getLowestSequenceOfContactOptionsWithType(CommunicationType.Telephone);
+            if (isNill(this.phoneNumber)) {
+                this.phoneNumber = new ContactOption();
+                this.phoneNumber.type = CommunicationType.Telephone;
+                this.phoneNumber.sequence = 0;
+                this._relation.addContactOption(this.phoneNumber);
+            }
+        }
+    }
+    loadPrivacySettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.privacySettings = yield this._service.getRelationPrivacySettings();
+        });
+    }
+    loadMarketing() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._service.getMarketingCodes();
+        });
+    }
+    isShared(relationPrivacySetting) {
+        const ownSetting = BusinessObjectUtils.FindItemById(this.relationAsCustomer.relationPrivacySettings, relationPrivacySetting.getId());
+        if (ownSetting) {
+            return ownSetting.allowToShare;
+        }
+        return false;
+    }
+    changeRelationType(value) {
+        this.relation.type = value;
+    }
+    changeGenderType(value) {
+        this.relation.gender = value;
+    }
+    firstNameChange(firstName) {
+        if (this._relation) {
+            this._relation.firstName = firstName;
+        }
+        this._relationNameChangeHandler.call(this);
+    }
+    familyNameChange(familyName) {
+        if (this._relation) {
+            this._relation.familyName = familyName;
+        }
+        this._relationNameChangeHandler.call(this);
+    }
+    onRelationSuggestionClick(relationSuggested) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (relationSuggested) {
+                this.hideSidebar();
+                // await this._service.addRelationToTransaction(relationSuggested.relationId);
+                this.relation = yield this._service.getCustomerFullObjectByRelationId(relationSuggested.relationId);
+                this.relationChange.next(this.relation);
+            }
+        });
+    }
+    changePrivacySetting(relationPrivacySetting, value) {
+        const ownSetting = BusinessObjectUtils.FindItemById(this.relationAsCustomer.relationPrivacySettings, relationPrivacySetting.getId());
+        if (ownSetting) {
+            ownSetting.allowToShare = value;
+        }
+        else {
+            this.relationAsCustomer.relationPrivacySettings.push(relationPrivacySetting);
+        }
+    }
+    showSidebar() {
+        this.showRelationSidebar = true;
+    }
+    hideSidebar() {
+        this.showRelationSidebar = false;
+    }
+    _initForm() {
+        if (this.relationForm) {
+            this.formRelation = this.relationForm.formGroup;
+        }
+    }
+    // load suggestions
+    _relationNameChangedHandlerFn() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const firstName = ObjectUtils.ValueOrDefault(this._relation.firstName);
+            const secondName = ObjectUtils.ValueOrDefault(this._relation.familyName);
+            if (!firstName && !secondName) {
+                this.relationSuggestions = [];
+                this.hideSidebar();
+                return;
+            }
+            const relationRequest = {};
+            relationRequest.relationType = this._relation.relationType;
+            if (firstName) {
+                relationRequest.firstName = firstName;
+            }
+            if (secondName) {
+                relationRequest.familyName = secondName;
+            }
+            this.showSidebar();
+            this.relationSuggestions = yield this._service.getRelationListObjects(relationRequest);
+        });
+    }
+}
+CheckoutOverviewRelationEditComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-checkout-overview-relation-edit",
+                template: `
+    <co-form>
+      <div class="checkout-form-wrapper">
+        <div class="checkout-label-column">
+          <span>01</span>
+          <span class="label" [textContent]="'PERSONAL_DATA' | localize"></span>
+        </div>
+        <div class="checkout-data-column">
+          <div class="checkout-data-row">
+            <co-input-radio-button class="default-width"
+                                   [name]="'type'"
+                                   [label]="'PRIVATE_PERSON' | localize"
+                                   [value]="relType.Private"
+                                   [checked]="relation.type === relType.Private"
+                                   (modelChange)="changeRelationType(relType.Private)"
+            ></co-input-radio-button>
+            <co-input-radio-button class="default-width"
+                                   [name]="'type'"
+                                   [label]="'COMPANY' | localize"
+                                   [value]="relType.Company"
+                                   [(model)]="relation.type"
+                                   [checked]="relation.type === relType.Company"
+                                   (modelChange)="changeRelationType(relType.Company)"
+            ></co-input-radio-button>
+          </div>
+          <div class="checkout-data-row">
+            <relation-customer-groups [(model)]="relation.customerGroup" required></relation-customer-groups>
+          </div>
+          <div *ngIf="relation.type === relType.Private" class="collapseable" @showHidePrivateRelationFields>
+            <div class="checkout-data-row">
+              <co-input-text
+                class="checkout-first-name"
+                [(model)]="relation.firstName"
+                [placeholder]="'FIRST_NAME' | localize"
+                (modelChange)="firstNameChange($event)"
+                [required]="true"
+              ></co-input-text>
+              <co-input-text
+                class="checkout-prefix-name default-width"
+                [(model)]="relation.prefix"
+                [placeholder]="'PREFIX' | localize"
+              ></co-input-text>
+              <co-input-text
+                class="checkout-last-name"
+                [(model)]="relation.familyName"
+                [placeholder]="'LAST_NAME' | localize"
+                (modelChange)="familyNameChange($event)"
+                [required]="true"></co-input-text>
+            </div>
+            <div class="checkout-data-row">
+              <co-input-radio-button class="default-width"
+                                     [name]="'gender'"
+                                     [label]="'MALE' | localize"
+                                     [value]="genderType.Male"
+                                     [checked]="relation.gender === genderType.Male"
+                                     (modelChange)="changeGenderType(genderType.Male)"
+              ></co-input-radio-button>
+              <co-input-radio-button class="default-width"
+                                     [name]="'gender'"
+                                     [label]="'FEMALE' | localize "
+                                     [value]="genderType.Female"
+                                     [checked]="relation.gender === genderType.Female"
+                                     (modelChange)="changeGenderType(genderType.Female)"
+              ></co-input-radio-button>
+              <co-input-radio-button class="default-width"
+                                     [name]="'gender'"
+                                     [label]="'UNKNOWN' | localize"
+                                     [value]="genderType.Unspecified"
+                                     [checked]="relation.gender === genderType.Unspecified"
+                                     (modelChange)="changeGenderType(genderType.Unspecified)"
+              ></co-input-radio-button>
+            </div>
+            <div class="checkout-data-row">
+              <co-input-date [placeholder]="'DATE_OF_BIRTH' | localize " [(model)]="dateOfBirth" [required]="true"></co-input-date>
+              <co-input-text [(model)]="phoneNumber.value" [placeholder]="'PHONE_NO' | localize " [required]="true"></co-input-text>
+            </div>
+          </div>
+          <div *ngIf="relation?.type === relType.Company" class="checkout-data-row collapseable" @showHideCompanyRelationFields>
+            <co-input-text [(model)]="relation.familyName" [placeholder]="'COMPANY_NAME' | localize" [required]="true"></co-input-text>
+          </div>
+        </div>
+        <div class="checkout-label-column">
+          <span>02</span>
+          <span class="label" [textContent]="'DELIVERY_ADDRESS' | localize"></span>
+        </div>
+        <div class="checkout-data-column">
+          <co-relation-address [address]="editFirstAddress" [showButtons]="false"></co-relation-address>
+        </div>
+        <div class="checkout-label-column">
+          <span>03</span>
+          <span class="label" [textContent]="'LOGIN_DETAILS' | localize"></span>
+          <span class="label-description" [textContent]="'ACCOUNT_EXPLANATION' | localize"></span>
+        </div>
+        <div class="checkout-data-column">
+          <div class="checkout-data-row">
+            <co-input-text [(model)]="emailAddress.value" [placeholder]="'EMAIL_ADDRESS' | localize " [type]="'email'" [required]="true"></co-input-text>
+          </div>
+          <div *ngIf="!applicationUser" class="checkout-data-row">
+            <co-input-text [(model)]="accountPassword" [placeholder]="'PASSWORD' | localize " [type]="'password'" [required]="true"></co-input-text>
+          </div>
+          <div *ngIf="applicationUser" class="checkout-data-row">
+            <co-input-checkbox [label]="'INVITE_TO_ACCOUNT' | localize" [(model)]="inviteToAccount"></co-input-checkbox>
+          </div>
+        </div>
+        <div class="checkout-label-column">
+          <span>04</span>
+          <span class="label" [textContent]="'PRIVACY_PREFERENCES' | localize"></span>
+        </div>
+        <div class="checkout-data-column">
+          <div class="two-column-grid">
+            <ng-container *ngFor="let privacySetting of privacySettings">
+              <co-input-checkbox class="first-column"
+                                 [label]="privacySetting.description"
+                                 [model]="isShared(privacySetting)"
+                                 (modelChange)="changePrivacySetting(privacySetting, $event)"
+              ></co-input-checkbox>
+              <span class="second-column" [textContent]="privacySetting.explanation"></span>
+            </ng-container>
+          </div>
+        </div>
+      </div>
+    </co-form>
+
+    <div class="suggestions-sidebar" *ngIf="showRelationSidebar" @showHideSidebar>
+      <div class="relation-sidebar-header">
+        <label class="checkout-label-h3" [textContent]="'SUGGESTIONS' | localize"></label>
+      </div>
+      <co-checkout-relation-suggestions-list
+        [suggestions]="relationSuggestions"
+        (suggestionSelected)="onRelationSuggestionClick($event)"
+      ></co-checkout-relation-suggestions-list>
+    </div>
+  `,
+                providers: [
+                    FormMasterService
+                ],
+                animations: [
+                    trigger("showHidePrivateRelationFields", [
+                        state("void", style({ height: 0 })),
+                        state("*", style({ height: "*" })),
+                        transition("void => *", animate("200ms ease-in-out")),
+                        transition("* => void", animate("200ms ease-out"))
+                    ]),
+                    trigger("showHideCompanyRelationFields", [
+                        state("void", style({ height: 0 })),
+                        state("*", style({ height: "*" })),
+                        transition("void => *", animate("200ms ease-in-out")),
+                        transition("* => void", animate("200ms ease-out"))
+                    ]),
+                    trigger("showHideSidebar", [
+                        state("void", style({ transform: "translateX(100%)" })),
+                        state("*", style({ transform: "translateX(0)" })),
+                        transition("void <=> *", animate("200ms ease-in-out"))
+                    ])
+                ],
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+CheckoutOverviewRelationEditComponent.ctorParameters = () => [
+    { type: TransactionService },
+    { type: FormMasterService }
+];
+CheckoutOverviewRelationEditComponent.propDecorators = {
+    relationForm: [{ type: ViewChild, args: [FormComponent, { static: true },] }],
+    relation: [{ type: Input }],
+    validSubmit: [{ type: Output }],
+    invalidSubmit: [{ type: Output }],
+    relationChange: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-checkout-overview-relation-edit",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkout-overview-relation-edit.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/checkout/checkout-overview-relation-edit/checkout-overview-relation-edit.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewChild, ViewEncapsulation} from \"@angular/core\";\nimport {RelationAnyType} from \"@colijnit/transactionapi/build/model/relation-any-type\";\nimport {NULL_RELATION_OBJECT} from \"@colijnit/transactionapi/build/model/nul-relation-object\";\nimport {CustomerFullObject} from \"@colijnit/transactionapi/build/model/customer-full-object.bo\";\nimport {CommunicationType} from \"@colijnit/transactionapi/build/enum/communication-type.enum\";\nimport {ContactOption} from \"@colijnit/transactionapi/build/model/contact-option.bo\";\nimport {isNill} from \"@colijnit/transactionapi/build/utils/function/is-nill.function\";\nimport {RelationNameKind} from \"@colijnit/transactionapi/build/enum/relation-name-kind.enum\";\nimport {AddressType} from \"@colijnit/transactionapi/build/enum/address-type.enum\";\nimport {RelationPrivacySetting} from \"@colijnit/transactionapi/build/model/relation-privacy-setting.bo\";\nimport {GenderType} from \"@colijnit/transactionapi/build/enum/gender-type.enum\";\nimport {TransactionService} from \"../../../service/transaction.service\";\nimport {BusinessObjectUtils} from \"@colijnit/transactionapi/build/utils/business-object-utils\";\nimport {FormComponent} from \"@colijnit/corecomponents_v12\";\nimport {FunctionUtils} from \"@colijnit/transactionapi/build/utils/function-utils\";\nimport {ObjectUtils} from \"@colijnit/transactionapi/build/utils/object-utils\";\nimport {RelationListObject} from \"@colijnit/transactionapi/build/model/relation-list-object.bo\";\nimport {RelationRequest} from \"@colijnit/transactionapi/build/model/relation-request\";\nimport {Address} from \"@colijnit/transactionapi/build/model/address.bo\";\nimport {animate, state, style, transition, trigger} from \"@angular/animations\";\nimport {FormGroup} from \"@angular/forms\";\nimport {FormMasterService} from \"@colijnit/corecomponents_v12\";\n\n@Component({\n  selector: \"co-checkout-overview-relation-edit\",\n  template: `\n    <co-form>\n      <div class=\"checkout-form-wrapper\">\n        <div class=\"checkout-label-column\">\n          <span>01</span>\n          <span class=\"label\" [textContent]=\"'PERSONAL_DATA' | localize\"></span>\n        </div>\n        <div class=\"checkout-data-column\">\n          <div class=\"checkout-data-row\">\n            <co-input-radio-button class=\"default-width\"\n                                   [name]=\"'type'\"\n                                   [label]=\"'PRIVATE_PERSON' | localize\"\n                                   [value]=\"relType.Private\"\n                                   [checked]=\"relation.type === relType.Private\"\n                                   (modelChange)=\"changeRelationType(relType.Private)\"\n            ></co-input-radio-button>\n            <co-input-radio-button class=\"default-width\"\n                                   [name]=\"'type'\"\n                                   [label]=\"'COMPANY' | localize\"\n                                   [value]=\"relType.Company\"\n                                   [(model)]=\"relation.type\"\n                                   [checked]=\"relation.type === relType.Company\"\n                                   (modelChange)=\"changeRelationType(relType.Company)\"\n            ></co-input-radio-button>\n          </div>\n          <div class=\"checkout-data-row\">\n            <relation-customer-groups [(model)]=\"relation.customerGroup\" required></relation-customer-groups>\n          </div>\n          <div *ngIf=\"relation.type === relType.Private\" class=\"collapseable\" @showHidePrivateRelationFields>\n            <div class=\"checkout-data-row\">\n              <co-input-text\n                class=\"checkout-first-name\"\n                [(model)]=\"relation.firstName\"\n                [placeholder]=\"'FIRST_NAME' | localize\"\n                (modelChange)=\"firstNameChange($event)\"\n                [required]=\"true\"\n              ></co-input-text>\n              <co-input-text\n                class=\"checkout-prefix-name default-width\"\n                [(model)]=\"relation.prefix\"\n                [placeholder]=\"'PREFIX' | localize\"\n              ></co-input-text>\n              <co-input-text\n                class=\"checkout-last-name\"\n                [(model)]=\"relation.familyName\"\n                [placeholder]=\"'LAST_NAME' | localize\"\n                (modelChange)=\"familyNameChange($event)\"\n                [required]=\"true\"></co-input-text>\n            </div>\n            <div class=\"checkout-data-row\">\n              <co-input-radio-button class=\"default-width\"\n                                     [name]=\"'gender'\"\n                                     [label]=\"'MALE' | localize\"\n                                     [value]=\"genderType.Male\"\n                                     [checked]=\"relation.gender === genderType.Male\"\n                                     (modelChange)=\"changeGenderType(genderType.Male)\"\n              ></co-input-radio-button>\n              <co-input-radio-button class=\"default-width\"\n                                     [name]=\"'gender'\"\n                                     [label]=\"'FEMALE' | localize \"\n                                     [value]=\"genderType.Female\"\n                                     [checked]=\"relation.gender === genderType.Female\"\n                                     (modelChange)=\"changeGenderType(genderType.Female)\"\n              ></co-input-radio-button>\n              <co-input-radio-button class=\"default-width\"\n                                     [name]=\"'gender'\"\n                                     [label]=\"'UNKNOWN' | localize\"\n                                     [value]=\"genderType.Unspecified\"\n                                     [checked]=\"relation.gender === genderType.Unspecified\"\n                                     (modelChange)=\"changeGenderType(genderType.Unspecified)\"\n              ></co-input-radio-button>\n            </div>\n            <div class=\"checkout-data-row\">\n              <co-input-date [placeholder]=\"'DATE_OF_BIRTH' | localize \" [(model)]=\"dateOfBirth\" [required]=\"true\"></co-input-date>\n              <co-input-text [(model)]=\"phoneNumber.value\" [placeholder]=\"'PHONE_NO' | localize \" [required]=\"true\"></co-input-text>\n            </div>\n          </div>\n          <div *ngIf=\"relation?.type === relType.Company\" class=\"checkout-data-row collapseable\" @showHideCompanyRelationFields>\n            <co-input-text [(model)]=\"relation.familyName\" [placeholder]=\"'COMPANY_NAME' | localize\" [required]=\"true\"></co-input-text>\n          </div>\n        </div>\n        <div class=\"checkout-label-column\">\n          <span>02</span>\n          <span class=\"label\" [textContent]=\"'DELIVERY_ADDRESS' | localize\"></span>\n        </div>\n        <div class=\"checkout-data-column\">\n          <co-relation-address [address]=\"editFirstAddress\" [showButtons]=\"false\"></co-relation-address>\n        </div>\n        <div class=\"checkout-label-column\">\n          <span>03</span>\n          <span class=\"label\" [textContent]=\"'LOGIN_DETAILS' | localize\"></span>\n          <span class=\"label-description\" [textContent]=\"'ACCOUNT_EXPLANATION' | localize\"></span>\n        </div>\n        <div class=\"checkout-data-column\">\n          <div class=\"checkout-data-row\">\n            <co-input-text [(model)]=\"emailAddress.value\" [placeholder]=\"'EMAIL_ADDRESS' | localize \" [type]=\"'email'\" [required]=\"true\"></co-input-text>\n          </div>\n          <div *ngIf=\"!applicationUser\" class=\"checkout-data-row\">\n            <co-input-text [(model)]=\"accountPassword\" [placeholder]=\"'PASSWORD' | localize \" [type]=\"'password'\" [required]=\"true\"></co-input-text>\n          </div>\n          <div *ngIf=\"applicationUser\" class=\"checkout-data-row\">\n            <co-input-checkbox [label]=\"'INVITE_TO_ACCOUNT' | localize\" [(model)]=\"inviteToAccount\"></co-input-checkbox>\n          </div>\n        </div>\n        <div class=\"checkout-label-column\">\n          <span>04</span>\n          <span class=\"label\" [textContent]=\"'PRIVACY_PREFERENCES' | localize\"></span>\n        </div>\n        <div class=\"checkout-data-column\">\n          <div class=\"two-column-grid\">\n            <ng-container *ngFor=\"let privacySetting of privacySettings\">\n              <co-input-checkbox class=\"first-column\"\n                                 [label]=\"privacySetting.description\"\n                                 [model]=\"isShared(privacySetting)\"\n                                 (modelChange)=\"changePrivacySetting(privacySetting, $event)\"\n              ></co-input-checkbox>\n              <span class=\"second-column\" [textContent]=\"privacySetting.explanation\"></span>\n            </ng-container>\n          </div>\n        </div>\n      </div>\n    </co-form>\n\n    <div class=\"suggestions-sidebar\" *ngIf=\"showRelationSidebar\" @showHideSidebar>\n      <div class=\"relation-sidebar-header\">\n        <label class=\"checkout-label-h3\" [textContent]=\"'SUGGESTIONS' | localize\"></label>\n      </div>\n      <co-checkout-relation-suggestions-list\n        [suggestions]=\"relationSuggestions\"\n        (suggestionSelected)=\"onRelationSuggestionClick($event)\"\n      ></co-checkout-relation-suggestions-list>\n    </div>\n  `,\n  providers: [\n    FormMasterService\n  ],\n  animations: [\n    trigger(\"showHidePrivateRelationFields\", [\n      state(\"void\", style({height: 0})),\n      state(\"*\", style({height: \"*\"})),\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\n      transition(\"* => void\", animate(\"200ms ease-out\"))\n    ]),\n    trigger(\"showHideCompanyRelationFields\", [\n      state(\"void\", style({height: 0})),\n      state(\"*\", style({height: \"*\"})),\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\n      transition(\"* => void\", animate(\"200ms ease-out\"))\n    ]),\n    trigger(\"showHideSidebar\", [\n      state(\"void\", style({transform: \"translateX(100%)\"})),\n      state(\"*\", style({transform: \"translateX(0)\"})),\n      transition(\"void <=> *\", animate(\"200ms ease-in-out\"))\n    ])\n  ],\n  encapsulation: ViewEncapsulation.None\n})\nexport class CheckoutOverviewRelationEditComponent implements OnInit {\n  @ViewChild(FormComponent, {static: true})\n  public relationForm: FormComponent;\n\n  @Input()\n  public set relation(value: RelationAnyType) {\n    this._relation = value;\n\n    this.preparePrimaryEmail();\n    this.preparePrimaryPhone();\n  }\n\n  @Output()\n  public validSubmit: EventEmitter<void> = new EventEmitter<void>();\n\n  @Output()\n  public invalidSubmit: EventEmitter<void> = new EventEmitter<void>();\n\n  @Output()\n  public relationChange: EventEmitter<RelationAnyType> = new EventEmitter<RelationAnyType>();\n\n  @HostBinding(\"class.co-checkout-overview-relation-edit\")\n  public showClass() {\n    return true;\n  }\n\n  public formRelation: FormGroup;\n\n  public dateOfBirth: Date;\n  public accountPassword: string = \"\";\n  public hide: boolean = true;\n  public gender: GenderType = GenderType.Unspecified;\n  public emailAddress: ContactOption = new ContactOption();\n  public phoneNumber: ContactOption = new ContactOption();\n  public privacySettings: RelationPrivacySetting[];\n  public relationSuggestions: RelationListObject[] = [];\n  public showRelationSidebar: boolean = false;\n  public inviteToAccount: boolean = false;\n\n  public readonly relType: typeof RelationNameKind = RelationNameKind;\n  public readonly genderType: typeof GenderType = GenderType;\n\n  public get relation(): RelationAnyType {\n    return this._relation;\n  }\n\n  public get relationAsCustomer(): CustomerFullObject {\n    return this._relation && this._relation as CustomerFullObject;\n  }\n\n  public get editFirstAddress(): Address {\n    const firstAddress: Address = this._service.getFirstAddress(this.relation);\n    if (firstAddress) {\n      return firstAddress;\n    } else if (this._relation) {\n      const address: Address = new Address();\n      address.addressType = AddressType.DeliveryAddress;\n      address.startDate = new Date();\n      address.sequence = this._relation.getNextAddressSequence();\n      this._relation.addresses.push(address);\n      return address;\n    }\n  }\n\n  public get applicationUser(): boolean {\n    return this._service.applicationUser;\n  }\n\n  private _relation: RelationAnyType = NULL_RELATION_OBJECT;\n\n  constructor(\n    private _service: TransactionService,\n    private _formMaster: FormMasterService\n  ) {\n  }\n\n  async ngOnInit(): Promise<void> {\n    this._initForm();\n    this._relation.type = this.relType.Private;\n    this._relation.gender = this.gender;\n    await this.loadPrivacySettings();\n  }\n\n  public submit(): boolean {\n    // return this.relationForm.submit();\n    return this._formMaster.submitSlaves();\n  }\n\n  public preparePrimaryEmail(): void {\n    if (this._relation) {\n      this.emailAddress = this._relation.getLowestSequenceOfContactOptionsWithType(CommunicationType.Email);\n      if (isNill(this.emailAddress)) {\n        this.emailAddress = new ContactOption();\n        this.emailAddress.type = CommunicationType.Email;\n        this.emailAddress.sequence = 0;\n        this._relation.addContactOption(this.emailAddress);\n      }\n      // if (this._transactionService.emailAddress) {\n      //   this.emailAddress.value = this._transactionService.emailAddress;\n      // }\n    }\n  }\n\n  public preparePrimaryPhone(): void {\n    if (this._relation) {\n      this.phoneNumber = this._relation.getLowestSequenceOfContactOptionsWithType(CommunicationType.Telephone);\n      if (isNill(this.phoneNumber)) {\n        this.phoneNumber = new ContactOption();\n        this.phoneNumber.type = CommunicationType.Telephone;\n        this.phoneNumber.sequence = 0;\n        this._relation.addContactOption(this.phoneNumber);\n      }\n    }\n  }\n\n  public async loadPrivacySettings(): Promise<void> {\n    this.privacySettings = await this._service.getRelationPrivacySettings();\n  }\n\n  public async loadMarketing(): Promise<void> {\n    await this._service.getMarketingCodes();\n  }\n\n  public isShared(relationPrivacySetting: RelationPrivacySetting): boolean {\n    const ownSetting: RelationPrivacySetting = BusinessObjectUtils.FindItemById(this.relationAsCustomer.relationPrivacySettings, relationPrivacySetting.getId());\n    if (ownSetting) {\n      return ownSetting.allowToShare;\n    }\n    return false;\n  }\n\n  public changeRelationType(value: RelationNameKind): void {\n    this.relation.type = value;\n  }\n\n  public changeGenderType(value: GenderType): void {\n    this.relation.gender = value;\n  }\n\n  public firstNameChange(firstName: string): void {\n    if (this._relation) {\n      this._relation.firstName = firstName;\n    }\n    this._relationNameChangeHandler.call(this);\n  }\n\n  public familyNameChange(familyName: string): void {\n    if (this._relation) {\n      this._relation.familyName = familyName;\n    }\n    this._relationNameChangeHandler.call(this);\n  }\n\n  public async onRelationSuggestionClick(relationSuggested: RelationListObject): Promise<void> {\n    if (relationSuggested) {\n      this.hideSidebar();\n      // await this._service.addRelationToTransaction(relationSuggested.relationId);\n      this.relation = await this._service.getCustomerFullObjectByRelationId(relationSuggested.relationId);\n      this.relationChange.next(this.relation);\n    }\n  }\n\n  public changePrivacySetting(relationPrivacySetting: RelationPrivacySetting, value: boolean): void {\n    const ownSetting: RelationPrivacySetting = BusinessObjectUtils.FindItemById(this.relationAsCustomer.relationPrivacySettings, relationPrivacySetting.getId());\n    if (ownSetting) {\n      ownSetting.allowToShare = value;\n    } else {\n      this.relationAsCustomer.relationPrivacySettings.push(relationPrivacySetting);\n    }\n  }\n\n  public showSidebar(): void {\n    this.showRelationSidebar = true;\n  }\n\n  public hideSidebar(): void {\n    this.showRelationSidebar = false;\n  }\n\n  private _initForm(): void {\n    if (this.relationForm) {\n      this.formRelation = this.relationForm.formGroup;\n    }\n  }\n\n  // fetches relation suggestions\n  private _relationNameChangeHandler: Function = FunctionUtils.Throttle(() => {\n    return this._relationNameChangedHandlerFn();\n    // eslint-disable-next-line no-magic-numbers\n  }, 600);\n\n  // load suggestions\n  private async _relationNameChangedHandlerFn(): Promise<any> {\n    const firstName: string = ObjectUtils.ValueOrDefault(this._relation.firstName);\n    const secondName: string = ObjectUtils.ValueOrDefault(this._relation.familyName);\n\n    if (!firstName && !secondName) {\n      this.relationSuggestions = [];\n      this.hideSidebar();\n      return;\n    }\n\n    const relationRequest: RelationRequest = {};\n    relationRequest.relationType = this._relation.relationType;\n    if (firstName) {\n      relationRequest.firstName = firstName;\n    }\n\n    if (secondName) {\n      relationRequest.familyName = secondName;\n    }\n\n    this.showSidebar();\n    this.relationSuggestions = await this._service.getRelationListObjects(relationRequest);\n  }\n}\n"]}

package/esm2015/lib/component/checkout/checkout-relation-suggestions-list/checkout-relation-suggestions-list.component.js

@@ -0,0 +1,30 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
+export class CheckOutRelationSuggestionsListComponent {
+    constructor() {
+        this.suggestions = [];
+        // Emits the clicked relation list object.
+        this.suggestionSelected = new EventEmitter();
+    }
+    showClass() {
+        return true;
+    }
+}
+CheckOutRelationSuggestionsListComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-checkout-relation-suggestions-list",
+                template: `
+    <div class="flex-column items-wrapper">
+      <co-checkout-relation-suggestions-list-item *ngFor="let suggestion of suggestions" [suggestion]="suggestion"
+                                                  (selectionSelected)="suggestionSelected.emit(suggestion)"></co-checkout-relation-suggestions-list-item>
+      <span *ngIf="suggestions?.length === 0" class="no-results" localize="NO_RESULTS_FOUND"></span>
+    </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+CheckOutRelationSuggestionsListComponent.propDecorators = {
+    suggestions: [{ type: Input }],
+    suggestionSelected: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ['class.co-checkout-relation-suggestions-list',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/checkout/checkout-relation-suggestions-list-item/checkout-relation-suggestions-list-item.component.js

@@ -0,0 +1,31 @@
+import { Component, EventEmitter, HostBinding, HostListener, Input, Output, ViewEncapsulation } from "@angular/core";
+export class CheckOutRelationSuggestionsListItemComponent {
+    constructor() {
+        this.selectionSelected = new EventEmitter();
+    }
+    showClass() {
+        return true;
+    }
+    handleClick(event) {
+        this.selectionSelected.next(this.suggestion);
+    }
+}
+CheckOutRelationSuggestionsListItemComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-checkout-relation-suggestions-list-item",
+                template: `
+    <div class="name medium-big-font" *ngIf="suggestion.displayName as displayName" [textContent]="displayName"></div>
+    <div class="email" *ngIf="suggestion.email" [textContent]="suggestion.email"></div>
+    <div class="address" *ngIf="suggestion.displayAddress as address" [textContent]="address"></div>
+    <div class="phone" *ngIf="suggestion.tel1" [textContent]="suggestion.tel1"></div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+CheckOutRelationSuggestionsListItemComponent.propDecorators = {
+    suggestion: [{ type: Input }],
+    selectionSelected: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-checkout-relation-suggestions-list-item",] }],
+    handleClick: [{ type: HostListener, args: ["click", ["$event"],] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/checkout/checkout.component.js

@@ -0,0 +1,102 @@
+import { __awaiter } from "tslib";
+import { Component, EventEmitter, HostBinding, Output, ViewChild, ViewEncapsulation } from "@angular/core";
+import { TransactionService } from "../../service/transaction.service";
+import { DictionaryService } from "../../service/dictionary.service";
+import { DialogService } from "../../service/dialog.service";
+export class CheckoutComponent {
+    constructor(service, _dictionary, _dialogService) {
+        this.service = service;
+        this._dictionary = _dictionary;
+        this._dialogService = _dialogService;
+        this.transactionFinished = new EventEmitter();
+    }
+    showClass() {
+        return true;
+    }
+    get userIsApplicationUser() {
+        // TODO: return this.userService.isApplicationUser;
+        return true;
+    }
+    // ngOnDestroy(): void {
+    //   this._subscriptions.forEach(subscription => subscription.unsubscribe());
+    // }
+    handleRelationValidation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.checkoutRelation && this.stepRelation) {
+                const valid = this.checkoutRelation.submit();
+                this.stepRelation.completed = valid;
+                if (valid) {
+                    this.saveRelation();
+                }
+            }
+        });
+    }
+    handleDeliveryValidation() {
+        if (this.checkoutDelivery && this.stepDelivery) {
+            const valid = this.checkoutDelivery.submit();
+            this.stepDelivery.completed = valid;
+            if (valid) {
+                this.handleSaveDelivery();
+            }
+        }
+    }
+    saveRelation() {
+        return this.service.saveRelation();
+    }
+    handleSaveDelivery() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.service.setTransactionDeliveryOptions().then((response) => __awaiter(this, void 0, void 0, function* () {
+                    if (response) {
+                        const response = yield this.service.saveTransaction();
+                        if (response && response.isSuccess) {
+                            const commitResponse = yield this.service.commit();
+                            if (commitResponse && commitResponse.validationResult && commitResponse.validationResult.success) {
+                                this.transactionFinished.next(this.service.currentTransaction.transactionInfo);
+                            }
+                        }
+                    }
+                    else {
+                        yield this._dialogService.showError("Opslag bezorging mislukt");
+                    }
+                    resolve(true);
+                })).catch((reason) => {
+                    this._dialogService.showError("Opslag transactie mislukt");
+                });
+            });
+        });
+    }
+}
+CheckoutComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-checkout",
+                template: `
+    <co-stepper [finishButtonLabel]="'CHECKOUT_FINISH' | localize" (finishStep)="handleDeliveryValidation()">
+      <co-stepper-step #stepRelation [index]="1" [label]="'YOUR_DATA' | localize" (validateStep)="handleRelationValidation()">
+        <co-checkout-overview-relation-edit #checkoutRelation [(relation)]="service.relation" (relationChange)="service.relation = $event"
+        ></co-checkout-overview-relation-edit>
+      </co-stepper-step>
+      <co-stepper-step #stepDelivery [index]="2" [label]="'DELIVERY' | localize">
+        <co-checkout-overview-delivery-edit #checkoutDelivery *ngIf="service.deliveryOptions" [(relation)]="service.relation" [deliveryOptionsRequest]="service.deliveryOptions"
+                                            [transaction]="service.currentTransaction"
+        ></co-checkout-overview-delivery-edit>
+      </co-stepper-step>
+    </co-stepper>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+CheckoutComponent.ctorParameters = () => [
+    { type: TransactionService },
+    { type: DictionaryService },
+    { type: DialogService }
+];
+CheckoutComponent.propDecorators = {
+    stepRelation: [{ type: ViewChild, args: ["stepRelation",] }],
+    stepDelivery: [{ type: ViewChild, args: ["stepDelivery",] }],
+    checkoutRelation: [{ type: ViewChild, args: ["checkoutRelation",] }],
+    checkoutDelivery: [{ type: ViewChild, args: ["checkoutDelivery",] }],
+    transactionFinished: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-checkout",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkout.component.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/component/checkout/checkout.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Output, ViewChild, ViewEncapsulation} from \"@angular/core\";\r\nimport {TransactionService} from \"../../service/transaction.service\";\r\nimport {DictionaryService} from \"../../service/dictionary.service\";\r\nimport {TransactionInfo} from \"@colijnit/transactionapi/build/model/transaction-info.bo\";\r\nimport {TransactionResponseBase} from \"@colijnit/transactionapi/build/model/transaction-response-base.bo\";\r\nimport {DataServiceResponseData} from \"@colijnit/transactionapi/build/model/data-service-response-data\";\r\nimport {ValidationResult} from \"@colijnit/transactionapi/build/model/validation-result\";\r\nimport {TransactionInfoResponse} from \"@colijnit/transactionapi/build/model/transaction-info-response.bo\";\r\nimport {CheckoutOverviewRelationEditComponent} from \"./checkout-overview-relation-edit/checkout-overview-relation-edit.component\";\r\nimport {CheckoutOverviewDeliveryEditComponent} from \"./checkout-overview-delivery-edit/checkout-overview-delivery-edit.component\";\r\nimport {StepperStepComponent} from \"../stepper/component/stepper-step.component\";\r\nimport {DialogService} from \"../../service/dialog.service\";\r\n\r\n@Component({\r\n  selector: \"co-checkout\",\r\n  template: `\r\n    <co-stepper [finishButtonLabel]=\"'CHECKOUT_FINISH' | localize\" (finishStep)=\"handleDeliveryValidation()\">\r\n      <co-stepper-step #stepRelation [index]=\"1\" [label]=\"'YOUR_DATA' | localize\" (validateStep)=\"handleRelationValidation()\">\r\n        <co-checkout-overview-relation-edit #checkoutRelation [(relation)]=\"service.relation\" (relationChange)=\"service.relation = $event\"\r\n        ></co-checkout-overview-relation-edit>\r\n      </co-stepper-step>\r\n      <co-stepper-step #stepDelivery [index]=\"2\" [label]=\"'DELIVERY' | localize\">\r\n        <co-checkout-overview-delivery-edit #checkoutDelivery *ngIf=\"service.deliveryOptions\" [(relation)]=\"service.relation\" [deliveryOptionsRequest]=\"service.deliveryOptions\"\r\n                                            [transaction]=\"service.currentTransaction\"\r\n        ></co-checkout-overview-delivery-edit>\r\n      </co-stepper-step>\r\n    </co-stepper>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class CheckoutComponent {\r\n  @ViewChild(\"stepRelation\")\r\n  public stepRelation: StepperStepComponent;\r\n\r\n  @ViewChild(\"stepDelivery\")\r\n  public stepDelivery: StepperStepComponent;\r\n\r\n  @ViewChild(\"checkoutRelation\")\r\n  public checkoutRelation: CheckoutOverviewRelationEditComponent;\r\n\r\n  @ViewChild(\"checkoutDelivery\")\r\n  public checkoutDelivery: CheckoutOverviewDeliveryEditComponent;\r\n\r\n  @Output()\r\n  public transactionFinished: EventEmitter<TransactionInfo> = new EventEmitter<TransactionInfo>();\r\n\r\n  @HostBinding(\"class.co-checkout\")\r\n  public showClass(): boolean {\r\n    return true;\r\n  }\r\n\r\n  public get userIsApplicationUser(): boolean {\r\n    // TODO: return this.userService.isApplicationUser;\r\n    return true;\r\n  }\r\n\r\n  public transaction: TransactionInfoResponse;\r\n\r\n  constructor(\r\n    public service: TransactionService,\r\n    private _dictionary: DictionaryService,\r\n    private _dialogService: DialogService\r\n  ) {\r\n  }\r\n\r\n  // ngOnDestroy(): void {\r\n  //   this._subscriptions.forEach(subscription => subscription.unsubscribe());\r\n  // }\r\n\r\n  public async handleRelationValidation(): Promise<void> {\r\n    if (this.checkoutRelation && this.stepRelation) {\r\n      const valid = this.checkoutRelation.submit();\r\n      this.stepRelation.completed = valid;\r\n      if (valid) {\r\n        this.saveRelation();\r\n      }\r\n    }\r\n  }\r\n\r\n  public handleDeliveryValidation(): void {\r\n    if (this.checkoutDelivery && this.stepDelivery) {\r\n      const valid = this.checkoutDelivery.submit();\r\n      this.stepDelivery.completed = valid;\r\n      if (valid) {\r\n        this.handleSaveDelivery();\r\n      }\r\n    }\r\n  }\r\n\r\n  public saveRelation(): Promise<boolean> {\r\n    return this.service.saveRelation();\r\n  }\r\n\r\n  public async handleSaveDelivery(): Promise<boolean> {\r\n    return new Promise<boolean>((resolve: Function, reject: Function) => {\r\n      this.service.setTransactionDeliveryOptions().then(async (response) => {\r\n        if (response) {\r\n          const response: TransactionResponseBase = await this.service.saveTransaction();\r\n          if (response && response.isSuccess) {\r\n            const commitResponse: DataServiceResponseData = await this.service.commit();\r\n            if (commitResponse && commitResponse.validationResult && commitResponse.validationResult.success) {\r\n              this.transactionFinished.next(this.service.currentTransaction.transactionInfo);\r\n            }\r\n          }\r\n        } else {\r\n          await this._dialogService.showError(\"Opslag bezorging mislukt\");\r\n        }\r\n        resolve(true);\r\n      }).catch((reason: ValidationResult) => {\r\n        this._dialogService.showError(\"Opslag transactie mislukt\");\r\n      });\r\n    });\r\n  }\r\n\r\n  // public async saveNewRelation(): Promise<void> {\r\n  //   if (isNill(this.service.currentRelation.relationId)) {\r\n  //     await this.service.saveNewRelation();\r\n  //   } else {\r\n  //     await this.service.saveRelation();\r\n  //   }\r\n  // }\r\n\r\n  // public async insertData(): Promise<void> {\r\n  //   await this.service.insertCustomer(this.relation);\r\n  // }\r\n  //\r\n  // public async updateData(): Promise<void> {\r\n  //   const relation: RelationAnyType = this.relation;\r\n  //   await this.service.updateCustomer(relation);\r\n  // }\r\n\r\n  // private async _handleSettingsLoaded(loaded: boolean): Promise<void> {\r\n  //   if (loaded) {\r\n  //     await this._initConnection().then();\r\n  //     this.upAndLoaded = true;\r\n  //   }\r\n  // }\r\n  //\r\n  // private async _initConnection(): Promise<void> {\r\n  //   await this._connector.connect(this._optionsService.options);\r\n  //\r\n  //   if (this._optionsService.options.url) {\r\n  //     this._dictionary.rootUrl = this._optionsService.options.url.replace(\"/ajaxservice\", \"\");\r\n  //   }\r\n  //   await this._dictionary.setDictionary(this._optionsService.options.languageCode);\r\n  //   setTimeout(() => {\r\n  //     this._changeDetector.detectChanges();\r\n  //   });\r\n  // }\r\n  //\r\n  // public loginSubmit(): void {\r\n  //   this.globalEvents.addUserRelationShoppingCartModule.next({user: this.checkoutLogin.userEmailAddress, pw: this.checkoutLogin.userPassword});\r\n  //   this.loggedIn = true;\r\n  // }\r\n  //\r\n  // public continueWithoutAccount(): void {\r\n  //   this.closeLogin();\r\n  //   this.loggedIn = true;\r\n  //   this.transactionEvents.addNewUserToShoppingCartModule.next(this.checkoutLogin.userNewEmailAddress);\r\n  // }\r\n  //\r\n  // public createNewAccount(): void {\r\n  //   this.closeLogin();\r\n  //   this.transactionEvents.addNewUserToShoppingCartModule.next(this.checkoutLogin.userNewEmailAddress);\r\n  // }\r\n  //\r\n  // private closeLogin(): void {\r\n  //   this.loggedIn = true;\r\n  //   this.show = true;\r\n  // }\r\n}\r\n"]}