@colijnit/sharedcomponents 1.0.6 → 1.0.9

package/esm2015/lib/components/stock/stock-location/stock-location.component.js

@@ -0,0 +1,62 @@
+import { Component, EventEmitter, Output, ViewEncapsulation } from "@angular/core";
+export class StockLocationComponent {
+    constructor() {
+        this.backToStockLines = new EventEmitter();
+        this.MAX_GRID_ROWS = 10;
+        this.stockLocationColumns = [];
+        this.stockLocation = [
+            { location: "title 1", batch: "1", serieNo: "1", amountInStock: "1", allocated: "1", amountAvailable: "1" },
+            { location: "title 2", amountInStock: "2" },
+            { location: "title 3", amountInStock: "3" },
+            { location: "title 4", amountInStock: "4" },
+            { location: "title 5", amountInStock: "5" },
+        ];
+        this.stockLocationColumns.push({ field: "location", headerText: "WAREHOUSE", editType: "none" }, { field: "batch", headerText: "BATCH" }, { field: "serieNo", headerText: "SERIAL_NO" }, { field: "amountInStock", headerText: "STOCK", textAlign: "Right", editType: "numericEdit" }, { field: "allocated", headerText: "ALLOCATED", textAlign: "Right" }, { field: "amountAvailable", headerText: "AVAILABLE_STOCK", textAlign: "Right" }, { field: "PhysicalStock", headerText: "PHYSICAL_STOCK", textAlign: "Right" }, { field: "Valuta", headerText: "VALUTA", textAlign: "Right" }, { field: "PurchasePrice", headerText: "PURSCHASE_PRICE", textAlign: "Right" }, { field: "SupplierNo", headerText: "SUPPLIER_NO", textAlign: "Right" }, { field: "Transfer", headerText: "TRANSFER" }, { field: "sticker", headerText: "STICKER" });
+    }
+    backToStockInformation() {
+        this.backToStockLines.emit();
+    }
+    onStickerClick(event) {
+        console.log('test');
+    }
+    onOkClick() {
+    }
+    onCancelClick() {
+    }
+}
+StockLocationComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-stock-location",
+                template: `
+    <div class="stock-location-wrapper">
+      <div class="buttons-wrapper">
+        <div class="stock-button-left-group">
+          <span class="stock-button-back" [textContent]="'BACK_TO_STOCK_LINES'" (click)="backToStockInformation()"></span>
+        </div>
+        <div class="dropdown-wrapper">
+          <co-drop-down-list></co-drop-down-list>
+        </div>
+      </div>
+
+      <div class="stock-grid">
+
+      </div>
+      <div class="button-wrapper">
+        <div class="button-left">
+          <co-button (click)="onOkClick()"></co-button>
+        </div>
+        <div class="button-right">
+          <co-button (click)="onCancelClick()"></co-button>
+        </div>
+      </div>
+    </div>
+
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+StockLocationComponent.ctorParameters = () => [];
+StockLocationComponent.propDecorators = {
+    backToStockLines: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/stock/stock-transfer/co-drop-down-list-fields.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY28tZHJvcC1kb3duLWxpc3QtZmllbGRzLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NoYXJlZGNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL3N0b2NrL3N0b2NrLXRyYW5zZmVyL2NvLWRyb3AtZG93bi1saXN0LWZpZWxkcy5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQ29Ecm9wRG93bkxpc3RGaWVsZHMge1xyXG4gIHRleHQ6IHN0cmluZztcclxuICB2YWx1ZTogc3RyaW5nO1xyXG59XHJcbiJdfQ==

package/esm2015/lib/components/stock/stock-transfer/stock-transfer.component.js

@@ -0,0 +1,98 @@
+import { __awaiter } from "tslib";
+import { Component, EventEmitter, Input, Output, ViewEncapsulation } from "@angular/core";
+import { StockService } from "../../../service/stock.service";
+export class StockTransferComponent {
+    constructor(_stockService) {
+        this._stockService = _stockService;
+        this.handleCancelClicked = new EventEmitter();
+        this.handleStickerClicked = new EventEmitter();
+        this.allWarehousesDropdownFields = { value: "warehouseNo", text: "description" };
+        this.showSendMethodDialog = false;
+    }
+    handleOkClick() {
+    }
+    handleCancelClick() {
+        this.handleCancelClicked.emit();
+    }
+    handleSelectedWarehouse(event) {
+        console.log(event);
+    }
+    handleStickerClick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.handleStickerClicked.emit();
+            this.showSendMethodDialog = true;
+        });
+    }
+}
+StockTransferComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-stock-transfer",
+                template: `
+      <div class="stock-transfer">
+        <div class="stock-transfer-columns">
+          <div *ngIf="article" class="stock-transfer-left-column">
+            <co-input-text disabled
+                           [(model)]="article.standardWareHouse.description"
+                           [textContent]="article.standardWareHouse.description"
+                           [placeholder]="'Standaard magazijn'">
+            </co-input-text>
+            <co-input-text disabled
+                           [(model)]="article.standardLocation"
+                           [textContent]="article.standardLocation"
+                           [placeholder]="'Standaard locatie'">
+            </co-input-text>
+            <co-input-text disabled
+                           [(model)]="stockSticker.batch"
+                           [placeholder]="'Batch'">
+            </co-input-text>
+            <co-input-text disabled
+                           [(model)]="stockSticker.serial"
+                           [placeholder]="'Serie'">
+            </co-input-text>
+            <co-input-text
+              [(model)]="article.amount"
+              [placeholder]="'Aantal'">
+
+            </co-input-text>
+          </div>
+
+          <div class="stock-transfer-right-column">
+            <co-drop-down-list [collection]="allWarehouses"
+                               [fields]="allWarehousesDropdownFields"
+                               (modelChange)="handleSelectedWarehouse($event)"
+            >
+            </co-drop-down-list>
+            <co-drop-down-list>
+
+            </co-drop-down-list>
+            <co-input-text [placeholder]="'Voorraadstatus'">
+
+            </co-input-text>
+            <co-input-text [placeholder]="'Omschrijving'">
+
+            </co-input-text>
+          </div>
+        </div>
+
+        <div class="ok-cancel-buttons">
+          <co-button [textContent]="'Ok'" (click)="handleOkClick()"></co-button>
+          <co-button [textContent]="'Annuleren'" (click)="handleCancelClick()"></co-button>
+          <co-button [textContent]="'Sticker'" (click)="handleStickerClick()"></co-button>
+        </div>
+      </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+StockTransferComponent.ctorParameters = () => [
+    { type: StockService }
+];
+StockTransferComponent.propDecorators = {
+    stockSticker: [{ type: Input }],
+    article: [{ type: Input }],
+    articleWarehouse: [{ type: Input }],
+    allWarehouses: [{ type: Input }],
+    handleCancelClicked: [{ type: Output }],
+    handleStickerClicked: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/stock/stock.component.js

@@ -0,0 +1,67 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewChild, ViewEncapsulation } from "@angular/core";
+import { StockService } from "../../service/stock.service";
+import { PrintStockStickers } from "@colijnit/articleapi/build/model/print-stock-stickers";
+export class StockComponent {
+    constructor(stockService) {
+        this.stockService = stockService;
+        this.handleStickerClicked = new EventEmitter();
+        this.showStockInformationGrid = true;
+        this.showStockLocation = false;
+        this.showStockTransfer = false;
+    }
+    set options(value) {
+        this.stockService.connectConnector(value);
+    }
+    showClass() {
+        return true;
+    }
+    backToStockLinesClicked() {
+        this.showStockLocation = false;
+        this.showStockInformationGrid = true;
+    }
+    handleStockTransferClick(event) {
+        this.showStockTransfer = !this.showStockTransfer;
+        this.showStockInformationGrid = !this.showStockInformationGrid;
+        this.stockService.stockStickers = new PrintStockStickers();
+    }
+    backToStock() {
+        this.showStockTransfer = !this.showStockTransfer;
+        this.showStockInformationGrid = !this.showStockInformationGrid;
+    }
+}
+StockComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-stock",
+                template: `
+      <div class="stock-info-container">
+        <co-stock-information [article]="articleExtended"></co-stock-information>
+        <hr>
+        <co-stock-information-grid *ngIf="showStockInformationGrid" (transferIconClicked)="handleStockTransferClick($event)"></co-stock-information-grid>
+        <co-stock-location *ngIf="showStockLocation" (backToStockLines)="backToStockLinesClicked()"></co-stock-location>
+        <co-stock-transfer *ngIf="showStockTransfer"
+                           (handleCancelClicked)="backToStock()"
+                           [article]="articleExtended"
+                           [stockSticker]="stockService.stockStickers"
+                           (handleStickerClicked)="handleStickerClicked.emit($event)"
+                           [articleWarehouse]="articleWarehouse"
+                           [allWarehouses]="allWarehouses"
+        >
+        </co-stock-transfer>
+      </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+StockComponent.ctorParameters = () => [
+    { type: StockService }
+];
+StockComponent.propDecorators = {
+    stock: [{ type: ViewChild, args: [StockComponent,] }],
+    handleStickerClicked: [{ type: Output }],
+    options: [{ type: Input }],
+    articleExtended: [{ type: Input }],
+    articleWarehouse: [{ type: Input }],
+    allWarehouses: [{ type: Input }],
+    showClass: [{ type: HostBinding, args: ["class.co-stock",] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/stock/stock.module.js

@@ -0,0 +1,44 @@
+import { NgModule } from "@angular/core";
+import { StockComponent } from "./stock.component";
+import { ButtonModule, CoGridModule, DropDownModule, ImageModule, InputComboBoxModule, InputRadioButtonModule, InputTextModule, SimpleGridModule } from "@colijnit/corecomponents_v12";
+import { CommonModule } from "@angular/common";
+import { StockInformationComponent } from "./stock-information/stock-information.component";
+import { StockInformationGridComponent } from "./stock-information-grid/stock-information-grid.component";
+import { StockLocationComponent } from "./stock-location/stock-location.component";
+import { StockService } from "../../service/stock.service";
+import { IoneConnectorAdapterService } from "../../service/ione-connector-adapter.service";
+import { StockTransferComponent } from "./stock-transfer/stock-transfer.component";
+import { SendMethodDialogModule } from "../send-method-dialog/send-method-dialog.module";
+export class StockModule {
+}
+StockModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    InputComboBoxModule,
+                    CoGridModule,
+                    ButtonModule,
+                    CommonModule,
+                    InputRadioButtonModule,
+                    DropDownModule,
+                    SimpleGridModule,
+                    ImageModule,
+                    InputTextModule,
+                    SendMethodDialogModule
+                ],
+                declarations: [
+                    StockComponent,
+                    StockInformationComponent,
+                    StockInformationGridComponent,
+                    StockLocationComponent,
+                    StockTransferComponent
+                ],
+                exports: [
+                    StockComponent
+                ],
+                providers: [
+                    StockService,
+                    IoneConnectorAdapterService
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/enum/icon.enum.js

@@ -0,0 +1,23 @@
+/** AUTO GENERATED FILE. DO NOT CHANGE.. OR YOU WILL SUFFER THE CONSEQUENCES OF YOUR ACTIONS **/
+export var Icon;
+(function (Icon) {
+    Icon["ArrowFatRight"] = "arrow_fat_right";
+    Icon["ArrowPointDown"] = "arrow_point_down";
+    Icon["ArrowPointLeft"] = "arrow_point_left";
+    Icon["ArrowPointRight"] = "arrow_point_right";
+    Icon["CalendarDay"] = "calendar_day";
+    Icon["Cancel"] = "cancel";
+    Icon["DeliveryTruck"] = "delivery_truck";
+    Icon["EditPencil"] = "edit_pencil";
+    Icon["Email"] = "email";
+    Icon["Pdf"] = "pdf";
+    Icon["PlusRound"] = "plus_round";
+    Icon["Print"] = "print";
+    Icon["SignatureField"] = "signature_field";
+    Icon["Tag"] = "tag";
+    Icon["ThickLines"] = "thick_lines";
+    Icon["ThinLines"] = "thin_lines";
+    Icon["Txt"] = "txt";
+    Icon["Xml"] = "xml";
+})(Icon || (Icon = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWNvbi5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2hhcmVkY29tcG9uZW50cy9zcmMvbGliL2VudW0vaWNvbi5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGdHQUFnRztBQUVoRyxNQUFNLENBQU4sSUFBWSxJQW1CWDtBQW5CRCxXQUFZLElBQUk7SUFDWix5Q0FBaUMsQ0FBQTtJQUNqQywyQ0FBbUMsQ0FBQTtJQUNuQywyQ0FBbUMsQ0FBQTtJQUNuQyw2Q0FBcUMsQ0FBQTtJQUNyQyxvQ0FBNEIsQ0FBQTtJQUM1Qix5QkFBaUIsQ0FBQTtJQUNqQix3Q0FBZ0MsQ0FBQTtJQUNoQyxrQ0FBMEIsQ0FBQTtJQUMxQix1QkFBZSxDQUFBO0lBQ2YsbUJBQVcsQ0FBQTtJQUNYLGdDQUF3QixDQUFBO0lBQ3hCLHVCQUFlLENBQUE7SUFDZiwwQ0FBa0MsQ0FBQTtJQUNsQyxtQkFBVyxDQUFBO0lBQ1gsa0NBQTBCLENBQUE7SUFDMUIsZ0NBQXdCLENBQUE7SUFDeEIsbUJBQVcsQ0FBQTtJQUNYLG1CQUFXLENBQUE7QUFDZixDQUFDLEVBbkJXLElBQUksS0FBSixJQUFJLFFBbUJmIiwic291cmNlc0NvbnRlbnQiOlsiLyoqIEFVVE8gR0VORVJBVEVEIEZJTEUuIERPIE5PVCBDSEFOR0UuLiBPUiBZT1UgV0lMTCBTVUZGRVIgVEhFIENPTlNFUVVFTkNFUyBPRiBZT1VSIEFDVElPTlMgKiovXHJcblxyXG5leHBvcnQgZW51bSBJY29uIHtcclxuICAgIEFycm93RmF0UmlnaHQgPSBcImFycm93X2ZhdF9yaWdodFwiLFxyXG4gICAgQXJyb3dQb2ludERvd24gPSBcImFycm93X3BvaW50X2Rvd25cIixcclxuICAgIEFycm93UG9pbnRMZWZ0ID0gXCJhcnJvd19wb2ludF9sZWZ0XCIsXHJcbiAgICBBcnJvd1BvaW50UmlnaHQgPSBcImFycm93X3BvaW50X3JpZ2h0XCIsXHJcbiAgICBDYWxlbmRhckRheSA9IFwiY2FsZW5kYXJfZGF5XCIsXHJcbiAgICBDYW5jZWwgPSBcImNhbmNlbFwiLFxyXG4gICAgRGVsaXZlcnlUcnVjayA9IFwiZGVsaXZlcnlfdHJ1Y2tcIixcclxuICAgIEVkaXRQZW5jaWwgPSBcImVkaXRfcGVuY2lsXCIsXHJcbiAgICBFbWFpbCA9IFwiZW1haWxcIixcclxuICAgIFBkZiA9IFwicGRmXCIsXHJcbiAgICBQbHVzUm91bmQgPSBcInBsdXNfcm91bmRcIixcclxuICAgIFByaW50ID0gXCJwcmludFwiLFxyXG4gICAgU2lnbmF0dXJlRmllbGQgPSBcInNpZ25hdHVyZV9maWVsZFwiLFxyXG4gICAgVGFnID0gXCJ0YWdcIixcclxuICAgIFRoaWNrTGluZXMgPSBcInRoaWNrX2xpbmVzXCIsXHJcbiAgICBUaGluTGluZXMgPSBcInRoaW5fbGluZXNcIixcclxuICAgIFR4dCA9IFwidHh0XCIsXHJcbiAgICBYbWwgPSBcInhtbFwiXHJcbn1cclxuIl19

package/esm2015/lib/factory/business-object-factory.js

@@ -0,0 +1,120 @@
+import { ComplexFieldDecorator } from "./decorators/complex-field.decorator";
+import { ComplexArrayDecorator } from "./decorators/complex-array.decorator";
+import { BooleanTextDecorator } from "./decorators/boolean.decorator";
+import { DateFieldFieldDecorator } from "./decorators/date-field.decorator";
+import { StringNumberDecorator } from "./decorators/string-number.decorator";
+import { isNill } from "../utils/is-nill.function";
+import { ArrayUtils } from "../utils/array-utils";
+import { BusinessObject } from "../model/business-object";
+// Factory service creates businessobjects, using their decorators in the process.
+export class BusinessObjectFactory {
+    constructor() {
+    }
+    /**
+     * Creates and returns a new business data object instance of given class, with all given data properties applied to it in a
+     * complex-aware style. That is, all properties on given class that are decorated with @ComplexField(..) or @ComplexArray(..) decorators
+     * become strongly typed business objects, with methods that are usable and such.
+     *
+     * @param modelClass
+     * @param {Object} rawData The object with all (possibly raw/flat/not alive) data to be applied to the created model object
+     */
+    makeWithRawBackendData(modelClass, rawData) {
+        if (!modelClass) {
+            return undefined;
+        }
+        if (typeof modelClass !== typeof BusinessObject) {
+            return undefined;
+        }
+        const model = new modelClass();
+        this._copyAllPropertiesDecoratorProcessedFrom(rawData, model);
+        return model;
+    }
+    // see makeWithRawBackendData, this is a loop-wrapper around that method
+    makeBOArrayFromRawBackendDataArray(modelClass, arrayOfRawDatas) {
+        if (!modelClass) {
+            return undefined;
+        }
+        const trueClientBos = [];
+        if (arrayOfRawDatas) {
+            for (let i = 0, len = arrayOfRawDatas.length; i < len; i++) {
+                trueClientBos.push(this.makeWithRawBackendData(modelClass, arrayOfRawDatas[i]));
+            }
+        }
+        return trueClientBos;
+    }
+    instantiateNewBo(modelClass) {
+        return this.makeWithRawBackendData(modelClass, {});
+    }
+    /**
+     * Applies all properties of given 'source' object to the given 'destination' businessobject, if destination has that property.
+     * Works with the @ComplexField(), @ComplexArray, @BooleanText, @CoInject and @DateField annotations of given destination model.
+     *
+     * @param sourceData Raw data to copy to destination model
+     * @param {BusinessObject} destinationModel InOut: The annotated businessobject to apply source properties to
+     */
+    _copyAllPropertiesDecoratorProcessedFrom(sourceData, destinationModel) {
+        if (!sourceData || !destinationModel) {
+            return;
+        }
+        // process all source data into destinationModel
+        for (const srcPropKey in sourceData) {
+            if (!sourceData.hasOwnProperty(srcPropKey)) {
+                continue;
+            }
+            const srcPropVal = sourceData[srcPropKey];
+            if (ComplexFieldDecorator.IsComplexField(destinationModel, srcPropKey)) {
+                const classOfField = ComplexFieldDecorator.GetComplexFieldType(destinationModel, srcPropKey);
+                destinationModel[srcPropKey] = this.makeWithRawBackendData(classOfField, srcPropVal);
+            }
+            else if (ComplexArrayDecorator.IsComplexArray(destinationModel, srcPropKey)) {
+                const sourceArray = srcPropVal;
+                if (!sourceArray) {
+                    continue;
+                }
+                const classOfArrayItems = ComplexArrayDecorator.GetComplexArrayType(destinationModel, srcPropKey);
+                const tempArray = [];
+                for (let i = 0, len = sourceArray.length; i < len; i++) {
+                    tempArray.push(this.makeWithRawBackendData(classOfArrayItems, sourceArray[i]));
+                }
+                destinationModel[srcPropKey] = tempArray;
+            }
+            else if (BooleanTextDecorator.IsBooleanTextField(destinationModel, srcPropKey)) {
+                // logical 'true' and 'false' also allowed as incoming values for @BooleanText() properties: then just copy their value
+                if (typeof srcPropVal === "boolean") {
+                    destinationModel[srcPropKey] = srcPropVal;
+                    // here, it should be a 'J' or 'N' (or 'T' or 'F'): assign the associated boolean value
+                }
+                else {
+                    destinationModel[srcPropKey] = BooleanTextDecorator.GetLogicalBooleanValue(srcPropVal);
+                }
+            }
+            else if (DateFieldFieldDecorator.IsDateField(destinationModel, srcPropKey)) {
+                destinationModel[srcPropKey] = DateFieldFieldDecorator.StringAsDate(srcPropVal);
+            }
+            else if (StringNumberDecorator.IsStringNumber(destinationModel, srcPropKey)) {
+                destinationModel[srcPropKey] = StringNumberDecorator.StringAsNumber(srcPropVal);
+            }
+            // non-decorated prop
+            else {
+                if (isNill(srcPropVal)) {
+                    destinationModel[srcPropKey] = undefined;
+                }
+                else if (Array.isArray(srcPropVal)) {
+                    destinationModel[srcPropKey] = ArrayUtils.CloneArray(srcPropVal);
+                }
+                else if (typeof srcPropVal === "object") {
+                    if (srcPropVal instanceof Map) { //just copy the value in case of maps
+                        destinationModel[srcPropKey] = srcPropVal;
+                    }
+                    else {
+                        destinationModel[srcPropKey] = Object.assign({}, srcPropVal);
+                    }
+                }
+                else {
+                    destinationModel[srcPropKey] = srcPropVal;
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"business-object-factory.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/factory/business-object-factory.ts"],"names":[],"mappings":"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","sourcesContent":["import {ComplexFieldDecorator} from \"./decorators/complex-field.decorator\";\r\nimport {ComplexArrayDecorator} from \"./decorators/complex-array.decorator\";\r\nimport {BooleanTextDecorator} from \"./decorators/boolean.decorator\";\r\nimport {DateFieldFieldDecorator} from \"./decorators/date-field.decorator\";\r\nimport {StringNumberDecorator} from \"./decorators/string-number.decorator\";\r\nimport {isNill} from \"../utils/is-nill.function\";\r\nimport {ArrayUtils} from \"../utils/array-utils\";\r\nimport {BusinessObject} from \"../model/business-object\";\r\n\r\n// Factory service creates businessobjects, using their decorators in the process.\r\nexport class BusinessObjectFactory {\r\n    constructor() {\r\n    }\r\n\r\n    /**\r\n     * Creates and returns a new business data object instance of given class, with all given data properties applied to it in a\r\n     * complex-aware style. That is, all properties on given class that are decorated with @ComplexField(..) or @ComplexArray(..) decorators\r\n     * become strongly typed business objects, with methods that are usable and such.\r\n     *\r\n     * @param modelClass\r\n     * @param {Object} rawData The object with all (possibly raw/flat/not alive) data to be applied to the created model object\r\n     */\r\n    public makeWithRawBackendData(modelClass: any, rawData: Object): BusinessObject {\r\n        if (!modelClass) {\r\n            return undefined;\r\n        }\r\n        if (typeof modelClass !== typeof BusinessObject) {\r\n            return undefined;\r\n        }\r\n\r\n        const model: BusinessObject = new modelClass();\r\n        this._copyAllPropertiesDecoratorProcessedFrom(rawData, model);\r\n        return model;\r\n    }\r\n\r\n    // see makeWithRawBackendData, this is a loop-wrapper around that method\r\n    public makeBOArrayFromRawBackendDataArray(modelClass: any, arrayOfRawDatas: Object[]): BusinessObject[] {\r\n        if (!modelClass) {\r\n            return undefined;\r\n        }\r\n\r\n        const trueClientBos: BusinessObject[] = [];\r\n        if (arrayOfRawDatas) {\r\n            for (let i: number = 0, len: number = arrayOfRawDatas.length; i < len; i++) {\r\n                trueClientBos.push(this.makeWithRawBackendData(modelClass, arrayOfRawDatas[i]));\r\n            }\r\n        }\r\n        return trueClientBos;\r\n    }\r\n\r\n    public instantiateNewBo(modelClass: any): BusinessObject {\r\n        return this.makeWithRawBackendData(modelClass, {});\r\n    }\r\n\r\n    /**\r\n     * Applies all properties of given 'source' object to the given 'destination' businessobject, if destination has that property.\r\n     * Works with the @ComplexField(), @ComplexArray, @BooleanText, @CoInject and @DateField annotations of given destination model.\r\n     *\r\n     * @param sourceData Raw data to copy to destination model\r\n     * @param {BusinessObject} destinationModel InOut: The annotated businessobject to apply source properties to\r\n     */\r\n    private _copyAllPropertiesDecoratorProcessedFrom(sourceData: any, destinationModel: BusinessObject): void {\r\n        if (!sourceData || !destinationModel) {\r\n            return;\r\n        }\r\n\r\n        // process all source data into destinationModel\r\n        for (const srcPropKey in sourceData) {\r\n            if (!sourceData.hasOwnProperty(srcPropKey)) {\r\n                continue;\r\n            }\r\n\r\n            const srcPropVal: any = sourceData[srcPropKey];\r\n\r\n            if (ComplexFieldDecorator.IsComplexField(destinationModel, srcPropKey)) {\r\n                const classOfField: any = ComplexFieldDecorator.GetComplexFieldType(destinationModel, srcPropKey);\r\n                destinationModel[srcPropKey] = this.makeWithRawBackendData(classOfField, srcPropVal);\r\n            } else if (ComplexArrayDecorator.IsComplexArray(destinationModel, srcPropKey)) {\r\n                const sourceArray: any[] = srcPropVal;\r\n                if (!sourceArray) {\r\n                    continue;\r\n                }\r\n                const classOfArrayItems: any = ComplexArrayDecorator.GetComplexArrayType(destinationModel, srcPropKey);\r\n                const tempArray: any[] = [];\r\n                for (let i: number = 0, len: number = sourceArray.length; i < len; i++) {\r\n                    tempArray.push(this.makeWithRawBackendData(classOfArrayItems, sourceArray[i]));\r\n                }\r\n                destinationModel[srcPropKey] = tempArray;\r\n            } else if (BooleanTextDecorator.IsBooleanTextField(destinationModel, srcPropKey)) {\r\n                // logical 'true' and 'false' also allowed as incoming values for @BooleanText() properties: then just copy their value\r\n                if (typeof srcPropVal === \"boolean\") {\r\n                    destinationModel[srcPropKey] = srcPropVal;\r\n                    // here, it should be a 'J' or 'N' (or 'T' or 'F'): assign the associated boolean value\r\n                } else {\r\n                    destinationModel[srcPropKey] = BooleanTextDecorator.GetLogicalBooleanValue(srcPropVal);\r\n                }\r\n            } else if (DateFieldFieldDecorator.IsDateField(destinationModel, srcPropKey)) {\r\n                destinationModel[srcPropKey] = DateFieldFieldDecorator.StringAsDate(srcPropVal);\r\n            } else if (StringNumberDecorator.IsStringNumber(destinationModel, srcPropKey)) {\r\n                destinationModel[srcPropKey] = StringNumberDecorator.StringAsNumber(srcPropVal);\r\n            }\r\n            // non-decorated prop\r\n            else {\r\n                if (isNill(srcPropVal)) {\r\n                    destinationModel[srcPropKey] = undefined;\r\n                } else if (Array.isArray(srcPropVal)) {\r\n                    destinationModel[srcPropKey] = ArrayUtils.CloneArray(srcPropVal);\r\n                } else if (typeof srcPropVal === \"object\") {\r\n                    if (srcPropVal instanceof Map) { //just copy the value in case of maps\r\n                        destinationModel[srcPropKey] = srcPropVal;\r\n                    } else {\r\n                        destinationModel[srcPropKey] = Object.assign({}, srcPropVal);\r\n                    }\r\n                } else {\r\n                    destinationModel[srcPropKey] = srcPropVal;\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2015/lib/factory/decorators/boolean.decorator.js

@@ -0,0 +1,102 @@
+import { GetYesNoDbBooleanValue } from "@colijnit/articleapi/build/enum/yes-no-db-type.enum";
+import { GetTrueFalseDbBooleanValue } from "@colijnit/articleapi/build/enum/true-false-db-type.enum";
+import { GetOneZeroDbBooleanValue } from "@colijnit/articleapi/build/enum/one-zero-bool-db-type.enum";
+import { GetLogicalBooleanValue } from "@colijnit/articleapi/build/enum/db-boolean-value-type.enum";
+const PROP_META_KEY_JN = "booleanTextJN";
+const PROP_META_KEY_TF = "booleanTextTF";
+const PROP_META_KEY_10 = "booleanText10";
+/**
+ * There are 'J', 'T', 'N', 'F', 0 and 1 'boolean values' in the database. These should be translated to true and false boolean values in
+ * our client application.
+ *
+ * The values 'J' and 'N' seem to be most commonly used. This is the default setting when using this decorator.
+ * You can pass 'T' or 1 for the other variants as follows:
+ *
+ * Usage:
+ *
+ * @BooleanText() or @BooleanText("J") (the default, uses YesNoDbType char values)
+ * public foo: boolean // 'J' and 'N' become true and false after BusinessObjectFactoryService and -SerializerService processing
+ *
+ * @BooleanText('T') (uses TrueFalseDbType char values)
+ * public bar: boolean // 'T' and 'F' become true and false after BusinessObjectFactoryService and -SerializerService processing
+ *
+ * @BooleanText(1)
+ * public baz: boolean // 1 and 0 become true and false after BusinessObjectFactoryService and -SerializerService processing
+ */
+export function BooleanText(type) {
+    return function (target, propertyKey) {
+        if (!target || !propertyKey) {
+            return;
+        }
+        // by default, it's a J N boolean text
+        if (!type || type === "J") {
+            Reflect.defineMetadata(PROP_META_KEY_JN, true, target, propertyKey);
+        }
+        else if (type === "T") {
+            Reflect.defineMetadata(PROP_META_KEY_TF, true, target, propertyKey);
+        }
+        else if (type === 1) {
+            Reflect.defineMetadata(PROP_META_KEY_10, true, target, propertyKey);
+        }
+    };
+}
+// Utility function holder of the BooleanTextDecorator decorator.
+export class BooleanTextDecorator {
+    /**
+     * Returns whether given property (as a string) on given object is a boolean text field. That is, it's a field that is decorated
+     * with the @BooleanText decorator.
+     */
+    static IsBooleanTextField(target, propertyKey) {
+        if (!target || !propertyKey || typeof target !== "object") {
+            return false;
+        }
+        return (Reflect.getMetadata(PROP_META_KEY_JN, target, propertyKey) === true
+            ||
+                Reflect.getMetadata(PROP_META_KEY_TF, target, propertyKey) === true
+            ||
+                Reflect.getMetadata(PROP_META_KEY_10, target, propertyKey) === true);
+    }
+    /**
+     * Returns the logical true or false value of given character ('J', 'N', 'T' or 'F') or number (0 or 1).
+     * Returns UNDEFINED if given boolChar was not recognised as a boolean text.
+     */
+    static GetLogicalBooleanValue(dbBoolChar) {
+        return GetLogicalBooleanValue(dbBoolChar);
+    }
+    /**
+     * Returns the boolean character / number of given logical bool property on target object. Uses its @BooleanText() annotation to decide
+     * what character / number to return.
+     * Used in BusinessObjectSerializerServiceService to convert logical bools to their original boolean character.
+     * @returns {string|number} The original, reverse-engineered boolean character (or number) of given object property, or undefined.
+     */
+    static GetDbBooleanValue(target, propertyKey) {
+        if (!target || !propertyKey || typeof target !== "object") {
+            return undefined;
+        }
+        let dbBoolVal = undefined;
+        const curBoolVal = target[propertyKey];
+        if (BooleanTextDecorator._IsJaNeeProp(target, propertyKey)) {
+            dbBoolVal = GetYesNoDbBooleanValue(curBoolVal);
+        }
+        else if (BooleanTextDecorator._IsTrueFalseProp(target, propertyKey)) {
+            dbBoolVal = GetTrueFalseDbBooleanValue(curBoolVal);
+        }
+        else if (BooleanTextDecorator._IsZeroOneProp(target, propertyKey)) {
+            dbBoolVal = GetOneZeroDbBooleanValue(curBoolVal);
+        }
+        return dbBoolVal;
+    }
+    static _IsJaNeeProp(target, propertyKey) {
+        return BooleanTextDecorator._IsProp(PROP_META_KEY_JN, target, propertyKey);
+    }
+    static _IsTrueFalseProp(target, propertyKey) {
+        return BooleanTextDecorator._IsProp(PROP_META_KEY_TF, target, propertyKey);
+    }
+    static _IsZeroOneProp(target, propertyKey) {
+        return BooleanTextDecorator._IsProp(PROP_META_KEY_10, target, propertyKey);
+    }
+    static _IsProp(prop, target, propertyKey) {
+        return !!target && !!propertyKey && typeof target === "object" && Reflect.hasMetadata(prop, target, propertyKey);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"boolean.decorator.js","sourceRoot":"","sources":["../../../../../../projects/sharedcomponents/src/lib/factory/decorators/boolean.decorator.ts"],"names":[],"mappings":"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","sourcesContent":["import {GetYesNoDbBooleanValue} from \"@colijnit/articleapi/build/enum/yes-no-db-type.enum\";\r\nimport {GetTrueFalseDbBooleanValue} from \"@colijnit/articleapi/build/enum/true-false-db-type.enum\";\r\nimport {GetOneZeroDbBooleanValue} from \"@colijnit/articleapi/build/enum/one-zero-bool-db-type.enum\";\r\nimport {DbBooleanValueType, GetLogicalBooleanValue} from \"@colijnit/articleapi/build/enum/db-boolean-value-type.enum\";\r\n\r\nconst PROP_META_KEY_JN: string = \"booleanTextJN\";\r\nconst PROP_META_KEY_TF: string = \"booleanTextTF\";\r\nconst PROP_META_KEY_10: string = \"booleanText10\";\r\n\r\n/**\r\n * There are 'J', 'T', 'N', 'F', 0 and 1 'boolean values' in the database. These should be translated to true and false boolean values in\r\n * our client application.\r\n *\r\n * The values 'J' and 'N' seem to be most commonly used. This is the default setting when using this decorator.\r\n * You can pass 'T' or 1 for the other variants as follows:\r\n *\r\n * Usage:\r\n *\r\n * @BooleanText() or @BooleanText(\"J\") (the default, uses YesNoDbType char values)\r\n * public foo: boolean // 'J' and 'N' become true and false after BusinessObjectFactoryService and -SerializerService processing\r\n *\r\n * @BooleanText('T') (uses TrueFalseDbType char values)\r\n * public bar: boolean // 'T' and 'F' become true and false after BusinessObjectFactoryService and -SerializerService processing\r\n *\r\n * @BooleanText(1)\r\n * public baz: boolean // 1 and 0 become true and false after BusinessObjectFactoryService and -SerializerService processing\r\n */\r\nexport function BooleanText(type?: \"J\" | \"T\" | 1): PropertyDecorator {\r\n    return function (target: any, propertyKey: string): void {\r\n        if (!target || !propertyKey) {\r\n            return;\r\n        }\r\n        // by default, it's a J N boolean text\r\n        if (!type || type === \"J\") {\r\n            Reflect.defineMetadata(PROP_META_KEY_JN, true, target, propertyKey);\r\n        } else if (type === \"T\") {\r\n            Reflect.defineMetadata(PROP_META_KEY_TF, true, target, propertyKey);\r\n        } else if (type === 1) {\r\n            Reflect.defineMetadata(PROP_META_KEY_10, true, target, propertyKey);\r\n        }\r\n    };\r\n}\r\n\r\n// Utility function holder of the BooleanTextDecorator decorator.\r\nexport class BooleanTextDecorator {\r\n\r\n    /**\r\n     * Returns whether given property (as a string) on given object is a boolean text field. That is, it's a field that is decorated\r\n     * with the @BooleanText decorator.\r\n     */\r\n    public static IsBooleanTextField(target: Object, propertyKey: string): boolean {\r\n        if (!target || !propertyKey || typeof target !== \"object\") {\r\n            return false;\r\n        }\r\n        return (\r\n            Reflect.getMetadata(PROP_META_KEY_JN, target, propertyKey) === true\r\n            ||\r\n            Reflect.getMetadata(PROP_META_KEY_TF, target, propertyKey) === true\r\n            ||\r\n            Reflect.getMetadata(PROP_META_KEY_10, target, propertyKey) === true\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Returns the logical true or false value of given character ('J', 'N', 'T' or 'F') or number (0 or 1).\r\n     * Returns UNDEFINED if given boolChar was not recognised as a boolean text.\r\n     */\r\n    public static GetLogicalBooleanValue(dbBoolChar: DbBooleanValueType | string): boolean {\r\n        return GetLogicalBooleanValue(dbBoolChar);\r\n    }\r\n\r\n    /**\r\n     * Returns the boolean character / number of given logical bool property on target object. Uses its @BooleanText() annotation to decide\r\n     * what character / number to return.\r\n     * Used in BusinessObjectSerializerServiceService to convert logical bools to their original boolean character.\r\n     * @returns {string|number} The original, reverse-engineered boolean character (or number) of given object property, or undefined.\r\n     */\r\n    public static GetDbBooleanValue(target: Object, propertyKey: string): DbBooleanValueType {\r\n        if (!target || !propertyKey || typeof target !== \"object\") {\r\n            return undefined;\r\n        }\r\n\r\n        let dbBoolVal: any = undefined;\r\n\r\n        const curBoolVal: boolean = target[propertyKey];\r\n\r\n        if (BooleanTextDecorator._IsJaNeeProp(target, propertyKey)) {\r\n            dbBoolVal = GetYesNoDbBooleanValue(curBoolVal);\r\n        } else if (BooleanTextDecorator._IsTrueFalseProp(target, propertyKey)) {\r\n            dbBoolVal = GetTrueFalseDbBooleanValue(curBoolVal);\r\n        } else if (BooleanTextDecorator._IsZeroOneProp(target, propertyKey)) {\r\n            dbBoolVal = GetOneZeroDbBooleanValue(curBoolVal);\r\n        }\r\n\r\n        return dbBoolVal as any as DbBooleanValueType;\r\n    }\r\n\r\n    private static _IsJaNeeProp(target: Object, propertyKey: string): boolean {\r\n        return BooleanTextDecorator._IsProp(PROP_META_KEY_JN, target, propertyKey);\r\n    }\r\n\r\n    private static _IsTrueFalseProp(target: Object, propertyKey: string): boolean {\r\n        return BooleanTextDecorator._IsProp(PROP_META_KEY_TF, target, propertyKey);\r\n    }\r\n\r\n    private static _IsZeroOneProp(target: Object, propertyKey: string): boolean {\r\n        return BooleanTextDecorator._IsProp(PROP_META_KEY_10, target, propertyKey);\r\n    }\r\n\r\n    private static _IsProp(prop: string, target: Object, propertyKey: string): boolean {\r\n        return !!target && !!propertyKey && typeof target === \"object\" && Reflect.hasMetadata(prop, target, propertyKey);\r\n    }\r\n}\r\n"]}