@colijnit/sharedcomponents 1.0.1 → 1.0.4

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/stock-transfer.component.js

@@ -0,0 +1,71 @@
+import { Component, EventEmitter, Output, ViewEncapsulation } from "@angular/core";
+export class StockTransferComponent {
+    constructor() {
+        this.handleCancelClicked = new EventEmitter();
+        this.handleStickerClicked = new EventEmitter();
+    }
+    handleOkClick() {
+    }
+    handleCancelClick() {
+        this.handleCancelClicked.emit();
+    }
+    handleStickerClick() {
+        this.handleStickerClicked.emit();
+    }
+}
+StockTransferComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-stock-transfer",
+                template: `
+      <div class="stock-transfer">
+        <div class="stock-transfer-columns">
+          <div class="stock-transfer-left-column">
+            <co-input-text disabled [placeholder]="'Standaard magazijn'">
+
+            </co-input-text>
+            <co-input-text disabled [placeholder]="'Standaard locatie'">
+
+            </co-input-text>
+            <co-input-text disabled [placeholder]="'Batch'">
+
+            </co-input-text>
+            <co-input-text disabled [placeholder]="'Serie'">
+
+            </co-input-text>
+            <co-input-text [placeholder]="'Aantal'">
+
+            </co-input-text>
+          </div>
+
+          <div class="stock-transfer-right-column">
+            <co-input-text [placeholder]="'Standaard magazijn'">
+
+            </co-input-text>
+            <co-input-text [placeholder]="'Standaard locatie'">
+
+            </co-input-text>
+            <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 = () => [];
+StockTransferComponent.propDecorators = {
+    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,61 @@
+import { __awaiter } from "tslib";
+import { Component, EventEmitter, HostBinding, Input, Output, ViewChild, ViewEncapsulation } from "@angular/core";
+import { StockService } from "../../service/stock.service";
+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;
+    }
+    handleStockLocationClick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._stockService.loadStockLocations(10);
+        });
+    }
+    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></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()" (handleStickerClicked)="handleStickerClicked.emit($event)"></co-stock-transfer>
+      </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+StockComponent.ctorParameters = () => [
+    { type: StockService }
+];
+StockComponent.propDecorators = {
+    stock: [{ type: ViewChild, args: [StockComponent,] }],
+    handleStickerClicked: [{ type: Output }],
+    options: [{ type: Input }],
+    goodId: [{ 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,42 @@
+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";
+export class StockModule {
+}
+StockModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    InputComboBoxModule,
+                    CoGridModule,
+                    ButtonModule,
+                    CommonModule,
+                    InputRadioButtonModule,
+                    DropDownModule,
+                    SimpleGridModule,
+                    ImageModule,
+                    InputTextModule
+                ],
+                declarations: [
+                    StockComponent,
+                    StockInformationComponent,
+                    StockInformationGridComponent,
+                    StockLocationComponent,
+                    StockTransferComponent
+                ],
+                exports: [
+                    StockComponent
+                ],
+                providers: [
+                    StockService,
+                    IoneConnectorAdapterService
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

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":"AAAA,OAAO,EAAC,sBAAsB,EAAC,MAAM,qDAAqD,CAAC;AAC3F,OAAO,EAAC,0BAA0B,EAAC,MAAM,yDAAyD,CAAC;AACnG,OAAO,EAAC,wBAAwB,EAAC,MAAM,4DAA4D,CAAC;AACpG,OAAO,EAAqB,sBAAsB,EAAC,MAAM,4DAA4D,CAAC;AAEtH,MAAM,gBAAgB,GAAW,eAAe,CAAC;AACjD,MAAM,gBAAgB,GAAW,eAAe,CAAC;AACjD,MAAM,gBAAgB,GAAW,eAAe,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,WAAW,CAAC,IAAoB;IAC5C,OAAO,UAAU,MAAW,EAAE,WAAmB;QAC7C,IAAI,CAAC,MAAM,IAAI,CAAC,WAAW,EAAE;YACzB,OAAO;SACV;QACD,sCAAsC;QACtC,IAAI,CAAC,IAAI,IAAI,IAAI,KAAK,GAAG,EAAE;YACvB,OAAO,CAAC,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;SACvE;aAAM,IAAI,IAAI,KAAK,GAAG,EAAE;YACrB,OAAO,CAAC,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;SACvE;aAAM,IAAI,IAAI,KAAK,CAAC,EAAE;YACnB,OAAO,CAAC,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;SACvE;IACL,CAAC,CAAC;AACN,CAAC;AAED,iEAAiE;AACjE,MAAM,OAAO,oBAAoB;IAE7B;;;OAGG;IACI,MAAM,CAAC,kBAAkB,CAAC,MAAc,EAAE,WAAmB;QAChE,IAAI,CAAC,MAAM,IAAI,CAAC,WAAW,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;YACvD,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,CACH,OAAO,CAAC,WAAW,CAAC,gBAAgB,EAAE,MAAM,EAAE,WAAW,CAAC,KAAK,IAAI;;gBAEnE,OAAO,CAAC,WAAW,CAAC,gBAAgB,EAAE,MAAM,EAAE,WAAW,CAAC,KAAK,IAAI;;gBAEnE,OAAO,CAAC,WAAW,CAAC,gBAAgB,EAAE,MAAM,EAAE,WAAW,CAAC,KAAK,IAAI,CACtE,CAAC;IACN,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,sBAAsB,CAAC,UAAuC;QACxE,OAAO,sBAAsB,CAAC,UAAU,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,iBAAiB,CAAC,MAAc,EAAE,WAAmB;QAC/D,IAAI,CAAC,MAAM,IAAI,CAAC,WAAW,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;YACvD,OAAO,SAAS,CAAC;SACpB;QAED,IAAI,SAAS,GAAQ,SAAS,CAAC;QAE/B,MAAM,UAAU,GAAY,MAAM,CAAC,WAAW,CAAC,CAAC;QAEhD,IAAI,oBAAoB,CAAC,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE;YACxD,SAAS,GAAG,sBAAsB,CAAC,UAAU,CAAC,CAAC;SAClD;aAAM,IAAI,oBAAoB,CAAC,gBAAgB,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE;YACnE,SAAS,GAAG,0BAA0B,CAAC,UAAU,CAAC,CAAC;SACtD;aAAM,IAAI,oBAAoB,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE;YACjE,SAAS,GAAG,wBAAwB,CAAC,UAAU,CAAC,CAAC;SACpD;QAED,OAAO,SAAsC,CAAC;IAClD,CAAC;IAEO,MAAM,CAAC,YAAY,CAAC,MAAc,EAAE,WAAmB;QAC3D,OAAO,oBAAoB,CAAC,OAAO,CAAC,gBAAgB,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IAC/E,CAAC;IAEO,MAAM,CAAC,gBAAgB,CAAC,MAAc,EAAE,WAAmB;QAC/D,OAAO,oBAAoB,CAAC,OAAO,CAAC,gBAAgB,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IAC/E,CAAC;IAEO,MAAM,CAAC,cAAc,CAAC,MAAc,EAAE,WAAmB;QAC7D,OAAO,oBAAoB,CAAC,OAAO,CAAC,gBAAgB,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IAC/E,CAAC;IAEO,MAAM,CAAC,OAAO,CAAC,IAAY,EAAE,MAAc,EAAE,WAAmB;QACpE,OAAO,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,WAAW,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,OAAO,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IACrH,CAAC;CACJ","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"]}

package/esm2015/lib/factory/decorators/complex-array.decorator.js

@@ -0,0 +1,55 @@
+import { notNill } from "@colijnit/articleapi/build/utils/function/not-nill.function";
+import { ObjectUtils } from "@colijnit/articleapi/build/utils/object-utils";
+const PROP_META_KEY = "complexArray";
+/**
+ * !! just a TAG DECORATOR for now, there is no code that uses this meta data within the ione connector lib itself.
+ */
+/**
+ * Property decorator for properties of businessobject classes that are an array of other strongly typed businessobjects.
+ * Ensures that the BusinessObjectFactoryService makes properly typed objects from incoming raw persistence data. Otherwise we couldn't add methods
+ * to our own businessobjects and use them, since all fields would be flat data without methods after BusinessObjectFactoryService creation.
+ *
+ * Usage:
+ *
+ * @ComplexArray(TransactionLine)
+ * public transactionLines: TransactionLine[]
+ */
+export function ComplexArray(type) {
+    return function (target, propertyKey) {
+        if (!target || !propertyKey || typeof target !== "object") {
+            return;
+        }
+        // warn the programmer if given type was undefined; it's probably an import order glitch that caused this, because decorators seem
+        // to be immediately processed when a class is first imported
+        if (!type) {
+            console.warn(`@ComplexArray(type): type was UNDEFINED. Called on prop (${ObjectUtils.GetClassName(target)}, ${propertyKey}). ` +
+                `Class will not properly serialize and deserialize now. We've always been able to fix this by CHANGING IMPORT ORDERS ` +
+                `where both classes and their dependencies are used, e.g. factory, repository or models..`);
+            return;
+        }
+        Reflect.defineMetadata(PROP_META_KEY, type, target, propertyKey);
+    };
+}
+// Utility function holder of the ComplexArrayDecorator decorator.
+export class ComplexArrayDecorator {
+    /**
+     * Returns whether given property (as a string) on given object is a complex array. A complex array is an array field that is decorated
+     * with the @ComplexArray decorator.
+     */
+    static IsComplexArray(target, propertyKey) {
+        if (!target || !propertyKey || typeof target !== "object") {
+            return false;
+        }
+        return (notNill(Reflect.getMetadata(PROP_META_KEY, target, propertyKey)));
+    }
+    /**
+     * Returns the VALUE of the @ComplexArray(VALUE) property decorator on the given propertyKey on the given modelobject.
+     */
+    static GetComplexArrayType(target, propertyKey) {
+        if (!target || !propertyKey || typeof target !== "object") {
+            return undefined;
+        }
+        return Reflect.getMetadata(PROP_META_KEY, target, propertyKey);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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