@colijnit/transaction 12.1.95 → 12.1.96

package/esm2015/lib/component/add-product/add-product.component.js

@@ -0,0 +1,102 @@
+import { __awaiter } from "tslib";
+import { Component, EventEmitter, HostBinding, Output, ViewEncapsulation } from "@angular/core";
+import { Icon } from "../../enum/icon.enum";
+import { IconCacheService } from "../../service/icon-cache.service";
+import { TransactionService } from "../../service/transaction.service";
+export class AddProductComponent {
+    constructor(iconService, _transactionService) {
+        this.iconService = iconService;
+        this._transactionService = _transactionService;
+        this.icons = Icon;
+        this.addArticle = new EventEmitter();
+        this.returnArticle = new EventEmitter();
+        this.catalogOptions = {
+            searchOnStart: true,
+            showAddToCart: false,
+            showLookAtArticleButton: false,
+            showAddArticleButton: false
+        };
+        this.catalogParameters = {};
+        this.showCatalog = false;
+        this.searchText = "";
+        this.return = false;
+    }
+    showClass() {
+        return true;
+    }
+    handleSearch(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.searchText = text;
+            this._prepareCatalogRequest();
+            // first check if there's a single article found
+            const foundArticles = yield this._transactionService.getArticles(this.catalogParameters);
+            if (foundArticles && foundArticles.length === 1) {
+                this._handleAddArticle(foundArticles[0].articleNumber);
+            }
+            else { // else open the catalog
+                this.showCatalogDialog();
+            }
+        });
+    }
+    handleCatalogArticleClick(article) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._handleAddArticle(article.articleNumber);
+            this.showCatalog = false;
+        });
+    }
+    showCatalogDialog() {
+        this._prepareCatalogRequest();
+        this.showCatalog = true;
+    }
+    handleCartIconClick(event) {
+        this.return = !this.return;
+    }
+    handleSearchIconClick(event) {
+        this.showCatalogDialog();
+    }
+    _prepareCatalogRequest() {
+        this.catalogParameters.general = this.searchText;
+        this.catalogParameters.publicationCode = 71; // todo: fix this?
+    }
+    _handleAddArticle(articleNr) {
+        this.return ? this.returnArticle.emit(articleNr) : this.addArticle.emit(articleNr);
+    }
+}
+AddProductComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-add-product",
+                template: `
+    <co-input-search
+      [(model)]="searchText"
+      [placeholder]="'SEARCH_ADD_ARTICLE' | localize"
+      [centerLabel]="true"
+      [useLeftIcon]="true"
+      [leftIconData]="iconService.getIcon(icons.CartShoppingSolid)"
+      [useRightIcon]="true"
+      (leftIconClick)="handleCartIconClick($event)"
+      (rightIconClick)="handleSearchIconClick($event)"
+      (search)="handleSearch($event)"
+    ></co-input-search>
+    <co-dialog-catalog *ngIf="showCatalog"
+                       [options]="catalogOptions"
+                       [parameters]="catalogParameters"
+                       [showNavigation]="true"
+                       (closeClick)="showCatalog = false"
+                       (articleClicked)="handleCatalogArticleClick($event)"
+    >
+    </co-dialog-catalog>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+AddProductComponent.ctorParameters = () => [
+    { type: IconCacheService },
+    { type: TransactionService }
+];
+AddProductComponent.propDecorators = {
+    addArticle: [{ type: Output }],
+    returnArticle: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-add-product",] }],
+    return: [{ type: HostBinding, args: ["class.return",] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/add-product/add-product.module.js

@@ -0,0 +1,27 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { AddProductComponent } from "./add-product.component";
+import { InputSearchModule } from "@colijnit/corecomponents_v12";
+import { QuickSendButtonModule } from "../quick-send-button/quick-send-button.module";
+import { DialogCatalogModule } from "../dialog/catalog/dialog-catalog/dialog-catalog.module";
+import { PipeModule } from "../../pipe/pipe.module";
+export class AddProductModule {
+}
+AddProductModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    InputSearchModule,
+                    QuickSendButtonModule,
+                    DialogCatalogModule,
+                    PipeModule
+                ],
+                declarations: [
+                    AddProductComponent
+                ],
+                exports: [
+                    AddProductComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -89,6 +89,7 @@ export class CheckoutOverviewRelationEditComponent {
     updateRelation(rel) {
         this.relation = rel;
         const firstActiveAddress = this._relation.activeAddresses.length > 0 ? this._relation.activeAddresses[0] : undefined;
+        this.address = firstActiveAddress;
         this.deliveryAddressNawNr = firstActiveAddress ? firstActiveAddress.nawNr : 0;
         this.deliveryAddressChange.emit(this.deliveryAddressNawNr);
         this.invoiceAddressNawNr = firstActiveAddress ? firstActiveAddress.nawNr : 0;
@@ -247,4 +248,4 @@ CheckoutOverviewRelationEditComponent.propDecorators = {
     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 {AfterViewInit, Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewEncapsulation} from \"@angular/core\";\nimport {TransactionService} from \"../../../service/transaction.service\";\nimport {FormMasterService} from \"@colijnit/corecomponents_v12\";\nimport {animate, state, style, transition, trigger} from \"@angular/animations\";\nimport {Country} from \"@colijnit/transactionapi/build/model/country.bo\";\nimport {Icon} from \"../../../enum/icon.enum\";\nimport {CustomerFullObject} from \"@colijnit/relationapi/build/model/customer-full-object.bo\";\nimport {RelationKind} from \"@colijnit/relationapi/build/enum/relation-kind.enum\";\nimport {AddressType} from \"@colijnit/relationapi/build/enum/address-type.enum\";\nimport {RelationAnyType} from \"../../../model/relation-any-type\";\nimport {Address} from \"@colijnit/relationapi/build/model/address.bo\";\nimport {RelationNameKind} from \"@colijnit/relationapi/build/enum/relation-name-kind.enum\";\nimport {SupplierFullObject} from \"@colijnit/relationapi/build/model/supplier-full-object.bo\";\nimport {Relation} from \"@colijnit/relationapi/build/model/relation.bo\";\n\n@Component({\n  selector: \"co-checkout-overview-relation-edit\",\n  template: `\n    <div class=\"relation-edit-content\">\n      <co-form>\n        <div class=\"checkout-form-wrapper\">\n          <div class=\"checkout-label-column\">\n            <span>01</span>\n            <span class=\"label-description\" [textContent]=\"'PERSONAL_DATA' | localize\"></span>\n          </div>\n          <div class=\"checkout-data-column\">\n            <div class=\"checkout-data-row\">\n              <co-relation-type *ngIf=\"relationKind === relKind.Customer\"\n                                [relation]=\"relation\"\n                                (relationChange)=\"handleRelationTypeChange($event)\"\n              ></co-relation-type>\n            </div>\n            <div class=\"checkout-data-row\" *ngIf=\"relationKind === relKind.Customer\">\n              <relation-customer-groups [model]=\"customerGroup\" (modelChange)=\"handleCustomerGroupChange($event)\" required></relation-customer-groups>\n            </div>\n            <div class=\"checkout-data-row\">\n              <co-relation-general [relation]=\"relation\" [relationType]=\"relationType\" (relationChange)=\"updateRelation($event)\"></co-relation-general>\n            </div>\n            <div class=\"checkout-data-row\">\n              <co-relation-address [address]=\"address\"></co-relation-address>\n            </div>\n          </div>\n          <div class=\"checkout-data-column\">\n            <div class=\"checkout-data-row\">\n              <co-relation-addresses\n                [relation]=\"relation\"\n                [addresses]=\"relation.addresses\"\n                [type]=\"addressType.DeliveryAddress\"\n                [selectedNawNr]=\"deliveryAddressNawNr\"\n                (selectedNawNrChange)=\"handleDeliveryAddressChange($event)\"\n              ></co-relation-addresses>\n            </div>\n          </div>\n          <div class=\"checkout-label-column\" *ngIf=\"relationKind === relKind.Customer\">\n            <span>02</span>\n            <span class=\"label-description\" [textContent]=\"'INVOICE_ADDRESS' | localize\"></span>\n          </div>\n          <div class=\"checkout-data-column\" *ngIf=\"relationKind === relKind.Customer\">\n            <div class=\"checkout-data-row\">\n              <co-input-checkbox [(model)]=\"service.invoiceAddressSameAsDelivery\" (modelChange)=\"checkSameAddress($event)\" [label]=\"'SAME_AS_DELIVERY' | localize\"></co-input-checkbox>\n            </div>\n            <div class=\"overview-delivery-invoice-address\" *ngIf=\"!service.invoiceAddressSameAsDelivery\" @showHideInvoiceAddress>\n              <div class=\"checkout-data-row\">\n                <co-relation-addresses\n                  [relation]=\"relation\"\n                  [addresses]=\"relation.activeAddresses\"\n                  [type]=\"addressType.BillingAddress\"\n                  [selectedNawNr]=\"invoiceAddressNawNr\"\n                  (selectedNawNrChange)=\"invoiceAddressChange.emit($event)\"\n                ></co-relation-addresses>\n              </div>\n            </div>\n          </div>\n          <div class=\"checkout-label-column\">\n            <span>{{  relationKind === relKind.Customer ? '03' : '02'}}</span>\n            <span class=\"label-description\" [textContent]=\"'CONTACT_DETAILS' | localize\"></span>\n          </div>\n          <div class=\"checkout-data-column\">\n            <div class=\"checkout-data-row\">\n              <co-relation-contact-details [relation]=\"relation\" [relationKind]=\"relationKind\"></co-relation-contact-details>\n            </div>\n          </div>\n          <ng-container *ngIf=\"relationKind === relKind.Customer\">\n            <div class=\"checkout-label-column\">\n              <span>04</span>\n              <span class=\"label-description\" [textContent]=\"'PRIVACY_PREFERENCES' | localize\"></span>\n            </div>\n            <div class=\"checkout-data-column\">\n              <div class=\"checkout-data-row\">\n                <co-relation-preferences [(relation)]=\"relation\"></co-relation-preferences>\n              </div>\n            </div>\n          </ng-container>\n        </div>\n      </co-form>\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    trigger(\"showHideInvoiceAddress\", [\n      state(\"void\", style({height: 0, opacity: 0})),\n      state(\"*\", style({height: \"*\", opacity: 1})),\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\n      transition(\"* => void\", animate(\"200ms ease-out\"))\n    ])\n  ],\n  encapsulation: ViewEncapsulation.None\n})\nexport class CheckoutOverviewRelationEditComponent implements OnInit, AfterViewInit {\n  public readonly relKind: typeof RelationKind = RelationKind;\n  public readonly icons: typeof Icon = Icon;\n  public readonly addressType: typeof AddressType = AddressType;\n\n  @Input()\n  public set relation(value: RelationAnyType) {\n    if (this._relation && value && this._relation.relationId === value.relationId) {\n      return;\n    }\n    this._relation = value;\n    if (this._relation) {\n      if (this._relation instanceof SupplierFullObject) {\n        this._relation.type = RelationNameKind.Company;\n        this.relationType = RelationNameKind.Company;\n      }\n      if (this._relation instanceof CustomerFullObject) {\n        this.customerGroup = this._relation.customerGroup;\n      }\n      this.address = this._relation.getFirstAddressOrCreateNew();\n    }\n  }\n\n  public get relation(): RelationAnyType {\n    return this._relation;\n  }\n\n  @Input()\n  public set relationKind(value: RelationKind) {\n    this._relationKind = value;\n    if (this._relationKind === RelationKind.Supplier) {\n      this.relationType = RelationNameKind.Company;\n    }\n  }\n\n  public get relationKind(): RelationKind {\n    return this._relationKind;\n  }\n\n  @Input()\n  public deliveryAddressNawNr: number;\n\n  @Input()\n  public invoiceAddressNawNr: number;\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 deliveryAddressChange: EventEmitter<number> = new EventEmitter<number>();\n\n  @Output()\n  public invoiceAddressChange: EventEmitter<number> = new EventEmitter<number>();\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  private _relation: RelationAnyType = new CustomerFullObject();\n  private _relationKind: RelationKind = RelationKind.Customer;\n\n  public address: Address;\n  public customerGroup: string;\n  public relationType: RelationNameKind = RelationNameKind.Private;\n\n  public get applicationUser(): boolean {\n    return this.service.applicationUser;\n  }\n\n  constructor(\n    private _formMaster: FormMasterService,\n    public service: TransactionService\n  ) {\n  }\n\n  async ngOnInit(): Promise<void> {\n    if (this._relation) {\n      this.address = this._relation.getFirstAddressOrCreateNew();\n    }\n  }\n\n  ngAfterViewInit(): void {\n    const firstActiveAddress: Address = this._relation.activeAddresses.length > 0 ? this._relation.activeAddresses[0] : undefined;\n    if (!this.deliveryAddressNawNr) {\n      this.deliveryAddressNawNr = firstActiveAddress ? firstActiveAddress.nawNr : 0;\n      this.deliveryAddressChange.emit(this.deliveryAddressNawNr);\n    }\n    if (!this.invoiceAddressNawNr) {\n      this.invoiceAddressNawNr = firstActiveAddress ? firstActiveAddress.nawNr : 0;\n      this.invoiceAddressChange.emit(this.invoiceAddressNawNr);\n    }\n  }\n\n  public handleRelationTypeChange(relation: Relation): void {\n    this.relationType = relation.type;\n  }\n\n  public handleCustomerGroupChange(group: string): void {\n    this.customerGroup = group;\n    if (this._relation instanceof CustomerFullObject) {\n      this._relation.customerGroup = this.customerGroup;\n    }\n  }\n\n  public updateRelation(rel: RelationAnyType): void {\n    this.relation = rel;\n    const firstActiveAddress: Address = this._relation.activeAddresses.length > 0 ? this._relation.activeAddresses[0] : undefined;\n    this.deliveryAddressNawNr = firstActiveAddress ? firstActiveAddress.nawNr : 0;\n    this.deliveryAddressChange.emit(this.deliveryAddressNawNr);\n    this.invoiceAddressNawNr = firstActiveAddress ? firstActiveAddress.nawNr : 0;\n    this.invoiceAddressChange.emit(this.invoiceAddressNawNr);\n    this.relationChange.emit(this.relation);\n  }\n\n  public submit(): boolean {\n    return this._formMaster.submitSlaves();\n  }\n\n  public handleDeliveryAddressChange(nawNr: number): void {\n    this.deliveryAddressChange.emit(nawNr);\n    if (this.service.invoiceAddressSameAsDelivery) {\n      this.invoiceAddressChange.emit(nawNr);\n    }\n  }\n\n  public checkSameAddress(checked: boolean): void {\n    this.invoiceAddressNawNr = this.deliveryAddressNawNr;\n    this.invoiceAddressChange.next(this.invoiceAddressNawNr);\n  }\n\n  private async _setCountryNameToAddress(address: Address): Promise<void> {\n    if (address.countryId && !address.countryName) {\n      const country: Country = await this.service.getCountry(address.countryId);\n      address.countryName = country.description;\n    }\n  }\n\n}\n"]}
+//# 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 {AfterViewInit, Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewEncapsulation} from \"@angular/core\";\nimport {TransactionService} from \"../../../service/transaction.service\";\nimport {FormMasterService} from \"@colijnit/corecomponents_v12\";\nimport {animate, state, style, transition, trigger} from \"@angular/animations\";\nimport {Country} from \"@colijnit/transactionapi/build/model/country.bo\";\nimport {Icon} from \"../../../enum/icon.enum\";\nimport {CustomerFullObject} from \"@colijnit/relationapi/build/model/customer-full-object.bo\";\nimport {RelationKind} from \"@colijnit/relationapi/build/enum/relation-kind.enum\";\nimport {AddressType} from \"@colijnit/relationapi/build/enum/address-type.enum\";\nimport {RelationAnyType} from \"../../../model/relation-any-type\";\nimport {Address} from \"@colijnit/relationapi/build/model/address.bo\";\nimport {RelationNameKind} from \"@colijnit/relationapi/build/enum/relation-name-kind.enum\";\nimport {SupplierFullObject} from \"@colijnit/relationapi/build/model/supplier-full-object.bo\";\nimport {Relation} from \"@colijnit/relationapi/build/model/relation.bo\";\n\n@Component({\n  selector: \"co-checkout-overview-relation-edit\",\n  template: `\n    <div class=\"relation-edit-content\">\n      <co-form>\n        <div class=\"checkout-form-wrapper\">\n          <div class=\"checkout-label-column\">\n            <span>01</span>\n            <span class=\"label-description\" [textContent]=\"'PERSONAL_DATA' | localize\"></span>\n          </div>\n          <div class=\"checkout-data-column\">\n            <div class=\"checkout-data-row\">\n              <co-relation-type *ngIf=\"relationKind === relKind.Customer\"\n                                [relation]=\"relation\"\n                                (relationChange)=\"handleRelationTypeChange($event)\"\n              ></co-relation-type>\n            </div>\n            <div class=\"checkout-data-row\" *ngIf=\"relationKind === relKind.Customer\">\n              <relation-customer-groups [model]=\"customerGroup\" (modelChange)=\"handleCustomerGroupChange($event)\" required></relation-customer-groups>\n            </div>\n            <div class=\"checkout-data-row\">\n              <co-relation-general [relation]=\"relation\" [relationType]=\"relationType\" (relationChange)=\"updateRelation($event)\"></co-relation-general>\n            </div>\n            <div class=\"checkout-data-row\">\n              <co-relation-address [address]=\"address\"></co-relation-address>\n            </div>\n          </div>\n          <div class=\"checkout-data-column\">\n            <div class=\"checkout-data-row\">\n              <co-relation-addresses\n                [relation]=\"relation\"\n                [addresses]=\"relation.addresses\"\n                [type]=\"addressType.DeliveryAddress\"\n                [selectedNawNr]=\"deliveryAddressNawNr\"\n                (selectedNawNrChange)=\"handleDeliveryAddressChange($event)\"\n              ></co-relation-addresses>\n            </div>\n          </div>\n          <div class=\"checkout-label-column\" *ngIf=\"relationKind === relKind.Customer\">\n            <span>02</span>\n            <span class=\"label-description\" [textContent]=\"'INVOICE_ADDRESS' | localize\"></span>\n          </div>\n          <div class=\"checkout-data-column\" *ngIf=\"relationKind === relKind.Customer\">\n            <div class=\"checkout-data-row\">\n              <co-input-checkbox [(model)]=\"service.invoiceAddressSameAsDelivery\" (modelChange)=\"checkSameAddress($event)\" [label]=\"'SAME_AS_DELIVERY' | localize\"></co-input-checkbox>\n            </div>\n            <div class=\"overview-delivery-invoice-address\" *ngIf=\"!service.invoiceAddressSameAsDelivery\" @showHideInvoiceAddress>\n              <div class=\"checkout-data-row\">\n                <co-relation-addresses\n                  [relation]=\"relation\"\n                  [addresses]=\"relation.activeAddresses\"\n                  [type]=\"addressType.BillingAddress\"\n                  [selectedNawNr]=\"invoiceAddressNawNr\"\n                  (selectedNawNrChange)=\"invoiceAddressChange.emit($event)\"\n                ></co-relation-addresses>\n              </div>\n            </div>\n          </div>\n          <div class=\"checkout-label-column\">\n            <span>{{  relationKind === relKind.Customer ? '03' : '02'}}</span>\n            <span class=\"label-description\" [textContent]=\"'CONTACT_DETAILS' | localize\"></span>\n          </div>\n          <div class=\"checkout-data-column\">\n            <div class=\"checkout-data-row\">\n              <co-relation-contact-details [relation]=\"relation\" [relationKind]=\"relationKind\"></co-relation-contact-details>\n            </div>\n          </div>\n          <ng-container *ngIf=\"relationKind === relKind.Customer\">\n            <div class=\"checkout-label-column\">\n              <span>04</span>\n              <span class=\"label-description\" [textContent]=\"'PRIVACY_PREFERENCES' | localize\"></span>\n            </div>\n            <div class=\"checkout-data-column\">\n              <div class=\"checkout-data-row\">\n                <co-relation-preferences [(relation)]=\"relation\"></co-relation-preferences>\n              </div>\n            </div>\n          </ng-container>\n        </div>\n      </co-form>\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    trigger(\"showHideInvoiceAddress\", [\n      state(\"void\", style({height: 0, opacity: 0})),\n      state(\"*\", style({height: \"*\", opacity: 1})),\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\n      transition(\"* => void\", animate(\"200ms ease-out\"))\n    ])\n  ],\n  encapsulation: ViewEncapsulation.None\n})\nexport class CheckoutOverviewRelationEditComponent implements OnInit, AfterViewInit {\n  public readonly relKind: typeof RelationKind = RelationKind;\n  public readonly icons: typeof Icon = Icon;\n  public readonly addressType: typeof AddressType = AddressType;\n\n  @Input()\n  public set relation(value: RelationAnyType) {\n    if (this._relation && value && this._relation.relationId === value.relationId) {\n      return;\n    }\n    this._relation = value;\n    if (this._relation) {\n      if (this._relation instanceof SupplierFullObject) {\n        this._relation.type = RelationNameKind.Company;\n        this.relationType = RelationNameKind.Company;\n      }\n      if (this._relation instanceof CustomerFullObject) {\n        this.customerGroup = this._relation.customerGroup;\n      }\n      this.address = this._relation.getFirstAddressOrCreateNew();\n    }\n  }\n\n  public get relation(): RelationAnyType {\n    return this._relation;\n  }\n\n  @Input()\n  public set relationKind(value: RelationKind) {\n    this._relationKind = value;\n    if (this._relationKind === RelationKind.Supplier) {\n      this.relationType = RelationNameKind.Company;\n    }\n  }\n\n  public get relationKind(): RelationKind {\n    return this._relationKind;\n  }\n\n  @Input()\n  public deliveryAddressNawNr: number;\n\n  @Input()\n  public invoiceAddressNawNr: number;\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 deliveryAddressChange: EventEmitter<number> = new EventEmitter<number>();\n\n  @Output()\n  public invoiceAddressChange: EventEmitter<number> = new EventEmitter<number>();\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  private _relation: RelationAnyType = new CustomerFullObject();\n  private _relationKind: RelationKind = RelationKind.Customer;\n\n  public address: Address;\n  public customerGroup: string;\n  public relationType: RelationNameKind = RelationNameKind.Private;\n\n  public get applicationUser(): boolean {\n    return this.service.applicationUser;\n  }\n\n  constructor(\n    private _formMaster: FormMasterService,\n    public service: TransactionService\n  ) {\n  }\n\n  async ngOnInit(): Promise<void> {\n    if (this._relation) {\n      this.address = this._relation.getFirstAddressOrCreateNew();\n    }\n  }\n\n  ngAfterViewInit(): void {\n    const firstActiveAddress: Address = this._relation.activeAddresses.length > 0 ? this._relation.activeAddresses[0] : undefined;\n    if (!this.deliveryAddressNawNr) {\n      this.deliveryAddressNawNr = firstActiveAddress ? firstActiveAddress.nawNr : 0;\n      this.deliveryAddressChange.emit(this.deliveryAddressNawNr);\n    }\n    if (!this.invoiceAddressNawNr) {\n      this.invoiceAddressNawNr = firstActiveAddress ? firstActiveAddress.nawNr : 0;\n      this.invoiceAddressChange.emit(this.invoiceAddressNawNr);\n    }\n  }\n\n  public handleRelationTypeChange(relation: Relation): void {\n    this.relationType = relation.type;\n  }\n\n  public handleCustomerGroupChange(group: string): void {\n    this.customerGroup = group;\n    if (this._relation instanceof CustomerFullObject) {\n      this._relation.customerGroup = this.customerGroup;\n    }\n  }\n\n  public updateRelation(rel: RelationAnyType): void {\n    this.relation = rel;\n    const firstActiveAddress: Address = this._relation.activeAddresses.length > 0 ? this._relation.activeAddresses[0] : undefined;\n    this.address = firstActiveAddress;\n    this.deliveryAddressNawNr = firstActiveAddress ? firstActiveAddress.nawNr : 0;\n    this.deliveryAddressChange.emit(this.deliveryAddressNawNr);\n    this.invoiceAddressNawNr = firstActiveAddress ? firstActiveAddress.nawNr : 0;\n    this.invoiceAddressChange.emit(this.invoiceAddressNawNr);\n    this.relationChange.emit(this.relation);\n  }\n\n  public submit(): boolean {\n    return this._formMaster.submitSlaves();\n  }\n\n  public handleDeliveryAddressChange(nawNr: number): void {\n    this.deliveryAddressChange.emit(nawNr);\n    if (this.service.invoiceAddressSameAsDelivery) {\n      this.invoiceAddressChange.emit(nawNr);\n    }\n  }\n\n  public checkSameAddress(checked: boolean): void {\n    this.invoiceAddressNawNr = this.deliveryAddressNawNr;\n    this.invoiceAddressChange.next(this.invoiceAddressNawNr);\n  }\n\n  private async _setCountryNameToAddress(address: Address): Promise<void> {\n    if (address.countryId && !address.countryName) {\n      const country: Country = await this.service.getCountry(address.countryId);\n      address.countryName = country.description;\n    }\n  }\n\n}\n"]}

package/esm2015/lib/component/quick-send-button/quick-send-button.component.js

@@ -5,6 +5,8 @@ export class QuickSendButtonComponent {
     constructor(iconCacheService) {
         this.iconCacheService = iconCacheService;
         this.icons = Icon;
+        this.title = 'SEND';
+        this.icon = Icon.ShareSolid;
         this.showSendMethodIcon = true;
         this.showSendMethodDialogIcon = true;
         this.showLoader = false;
@@ -19,12 +21,17 @@ QuickSendButtonComponent.decorators = [
     { type: Component, args: [{
                 selector: "co-quick-send-button",
                 template: `
-    <div class="icons-wrapper" [class.disabled]="showLoader" [class.no-dialog]="!showSendMethodDialogIcon">
+    <div class="quick-send-button-wrapper" [class.disabled]="showLoader" [class.no-dialog]="!showSendMethodDialogIcon">
       <co-loader *ngIf="showLoader"></co-loader>
       <div class="icon-wrapper-flat-left" (click)="sendIconClicked.emit($event)">
-        <co-icon [iconData]="iconCacheService.getIcon(icons.ShareSolid)" class="icon-send"></co-icon>
-        <co-icon *ngIf="showSendMethodIcon" class="icon-method"
-          [iconData]="iconCacheService.getIcon(defaultMethodIcon ? defaultMethodIcon : icons.AtSolid)"></co-icon>
+        <div class="icons-and-title-wrapper">
+          <div class="icons-wrapper">
+            <co-icon [iconData]="iconCacheService.getIcon(icon)" class="icon-send"></co-icon>
+            <co-icon *ngIf="showSendMethodIcon" class="icon-method"
+              [iconData]="iconCacheService.getIcon(defaultMethodIcon ? defaultMethodIcon : icons.AtSolid)"></co-icon>
+            </div>
+          <span class="send-button-title" [textContent]="title | localize"></span>
+        </div>
       </div>
       <div class="icons-spacer" *ngIf="showSendMethodDialogIcon"></div>
       <div class="icon-wrapper-flat-right" *ngIf="showSendMethodDialogIcon" (click)="openSendMethodDialog.emit($event)">
@@ -39,6 +46,8 @@ QuickSendButtonComponent.ctorParameters = () => [
     { type: IconCacheService }
 ];
 QuickSendButtonComponent.propDecorators = {
+    title: [{ type: Input }],
+    icon: [{ type: Input }],
     defaultMethodIcon: [{ type: Input }],
     showSendMethodIcon: [{ type: Input }],
     showSendMethodDialogIcon: [{ type: Input }],
@@ -47,4 +56,4 @@ QuickSendButtonComponent.propDecorators = {
     openSendMethodDialog: [{ type: Output }],
     sendIconClicked: [{ type: Output }]
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/relation/relation-addresses/relation-addresses.component.js

@@ -25,6 +25,11 @@ export class RelationAddressesComponent extends RelationBaseComponent {
     showClass() {
         return true;
     }
+    ngAfterViewInit() {
+        if (!this.selectedNawNr && this.addresses && this.addresses.length > 0) {
+            this.changeAddress(this.addresses[0]);
+        }
+    }
     submitForm() {
         if (this._formMasterService.submitSlaves()) {
             this.saveAddress(this.addressToEdit);
@@ -128,4 +133,4 @@ RelationAddressesComponent.propDecorators = {
     selectedNawNrChange: [{ type: Output }],
     showClass: [{ type: HostBinding, args: ["class.co-relation-addresses",] }]
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"relation-addresses.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/relation/relation-addresses/relation-addresses.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation} from \"@angular/core\";\r\nimport {Icon} from \"../../../enum/icon.enum\";\r\nimport {RelationBaseComponent} from \"../relation-base.component\";\r\nimport {FormMasterService} from \"@colijnit/corecomponents_v12\";\r\nimport {Address} from \"@colijnit/relationapi/build/model/address.bo\";\r\nimport {AddressType} from \"@colijnit/relationapi/build/enum/address-type.enum\";\r\nimport {BusinessObjectFactory} from \"@colijnit/ioneconnector/build/factory/business-object-factory\";\r\nimport {RelationService} from \"../../../service/relation.service\";\r\n\r\n@Component({\r\n  selector: \"co-relation-addresses\",\r\n  template: `\r\n    <div class=\"default-data-row\">\r\n      <co-carousel *ngIf=\"addresses && addresses.length > 1\">\r\n        <co-relation-address-tile #carouselItem *ngFor=\"let address of addresses | filter:'isActive':true; let index = index\"\r\n                                  [address]=\"address\"\r\n                                  [selected]=\"selectedNawNr === address.nawNr\"\r\n                                  (editAddressClicked)=\"editAddress($event)\"\r\n                                  (selectedChange)=\"changeAddress($event)\"\r\n        ></co-relation-address-tile>\r\n      </co-carousel>\r\n    </div>\r\n    <div class=\"default-data-row\" *ngIf=\"!readonly\">\r\n      <div class=\"relation-address-new\">\r\n        <icon class=\"relation-address-icon\" [icon]=\"icons.ArrowPointRight\"></icon>\r\n        <div [textContent]=\"'ADDRESS_ADD' | localize\" (click)=\"showNewAddressDialog()\"></div>\r\n      </div>\r\n    </div>\r\n    <co-dialog class=\"dialog-relation-addresses-create-address\" *ngIf=\"showEditAddressDialog\"\r\n               [footerTemplate]=\"templateFooter\"\r\n               [headerTemplate]=\"templateHeader\"\r\n               (closeClick)=\"showEditAddressDialog = false\"\r\n    >\r\n      <co-form>\r\n        <co-relation-address\r\n          [relation]=\"relation\"\r\n          [(address)]=\"addressToEdit\"\r\n        ></co-relation-address>\r\n      </co-form>\r\n      <ng-template #templateHeader>\r\n        <div class=\"co-dialog-header-title\" [textContent]=\"'NEW_ADDRESS' | localize\"></div>\r\n      </ng-template>\r\n      <ng-template #templateFooter>\r\n        <div class=\"co-dialog-footer-button-wrapper\">\r\n          <co-button [label]=\"'OK' | localize\" (click)=\"submitForm()\"></co-button>\r\n        </div>\r\n      </ng-template>\r\n    </co-dialog>\r\n  `,\r\n  providers: [\r\n    FormMasterService\r\n  ],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class RelationAddressesComponent extends RelationBaseComponent {\r\n  public readonly icons: typeof Icon = Icon;\r\n\r\n  @Input()\r\n  public readonly: boolean = false;\r\n\r\n  @Input()\r\n  public addresses: Address[] = [];\r\n\r\n  @Input()\r\n  public showOnlyActive: boolean = true;\r\n\r\n  @Input()\r\n  public type: AddressType = AddressType.DeliveryAddress;\r\n\r\n  @Input()\r\n  public selectedNawNr: number = 0;\r\n\r\n  @Output()\r\n  public selectedNawNrChange: EventEmitter<number> = new EventEmitter<number>();\r\n\r\n  @HostBinding(\"class.co-relation-addresses\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public showEditAddressDialog: boolean = false;\r\n  public addressToEdit: Address;\r\n\r\n  private _boFactory: BusinessObjectFactory = new BusinessObjectFactory();\r\n\r\n  constructor(\r\n    private _formMasterService: FormMasterService,\r\n    private _relationService: RelationService\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  public submitForm(): void {\r\n    if (this._formMasterService.submitSlaves()) {\r\n      this.saveAddress(this.addressToEdit);\r\n    }\r\n  }\r\n\r\n  public async saveAddress(address: Address): Promise<void> {\r\n    address.relationId = this.relation.relationId;\r\n    address.addressType = this.type;\r\n    if (!address.nawNr) { // new address\r\n      address.startDate = new Date();\r\n      address.sequence = this.relation.getNextAddressSequence();\r\n      const savedAddress: Address = await this._relationService.insertAddress(address);\r\n      this.relation.addresses.push(savedAddress);\r\n      this.changeAddress(savedAddress);\r\n    } else {\r\n      const savedAddress: Address = await this._relationService.updateAddress(address);\r\n      const idx: number = this.relation.addresses.findIndex(a => a.nawNr === address.nawNr);\r\n      if (idx > -1) {\r\n        this.relation.addresses[idx] = savedAddress;\r\n      }\r\n    }\r\n    this.showEditAddressDialog = false;\r\n  }\r\n\r\n  public showNewAddressDialog(): void {\r\n    this.addressToEdit = new Address();\r\n    this.showEditAddressDialog = true;\r\n  }\r\n\r\n  public changeAddress(address: Address): void {\r\n    if (address && !this.readonly) {\r\n      this.selectedNawNr = address.nawNr;\r\n      this.selectedNawNrChange.emit(this.selectedNawNr);\r\n    }\r\n  }\r\n\r\n  public editAddress(addr: Address): void {\r\n    if (!this.readonly) {\r\n      this.addressToEdit = <Address><unknown>this._boFactory.makeWithRawBackendData(Address, addr);\r\n      this.showEditAddressDialog = true;\r\n    }\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"relation-addresses.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/relation/relation-addresses/relation-addresses.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {AfterViewInit, Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation} from \"@angular/core\";\r\nimport {Icon} from \"../../../enum/icon.enum\";\r\nimport {RelationBaseComponent} from \"../relation-base.component\";\r\nimport {FormMasterService} from \"@colijnit/corecomponents_v12\";\r\nimport {Address} from \"@colijnit/relationapi/build/model/address.bo\";\r\nimport {AddressType} from \"@colijnit/relationapi/build/enum/address-type.enum\";\r\nimport {BusinessObjectFactory} from \"@colijnit/ioneconnector/build/factory/business-object-factory\";\r\nimport {RelationService} from \"../../../service/relation.service\";\r\n\r\n@Component({\r\n  selector: \"co-relation-addresses\",\r\n  template: `\r\n    <div class=\"default-data-row\">\r\n      <co-carousel *ngIf=\"addresses && addresses.length > 1\">\r\n        <co-relation-address-tile #carouselItem *ngFor=\"let address of addresses | filter:'isActive':true; let index = index\"\r\n                                  [address]=\"address\"\r\n                                  [selected]=\"selectedNawNr === address.nawNr\"\r\n                                  (editAddressClicked)=\"editAddress($event)\"\r\n                                  (selectedChange)=\"changeAddress($event)\"\r\n        ></co-relation-address-tile>\r\n      </co-carousel>\r\n    </div>\r\n    <div class=\"default-data-row\" *ngIf=\"!readonly\">\r\n      <div class=\"relation-address-new\">\r\n        <icon class=\"relation-address-icon\" [icon]=\"icons.ArrowPointRight\"></icon>\r\n        <div [textContent]=\"'ADDRESS_ADD' | localize\" (click)=\"showNewAddressDialog()\"></div>\r\n      </div>\r\n    </div>\r\n    <co-dialog class=\"dialog-relation-addresses-create-address\" *ngIf=\"showEditAddressDialog\"\r\n               [footerTemplate]=\"templateFooter\"\r\n               [headerTemplate]=\"templateHeader\"\r\n               (closeClick)=\"showEditAddressDialog = false\"\r\n    >\r\n      <co-form>\r\n        <co-relation-address\r\n          [relation]=\"relation\"\r\n          [(address)]=\"addressToEdit\"\r\n        ></co-relation-address>\r\n      </co-form>\r\n      <ng-template #templateHeader>\r\n        <div class=\"co-dialog-header-title\" [textContent]=\"'NEW_ADDRESS' | localize\"></div>\r\n      </ng-template>\r\n      <ng-template #templateFooter>\r\n        <div class=\"co-dialog-footer-button-wrapper\">\r\n          <co-button [label]=\"'OK' | localize\" (click)=\"submitForm()\"></co-button>\r\n        </div>\r\n      </ng-template>\r\n    </co-dialog>\r\n  `,\r\n  providers: [\r\n    FormMasterService\r\n  ],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class RelationAddressesComponent extends RelationBaseComponent implements AfterViewInit {\r\n  public readonly icons: typeof Icon = Icon;\r\n\r\n  @Input()\r\n  public readonly: boolean = false;\r\n\r\n  @Input()\r\n  public addresses: Address[] = [];\r\n\r\n  @Input()\r\n  public showOnlyActive: boolean = true;\r\n\r\n  @Input()\r\n  public type: AddressType = AddressType.DeliveryAddress;\r\n\r\n  @Input()\r\n  public selectedNawNr: number = 0;\r\n\r\n  @Output()\r\n  public selectedNawNrChange: EventEmitter<number> = new EventEmitter<number>();\r\n\r\n  @HostBinding(\"class.co-relation-addresses\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public showEditAddressDialog: boolean = false;\r\n  public addressToEdit: Address;\r\n\r\n  private _boFactory: BusinessObjectFactory = new BusinessObjectFactory();\r\n\r\n  constructor(\r\n    private _formMasterService: FormMasterService,\r\n    private _relationService: RelationService\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    if (!this.selectedNawNr && this.addresses && this.addresses.length > 0) {\r\n      this.changeAddress(this.addresses[0]);\r\n    }\r\n  }\r\n\r\n  public submitForm(): void {\r\n    if (this._formMasterService.submitSlaves()) {\r\n      this.saveAddress(this.addressToEdit);\r\n    }\r\n  }\r\n\r\n  public async saveAddress(address: Address): Promise<void> {\r\n    address.relationId = this.relation.relationId;\r\n    address.addressType = this.type;\r\n    if (!address.nawNr) { // new address\r\n      address.startDate = new Date();\r\n      address.sequence = this.relation.getNextAddressSequence();\r\n      const savedAddress: Address = await this._relationService.insertAddress(address);\r\n      this.relation.addresses.push(savedAddress);\r\n      this.changeAddress(savedAddress);\r\n    } else {\r\n      const savedAddress: Address = await this._relationService.updateAddress(address);\r\n      const idx: number = this.relation.addresses.findIndex(a => a.nawNr === address.nawNr);\r\n      if (idx > -1) {\r\n        this.relation.addresses[idx] = savedAddress;\r\n      }\r\n    }\r\n    this.showEditAddressDialog = false;\r\n  }\r\n\r\n  public showNewAddressDialog(): void {\r\n    this.addressToEdit = new Address();\r\n    this.showEditAddressDialog = true;\r\n  }\r\n\r\n  public changeAddress(address: Address): void {\r\n    if (address && !this.readonly) {\r\n      this.selectedNawNr = address.nawNr;\r\n      this.selectedNawNrChange.emit(this.selectedNawNr);\r\n    }\r\n  }\r\n\r\n  public editAddress(addr: Address): void {\r\n    if (!this.readonly) {\r\n      this.addressToEdit = <Address><unknown>this._boFactory.makeWithRawBackendData(Address, addr);\r\n      this.showEditAddressDialog = true;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/lib/component/relation/relation-general/relation-general.component.js

@@ -76,7 +76,11 @@ export class RelationGeneralComponent extends RelationBaseComponent {
                 }
                 else {
                     this.hideSidebar();
-                    this.relation = yield this._relationService.getRelation(relationSuggested.relationType, parseInt(relationSuggested.relationNr));
+                    const suggestedRelation = yield this._relationService.getRelation(relationSuggested.relationType, parseInt(relationSuggested.relationNr));
+                    if (suggestedRelation && suggestedRelation.addresses && suggestedRelation.addresses.length > 0) {
+                        suggestedRelation.addresses.sort((a, b) => a.sequence < b.sequence ? -1 : 1);
+                    }
+                    this.relation = suggestedRelation;
                     this.relationChange.next(this.relation);
                 }
             }
@@ -228,4 +232,4 @@ RelationGeneralComponent.propDecorators = {
     relationType: [{ type: Input }],
     showClass: [{ type: HostBinding, args: ["class.co-relation-general",] }]
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"relation-general.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/relation/relation-general/relation-general.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, HostBinding, Input, ViewEncapsulation} from \"@angular/core\";\r\nimport {RelationRequest} from \"@colijnit/relationapi/build/model/relation-request\";\r\nimport {TransactionService} from \"../../../service/transaction.service\";\r\nimport {animate, state, style, transition, trigger} from \"@angular/animations\";\r\nimport {RelationBaseComponent} from \"../relation-base.component\";\r\nimport {ValidationResult} from \"@colijnit/ioneconnector/build/model/validation-result\";\r\nimport {DialogService} from \"../../../service/dialog.service\";\r\nimport {DictionaryService} from \"../../../service/dictionary.service\";\r\nimport {RelationNameKind} from \"@colijnit/relationapi/build/enum/relation-name-kind.enum\";\r\nimport {GenderType} from \"@colijnit/relationapi/build/enum/gender-type.enum\";\r\nimport {RelationListObject} from \"@colijnit/relationapi/build/model/relation-list-object.bo\";\r\nimport {FunctionUtils} from \"@colijnit/ioneconnector/build/utils/function-utils\";\r\nimport {ObjectUtils} from \"@colijnit/ioneconnector/build/utils/object-utils\";\r\nimport {RelationService} from \"../../../service/relation.service\";\r\n\r\n@Component({\r\n  selector: \"co-relation-general\",\r\n  template: `\r\n    <div *ngIf=\"relationType === relType.Private\" class=\"collapseable\" @showHidePrivateRelationFields>\r\n      <div class=\"default-data-row\">\r\n        <co-input-text\r\n          class=\"checkout-first-name\"\r\n          [readonly]=\"readonly\"\r\n          [(model)]=\"relation.firstName\"\r\n          [placeholder]=\"'FIRST_NAME' | localize\"\r\n          (modelChange)=\"firstNameChange($event)\"\r\n          (blur)=\"checkVisibilitySuggestions()\"\r\n          [required]=\"true\"\r\n        ></co-input-text>\r\n        <co-input-text\r\n          class=\"checkout-prefix-name default-width\"\r\n          [readonly]=\"readonly\"\r\n          [(model)]=\"relation.prefix\"\r\n          [placeholder]=\"'PREFIX' | localize\"\r\n        ></co-input-text>\r\n        <co-input-text\r\n          class=\"checkout-last-name\"\r\n          [readonly]=\"readonly\"\r\n          [(model)]=\"relation.familyName\"\r\n          [placeholder]=\"'LAST_NAME' | localize\"\r\n          (modelChange)=\"familyNameChange($event)\"\r\n          (blur)=\"checkVisibilitySuggestions()\"\r\n          [required]=\"true\"></co-input-text>\r\n      </div>\r\n      <div class=\"default-data-row\">\r\n        <co-input-radio-button class=\"default-width\"\r\n                               [readonly]=\"readonly\"\r\n                               [label]=\"'MALE' | localize\"\r\n                               [model]=\"relation.gender === genderType.Male\"\r\n                               (modelChange)=\"changeGenderType(genderType.Male)\"\r\n        ></co-input-radio-button>\r\n        <co-input-radio-button class=\"default-width\"\r\n                               [readonly]=\"readonly\"\r\n                               [label]=\"'FEMALE' | localize\"\r\n                               [model]=\"relation.gender === genderType.Female\"\r\n                               (modelChange)=\"changeGenderType(genderType.Female)\"\r\n        ></co-input-radio-button>\r\n        <co-input-radio-button class=\"default-width\"\r\n                               [readonly]=\"readonly\"\r\n                               [label]=\"'UNKNOWN' | localize\"\r\n                               [model]=\"relation.gender === genderType.Unspecified\"\r\n                               (modelChange)=\"changeGenderType(genderType.Unspecified)\"\r\n        ></co-input-radio-button>\r\n      </div>\r\n      <!--\r\n            <div class=\"default-data-row\">\r\n              <co-input-date [readonly]=\"readonly\" [placeholder]=\"'DATE_OF_BIRTH' | localize \" [(model)]=\"dateOfBirth\"></co-input-date>\r\n            </div>\r\n      -->\r\n    </div>\r\n    <div *ngIf=\"relationType === relType.Company\" class=\"default-data-row collapseable\" @showHideCompanyRelationFields>\r\n      <co-input-text [readonly]=\"readonly\"\r\n                     [(model)]=\"relation.familyName\"\r\n                     [placeholder]=\"'COMPANY_NAME' | localize\"\r\n                     [required]=\"true\"\r\n                     (modelChange)=\"familyNameChange($event)\"\r\n                     (blur)=\"checkVisibilitySuggestions()\"\r\n      ></co-input-text>\r\n    </div>\r\n\r\n    <div class=\"suggestions-sidebar\" *ngIf=\"showSuggestionsSidebar\" @showHideSidebar>\r\n      <div class=\"relation-sidebar-header\">\r\n        <label class=\"checkout-label-h3\" [textContent]=\"'SUGGESTIONS' | localize\"></label>\r\n      </div>\r\n      <co-relation-suggestions-list\r\n        [suggestions]=\"relationSuggestions\"\r\n        (suggestionSelected)=\"onRelationSuggestionClick($event)\"\r\n      ></co-relation-suggestions-list>\r\n    </div>\r\n  `,\r\n  animations: [\r\n    trigger(\"showHidePrivateRelationFields\", [\r\n      state(\"void\", style({height: 0})),\r\n      state(\"*\", style({height: \"*\"})),\r\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\r\n      transition(\"* => void\", animate(\"200ms ease-out\"))\r\n    ]),\r\n    trigger(\"showHideCompanyRelationFields\", [\r\n      state(\"void\", style({height: 0})),\r\n      state(\"*\", style({height: \"*\"})),\r\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\r\n      transition(\"* => void\", animate(\"200ms ease-out\"))\r\n    ]),\r\n    trigger(\"showHideSidebar\", [\r\n      state(\"void\", style({transform: \"translateX(100%)\"})),\r\n      state(\"*\", style({transform: \"translateX(0)\"})),\r\n      transition(\"void <=> *\", animate(\"200ms ease-in-out\"))\r\n    ])\r\n  ],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class RelationGeneralComponent extends RelationBaseComponent {\r\n  public readonly relType: typeof RelationNameKind = RelationNameKind;\r\n  public readonly genderType: typeof GenderType = GenderType;\r\n\r\n  @Input()\r\n  public readonly: boolean = false;\r\n\r\n  @Input()\r\n  public relationType: RelationNameKind = RelationNameKind.Private;\r\n\r\n  @HostBinding(\"class.co-relation-general\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public relationSuggestions: RelationListObject[] = [];\r\n  public showSuggestionsSidebar: boolean = false;\r\n  public dateOfBirth: Date; // todo: this needs to be on the relation object\r\n\r\n  constructor(\r\n    private _service: TransactionService,\r\n    private _dictionaryService: DictionaryService,\r\n    private _dialogService: DialogService,\r\n    private _relationService: RelationService\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  public firstNameChange(firstName: string): void {\r\n    if (this.relation) {\r\n      this.relation.firstName = firstName;\r\n      this.relationChange.emit(this.relation);\r\n    }\r\n    this._relationNameChangeHandler.call(this);\r\n  }\r\n\r\n  public familyNameChange(familyName: string): void {\r\n    if (this.relation) {\r\n      this.relation.familyName = familyName;\r\n      this.relationChange.emit(this.relation);\r\n    }\r\n    this._relationNameChangeHandler.call(this);\r\n  }\r\n\r\n  public changeGenderType(value: GenderType): void {\r\n    this.relation.gender = value;\r\n    this.relationChange.emit(this.relation);\r\n  }\r\n\r\n  public checkVisibilitySuggestions(): void {\r\n    if (this.relation.firstName && this.relation.familyName) {\r\n      this.hideSidebar();\r\n    }\r\n  }\r\n\r\n  public showSidebar(): void {\r\n    if (!this.readonly) {\r\n      this.showSuggestionsSidebar = true;\r\n    }\r\n  }\r\n\r\n  // Hide sidebar with a little timeout to prevent missing the click\r\n  public hideSidebar(): void {\r\n    setTimeout(() => {\r\n      this.showSuggestionsSidebar = false;\r\n    }, 200);\r\n  }\r\n\r\n  public async onRelationSuggestionClick(relationSuggested: RelationListObject): Promise<void> {\r\n    if (relationSuggested) {\r\n      const lockResult: ValidationResult = await this._relationService.lockRelation(relationSuggested.relationType, parseInt(relationSuggested.relationNr, 0));\r\n      if (!lockResult.success) {\r\n        this._dialogService.showError(this._dictionaryService.get(\"RELATION_ALREADY_LOCKED\"), lockResult.messages[0].message);\r\n      } else {\r\n        this.hideSidebar();\r\n        this.relation = await this._relationService.getRelation(relationSuggested.relationType, parseInt(relationSuggested.relationNr));\r\n        this.relationChange.next(this.relation);\r\n      }\r\n    }\r\n  }\r\n\r\n  protected relationSet(): void {\r\n    super.relationSet();\r\n    if (!this.relation.type) {\r\n      this.relation.type = RelationNameKind.Private;\r\n      this.relation.gender = GenderType.Unspecified;\r\n    }\r\n  }\r\n\r\n  // fetches relation suggestions\r\n  private _relationNameChangeHandler: Function = FunctionUtils.Throttle(() => {\r\n    return this._relationNameChangedHandlerFn();\r\n    // eslint-disable-next-line no-magic-numbers\r\n  }, 600);\r\n\r\n  // load suggestions\r\n  private async _relationNameChangedHandlerFn(): Promise<any> {\r\n    const firstName: string = ObjectUtils.ValueOrDefault(this.relation.firstName);\r\n    const secondName: string = ObjectUtils.ValueOrDefault(this.relation.familyName);\r\n\r\n    if (!firstName && !secondName) {\r\n      this.relationSuggestions = [];\r\n      this.hideSidebar();\r\n      return;\r\n    }\r\n\r\n    const relationRequest: RelationRequest = new RelationRequest();\r\n    relationRequest.relationType = this._service.getRelationKindFromTransactionKind();\r\n    if (firstName) {\r\n      relationRequest.firstName = firstName;\r\n    }\r\n\r\n    if (secondName) {\r\n      relationRequest.familyName = secondName;\r\n    }\r\n\r\n    this._relationService.getRelationListObjects(relationRequest).then((relations: RelationListObject[]) => {\r\n      this.relationSuggestions = relations;\r\n      if (relations && relations.length > 0) {\r\n        this.showSidebar();\r\n      } else {\r\n        this.hideSidebar();\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"relation-general.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/relation/relation-general/relation-general.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, HostBinding, Input, ViewEncapsulation} from \"@angular/core\";\r\nimport {RelationRequest} from \"@colijnit/relationapi/build/model/relation-request\";\r\nimport {TransactionService} from \"../../../service/transaction.service\";\r\nimport {animate, state, style, transition, trigger} from \"@angular/animations\";\r\nimport {RelationBaseComponent} from \"../relation-base.component\";\r\nimport {ValidationResult} from \"@colijnit/ioneconnector/build/model/validation-result\";\r\nimport {DialogService} from \"../../../service/dialog.service\";\r\nimport {DictionaryService} from \"../../../service/dictionary.service\";\r\nimport {RelationNameKind} from \"@colijnit/relationapi/build/enum/relation-name-kind.enum\";\r\nimport {GenderType} from \"@colijnit/relationapi/build/enum/gender-type.enum\";\r\nimport {RelationListObject} from \"@colijnit/relationapi/build/model/relation-list-object.bo\";\r\nimport {FunctionUtils} from \"@colijnit/ioneconnector/build/utils/function-utils\";\r\nimport {ObjectUtils} from \"@colijnit/ioneconnector/build/utils/object-utils\";\r\nimport {RelationService} from \"../../../service/relation.service\";\r\nimport {RelationAnyType} from \"@colijnit/relationapi/build/model/relation-any-type\";\r\n\r\n@Component({\r\n  selector: \"co-relation-general\",\r\n  template: `\r\n    <div *ngIf=\"relationType === relType.Private\" class=\"collapseable\" @showHidePrivateRelationFields>\r\n      <div class=\"default-data-row\">\r\n        <co-input-text\r\n          class=\"checkout-first-name\"\r\n          [readonly]=\"readonly\"\r\n          [(model)]=\"relation.firstName\"\r\n          [placeholder]=\"'FIRST_NAME' | localize\"\r\n          (modelChange)=\"firstNameChange($event)\"\r\n          (blur)=\"checkVisibilitySuggestions()\"\r\n          [required]=\"true\"\r\n        ></co-input-text>\r\n        <co-input-text\r\n          class=\"checkout-prefix-name default-width\"\r\n          [readonly]=\"readonly\"\r\n          [(model)]=\"relation.prefix\"\r\n          [placeholder]=\"'PREFIX' | localize\"\r\n        ></co-input-text>\r\n        <co-input-text\r\n          class=\"checkout-last-name\"\r\n          [readonly]=\"readonly\"\r\n          [(model)]=\"relation.familyName\"\r\n          [placeholder]=\"'LAST_NAME' | localize\"\r\n          (modelChange)=\"familyNameChange($event)\"\r\n          (blur)=\"checkVisibilitySuggestions()\"\r\n          [required]=\"true\"></co-input-text>\r\n      </div>\r\n      <div class=\"default-data-row\">\r\n        <co-input-radio-button class=\"default-width\"\r\n                               [readonly]=\"readonly\"\r\n                               [label]=\"'MALE' | localize\"\r\n                               [model]=\"relation.gender === genderType.Male\"\r\n                               (modelChange)=\"changeGenderType(genderType.Male)\"\r\n        ></co-input-radio-button>\r\n        <co-input-radio-button class=\"default-width\"\r\n                               [readonly]=\"readonly\"\r\n                               [label]=\"'FEMALE' | localize\"\r\n                               [model]=\"relation.gender === genderType.Female\"\r\n                               (modelChange)=\"changeGenderType(genderType.Female)\"\r\n        ></co-input-radio-button>\r\n        <co-input-radio-button class=\"default-width\"\r\n                               [readonly]=\"readonly\"\r\n                               [label]=\"'UNKNOWN' | localize\"\r\n                               [model]=\"relation.gender === genderType.Unspecified\"\r\n                               (modelChange)=\"changeGenderType(genderType.Unspecified)\"\r\n        ></co-input-radio-button>\r\n      </div>\r\n      <!--\r\n            <div class=\"default-data-row\">\r\n              <co-input-date [readonly]=\"readonly\" [placeholder]=\"'DATE_OF_BIRTH' | localize \" [(model)]=\"dateOfBirth\"></co-input-date>\r\n            </div>\r\n      -->\r\n    </div>\r\n    <div *ngIf=\"relationType === relType.Company\" class=\"default-data-row collapseable\" @showHideCompanyRelationFields>\r\n      <co-input-text [readonly]=\"readonly\"\r\n                     [(model)]=\"relation.familyName\"\r\n                     [placeholder]=\"'COMPANY_NAME' | localize\"\r\n                     [required]=\"true\"\r\n                     (modelChange)=\"familyNameChange($event)\"\r\n                     (blur)=\"checkVisibilitySuggestions()\"\r\n      ></co-input-text>\r\n    </div>\r\n\r\n    <div class=\"suggestions-sidebar\" *ngIf=\"showSuggestionsSidebar\" @showHideSidebar>\r\n      <div class=\"relation-sidebar-header\">\r\n        <label class=\"checkout-label-h3\" [textContent]=\"'SUGGESTIONS' | localize\"></label>\r\n      </div>\r\n      <co-relation-suggestions-list\r\n        [suggestions]=\"relationSuggestions\"\r\n        (suggestionSelected)=\"onRelationSuggestionClick($event)\"\r\n      ></co-relation-suggestions-list>\r\n    </div>\r\n  `,\r\n  animations: [\r\n    trigger(\"showHidePrivateRelationFields\", [\r\n      state(\"void\", style({height: 0})),\r\n      state(\"*\", style({height: \"*\"})),\r\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\r\n      transition(\"* => void\", animate(\"200ms ease-out\"))\r\n    ]),\r\n    trigger(\"showHideCompanyRelationFields\", [\r\n      state(\"void\", style({height: 0})),\r\n      state(\"*\", style({height: \"*\"})),\r\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\r\n      transition(\"* => void\", animate(\"200ms ease-out\"))\r\n    ]),\r\n    trigger(\"showHideSidebar\", [\r\n      state(\"void\", style({transform: \"translateX(100%)\"})),\r\n      state(\"*\", style({transform: \"translateX(0)\"})),\r\n      transition(\"void <=> *\", animate(\"200ms ease-in-out\"))\r\n    ])\r\n  ],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class RelationGeneralComponent extends RelationBaseComponent {\r\n  public readonly relType: typeof RelationNameKind = RelationNameKind;\r\n  public readonly genderType: typeof GenderType = GenderType;\r\n\r\n  @Input()\r\n  public readonly: boolean = false;\r\n\r\n  @Input()\r\n  public relationType: RelationNameKind = RelationNameKind.Private;\r\n\r\n  @HostBinding(\"class.co-relation-general\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public relationSuggestions: RelationListObject[] = [];\r\n  public showSuggestionsSidebar: boolean = false;\r\n  public dateOfBirth: Date; // todo: this needs to be on the relation object\r\n\r\n  constructor(\r\n    private _service: TransactionService,\r\n    private _dictionaryService: DictionaryService,\r\n    private _dialogService: DialogService,\r\n    private _relationService: RelationService\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  public firstNameChange(firstName: string): void {\r\n    if (this.relation) {\r\n      this.relation.firstName = firstName;\r\n      this.relationChange.emit(this.relation);\r\n    }\r\n    this._relationNameChangeHandler.call(this);\r\n  }\r\n\r\n  public familyNameChange(familyName: string): void {\r\n    if (this.relation) {\r\n      this.relation.familyName = familyName;\r\n      this.relationChange.emit(this.relation);\r\n    }\r\n    this._relationNameChangeHandler.call(this);\r\n  }\r\n\r\n  public changeGenderType(value: GenderType): void {\r\n    this.relation.gender = value;\r\n    this.relationChange.emit(this.relation);\r\n  }\r\n\r\n  public checkVisibilitySuggestions(): void {\r\n    if (this.relation.firstName && this.relation.familyName) {\r\n      this.hideSidebar();\r\n    }\r\n  }\r\n\r\n  public showSidebar(): void {\r\n    if (!this.readonly) {\r\n      this.showSuggestionsSidebar = true;\r\n    }\r\n  }\r\n\r\n  // Hide sidebar with a little timeout to prevent missing the click\r\n  public hideSidebar(): void {\r\n    setTimeout(() => {\r\n      this.showSuggestionsSidebar = false;\r\n    }, 200);\r\n  }\r\n\r\n  public async onRelationSuggestionClick(relationSuggested: RelationListObject): Promise<void> {\r\n    if (relationSuggested) {\r\n      const lockResult: ValidationResult = await this._relationService.lockRelation(relationSuggested.relationType, parseInt(relationSuggested.relationNr, 0));\r\n      if (!lockResult.success) {\r\n        this._dialogService.showError(this._dictionaryService.get(\"RELATION_ALREADY_LOCKED\"), lockResult.messages[0].message);\r\n      } else {\r\n        this.hideSidebar();\r\n        const suggestedRelation: RelationAnyType = await this._relationService.getRelation(relationSuggested.relationType, parseInt(relationSuggested.relationNr));\r\n        if (suggestedRelation && suggestedRelation.addresses && suggestedRelation.addresses.length > 0) {\r\n          suggestedRelation.addresses.sort((a, b) => a.sequence < b.sequence ? -1 : 1);\r\n        }\r\n        this.relation = suggestedRelation;\r\n        this.relationChange.next(this.relation);\r\n      }\r\n    }\r\n  }\r\n\r\n  protected relationSet(): void {\r\n    super.relationSet();\r\n    if (!this.relation.type) {\r\n      this.relation.type = RelationNameKind.Private;\r\n      this.relation.gender = GenderType.Unspecified;\r\n    }\r\n  }\r\n\r\n  // fetches relation suggestions\r\n  private _relationNameChangeHandler: Function = FunctionUtils.Throttle(() => {\r\n    return this._relationNameChangedHandlerFn();\r\n    // eslint-disable-next-line no-magic-numbers\r\n  }, 600);\r\n\r\n  // load suggestions\r\n  private async _relationNameChangedHandlerFn(): Promise<any> {\r\n    const firstName: string = ObjectUtils.ValueOrDefault(this.relation.firstName);\r\n    const secondName: string = ObjectUtils.ValueOrDefault(this.relation.familyName);\r\n\r\n    if (!firstName && !secondName) {\r\n      this.relationSuggestions = [];\r\n      this.hideSidebar();\r\n      return;\r\n    }\r\n\r\n    const relationRequest: RelationRequest = new RelationRequest();\r\n    relationRequest.relationType = this._service.getRelationKindFromTransactionKind();\r\n    if (firstName) {\r\n      relationRequest.firstName = firstName;\r\n    }\r\n\r\n    if (secondName) {\r\n      relationRequest.familyName = secondName;\r\n    }\r\n\r\n    this._relationService.getRelationListObjects(relationRequest).then((relations: RelationListObject[]) => {\r\n      this.relationSuggestions = relations;\r\n      if (relations && relations.length > 0) {\r\n        this.showSidebar();\r\n      } else {\r\n        this.hideSidebar();\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2015/lib/component/transaction-button-bar/transaction-button-bar-button/transaction-purchase-invoice-button-bar-button.component.js

@@ -0,0 +1,39 @@
+import { Component, HostBinding, ViewEncapsulation } from "@angular/core";
+import { IconCacheService } from "../../../service/icon-cache.service";
+import { TransactionButtonBarButtonBaseComponent } from "./transaction-button-bar-button-base.component";
+import { TransactionEventService } from "../../../service/transaction-event.service";
+export class TransactionPurchaseInvoiceButtonBarButtonComponent extends TransactionButtonBarButtonBaseComponent {
+    constructor(iconCacheService, _transactionEventService) {
+        super();
+        this.iconCacheService = iconCacheService;
+        this._transactionEventService = _transactionEventService;
+        this.showClass = true;
+        this._subs = [];
+        this._subs.push(this._transactionEventService.updatingInvoice.subscribe((generating) => {
+            this.showLoader = generating;
+        }), this._transactionEventService.invoiceCompletedChanged.subscribe((completed) => {
+            this.checked = completed;
+        }));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+}
+TransactionPurchaseInvoiceButtonBarButtonComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-transaction-purchase-invoice-button-bar-button",
+                template: `
+    <co-icon class="co-transaction-button-bar-icon" [iconData]="iconCacheService.getIcon(iconName)"></co-icon>
+    <span class="button-title" [textContent]="title | localize"></span>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+TransactionPurchaseInvoiceButtonBarButtonComponent.ctorParameters = () => [
+    { type: IconCacheService },
+    { type: TransactionEventService }
+];
+TransactionPurchaseInvoiceButtonBarButtonComponent.propDecorators = {
+    showClass: [{ type: HostBinding, args: ['class.co-transaction-purchase-invoice-button-bar-button',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/transaction-button-bar/transaction-button-bar-button/transaction-sales-invoice-button-bar-button.component.js

@@ -9,9 +9,9 @@ export class TransactionSalesInvoiceButtonBarButtonComponent extends Transaction
         this._transactionEventService = _transactionEventService;
         this.showClass = true;
         this._subs = [];
-        this._subs.push(this._transactionEventService.updatingSalesOrderInvoice.subscribe((generating) => {
+        this._subs.push(this._transactionEventService.updatingInvoice.subscribe((generating) => {
             this.showLoader = generating;
-        }), this._transactionEventService.salesOrderInvoiceCompletedChanged.subscribe((completed) => {
+        }), this._transactionEventService.invoiceCompletedChanged.subscribe((completed) => {
             this.checked = completed;
         }));
     }
@@ -36,4 +36,4 @@ TransactionSalesInvoiceButtonBarButtonComponent.ctorParameters = () => [
 TransactionSalesInvoiceButtonBarButtonComponent.propDecorators = {
     showClass: [{ type: HostBinding, args: ['class.co-transaction-sales-invoice-button-bar-button',] }]
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb24tc2FsZXMtaW52b2ljZS1idXR0b24tYmFyLWJ1dHRvbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90cmFuc2FjdGlvbi9zcmMvbGliL2NvbXBvbmVudC90cmFuc2FjdGlvbi1idXR0b24tYmFyL3RyYW5zYWN0aW9uLWJ1dHRvbi1iYXItYnV0dG9uL3RyYW5zYWN0aW9uLXNhbGVzLWludm9pY2UtYnV0dG9uLWJhci1idXR0b24uY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUUsV0FBVyxFQUFhLGlCQUFpQixFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ25GLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLHFDQUFxQyxDQUFDO0FBQ3JFLE9BQU8sRUFBQyx1Q0FBdUMsRUFBQyxNQUFNLGdEQUFnRCxDQUFDO0FBRXZHLE9BQU8sRUFBQyx1QkFBdUIsRUFBQyxNQUFNLDRDQUE0QyxDQUFDO0FBVW5GLE1BQU0sT0FBTywrQ0FBZ0QsU0FBUSx1Q0FBdUM7SUFPMUcsWUFDUyxnQkFBa0MsRUFDakMsd0JBQWlEO1FBRXpELEtBQUssRUFBRSxDQUFDO1FBSEQscUJBQWdCLEdBQWhCLGdCQUFnQixDQUFrQjtRQUNqQyw2QkFBd0IsR0FBeEIsd0JBQXdCLENBQXlCO1FBTnBELGNBQVMsR0FBWSxJQUFJLENBQUM7UUFFekIsVUFBSyxHQUFtQixFQUFFLENBQUM7UUFPakMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQ2IsSUFBSSxDQUFDLHdCQUF3QixDQUFDLHlCQUF5QixDQUFDLFNBQVMsQ0FBQyxDQUFDLFVBQW1CLEVBQUUsRUFBRTtZQUN4RixJQUFJLENBQUMsVUFBVSxHQUFHLFVBQVUsQ0FBQztRQUMvQixDQUFDLENBQUMsRUFDRixJQUFJLENBQUMsd0JBQXdCLENBQUMsaUNBQWlDLENBQUMsU0FBUyxDQUFDLENBQUMsU0FBa0IsRUFBRSxFQUFFO1lBQy9GLElBQUksQ0FBQyxPQUFPLEdBQUcsU0FBUyxDQUFDO1FBQzNCLENBQUMsQ0FBQyxDQUNILENBQUE7SUFDSCxDQUFDO0lBRUQsV0FBVztRQUNULElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUM7SUFDM0MsQ0FBQzs7O1lBaENGLFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsZ0RBQWdEO2dCQUMxRCxRQUFRLEVBQUU7OztHQUdUO2dCQUNELGFBQWEsRUFBRSxpQkFBaUIsQ0FBQyxJQUFJO2FBQ3RDOzs7WUFaTyxnQkFBZ0I7WUFHaEIsdUJBQXVCOzs7d0JBWTVCLFdBQVcsU0FBQyxzREFBc0QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NvbXBvbmVudCwgSG9zdEJpbmRpbmcsIE9uRGVzdHJveSwgVmlld0VuY2Fwc3VsYXRpb259IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7SWNvbkNhY2hlU2VydmljZX0gZnJvbSBcIi4uLy4uLy4uL3NlcnZpY2UvaWNvbi1jYWNoZS5zZXJ2aWNlXCI7XHJcbmltcG9ydCB7VHJhbnNhY3Rpb25CdXR0b25CYXJCdXR0b25CYXNlQ29tcG9uZW50fSBmcm9tIFwiLi90cmFuc2FjdGlvbi1idXR0b24tYmFyLWJ1dHRvbi1iYXNlLmNvbXBvbmVudFwiO1xyXG5pbXBvcnQge1N1YnNjcmlwdGlvbn0gZnJvbSBcInJ4anNcIjtcclxuaW1wb3J0IHtUcmFuc2FjdGlvbkV2ZW50U2VydmljZX0gZnJvbSBcIi4uLy4uLy4uL3NlcnZpY2UvdHJhbnNhY3Rpb24tZXZlbnQuc2VydmljZVwiO1xyXG5cclxuQENvbXBvbmVudCh7XHJcbiAgc2VsZWN0b3I6IFwiY28tdHJhbnNhY3Rpb24tc2FsZXMtaW52b2ljZS1idXR0b24tYmFyLWJ1dHRvblwiLFxyXG4gIHRlbXBsYXRlOiBgXHJcbiAgICA8Y28taWNvbiBjbGFzcz1cImNvLXRyYW5zYWN0aW9uLWJ1dHRvbi1iYXItaWNvblwiIFtpY29uRGF0YV09XCJpY29uQ2FjaGVTZXJ2aWNlLmdldEljb24oaWNvbk5hbWUpXCI+PC9jby1pY29uPlxyXG4gICAgPHNwYW4gY2xhc3M9XCJidXR0b24tdGl0bGVcIiBbdGV4dENvbnRlbnRdPVwidGl0bGUgfCBsb2NhbGl6ZVwiPjwvc3Bhbj5cclxuICBgLFxyXG4gIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmVcclxufSlcclxuZXhwb3J0IGNsYXNzIFRyYW5zYWN0aW9uU2FsZXNJbnZvaWNlQnV0dG9uQmFyQnV0dG9uQ29tcG9uZW50IGV4dGVuZHMgVHJhbnNhY3Rpb25CdXR0b25CYXJCdXR0b25CYXNlQ29tcG9uZW50IGltcGxlbWVudHMgT25EZXN0cm95IHtcclxuXHJcbiAgQEhvc3RCaW5kaW5nKCdjbGFzcy5jby10cmFuc2FjdGlvbi1zYWxlcy1pbnZvaWNlLWJ1dHRvbi1iYXItYnV0dG9uJylcclxuICBwdWJsaWMgc2hvd0NsYXNzOiBib29sZWFuID0gdHJ1ZTtcclxuXHJcbiAgcHJpdmF0ZSBfc3ViczogU3Vic2NyaXB0aW9uW10gPSBbXTtcclxuXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICBwdWJsaWMgaWNvbkNhY2hlU2VydmljZTogSWNvbkNhY2hlU2VydmljZSxcclxuICAgIHByaXZhdGUgX3RyYW5zYWN0aW9uRXZlbnRTZXJ2aWNlOiBUcmFuc2FjdGlvbkV2ZW50U2VydmljZVxyXG4gICkge1xyXG4gICAgc3VwZXIoKTtcclxuICAgIHRoaXMuX3N1YnMucHVzaChcclxuICAgICAgdGhpcy5fdHJhbnNhY3Rpb25FdmVudFNlcnZpY2UudXBkYXRpbmdTYWxlc09yZGVySW52b2ljZS5zdWJzY3JpYmUoKGdlbmVyYXRpbmc6IGJvb2xlYW4pID0+IHtcclxuICAgICAgICB0aGlzLnNob3dMb2FkZXIgPSBnZW5lcmF0aW5nO1xyXG4gICAgICB9KSxcclxuICAgICAgdGhpcy5fdHJhbnNhY3Rpb25FdmVudFNlcnZpY2Uuc2FsZXNPcmRlckludm9pY2VDb21wbGV0ZWRDaGFuZ2VkLnN1YnNjcmliZSgoY29tcGxldGVkOiBib29sZWFuKSA9PiB7XHJcbiAgICAgICAgdGhpcy5jaGVja2VkID0gY29tcGxldGVkO1xyXG4gICAgICB9KVxyXG4gICAgKVxyXG4gIH1cclxuXHJcbiAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XHJcbiAgICB0aGlzLl9zdWJzLmZvckVhY2gocyA9PiBzLnVuc3Vic2NyaWJlKCkpO1xyXG4gIH1cclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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