@colijnit/corecomponents_v12 254.1.10 → 255.1.1

package/projects/corecomponents/src/lib/core/enum/table-name.enum.ts

@@ -0,0 +1,79 @@
+export enum TableName {
+    Absence = "ABSENCE",
+    AbsenceEvent = "ABSENCE_EVENT",
+    AbsenceFile = "ABSENCE_FILE",
+    AbsenceForm = "ABSENCE_FORM",
+    AccountingPeriod = "PERIODES",
+    Address = "ADRESSEN",
+    Administration = "ADMINISTRATIES",
+    AnamnesisForm = "ANAMNESIS_FORM",
+    ArticleGroup = "ARTIKEL_GROEP",
+    Branch = "FILIALEN",
+    BusinessRule = "BRE_RULE",
+    Category = "CATEGORIE",
+    Characteristic = "KENMERKEN",
+    Company = "BEDRIJVEN",
+    Concept = "CONCEPTEN",
+    Connections = "ASS_VERBINDING",
+    ContactPerson = "CONTACTPERSONEN",
+    CostCenter = "KOSTENPLAATS_DRAGER",
+    Country = "LANDCODE",
+    CurrencyInfo = "VALUTA",
+    CurrentIndication = "CURRENT_INDICATION",
+    Customer = "KLANTEN",
+    DeclarationMedicalOfficer = "DECLARATION_MEDICAL_OFFICER",
+    DeliveryMethod = "LEVERMETHODES",
+    Department = "AFDELING",
+    DiagnosisForm = "DIAGNOSIS_FORM",
+    Documents = "DOCUMENTATIE",
+    EmployabilityProfile = "EMPLOYABILITY_PROFILE",
+    EmployeeContract = "EMPLOYEE_CONTRACT",
+    EmployeeContractType = "EMPLOYEE_CONTRACT_TYPE",
+    Employee = "PERSONEEL",
+    EndEvaluation = "END_EVALUATION",
+    ExternalSource = "EXTERNE_BRONNEN",
+    FirstYearEvaluation = "FIRST_YEAR_EVALUATION",
+    FmlDocument = "FML_DOCUMENT",
+    Goods = "GOEDEREN",
+    Hardware = "ASS_HARDWARE",
+    Identification = "IDENTIFICATION",
+    JobCategory = "JOB_CATEGORY",
+    JobType = "JOB_TYPE",
+    LedgerAccount = "GROOTBOEKEN",
+    LedgerClassification = "VERDICHTINGEN",
+    LedgerJournal = "DAGBOEKEN",
+    LedgerMainClassification = "HOOFDVERDICHTINGEN",
+    LedgerMutation = "GROOTBOEK_MUTATIES",
+    Location = "LOCATIES",
+    MainArticle = "HOOFDARTIKELEN",
+    MedicalConsultFeedback = "MEDICAL_CONSULT_FEEDBACK",
+    MedicalFile = "MEDICAL_FILE",
+    MedicalForm = "MEDICAL_FORM",
+    MedicalInformationForm = "MEDICAL_INFORMATION_FORM",
+    Note = "NOTITIE",
+    NotificationFullyRecovered = "NOTIFICATION_FULLY_RECOVERED",
+    NotificationLongTermIllness = "NOTIFICATION_LONG_TERM_ILLNESS",
+    PaymentCondition = "BETALINGSCONDITIES",
+    PaymentMethod = "BETAALWIJZE",
+    PlanOfApproach = "PLAN_OF_APPROACH",
+    PriceList = "PRIJSLIJSTEN",
+    ProblemAnalysis = "PROBLEM_ANALYSIS",
+    ProblemAnalysisAdjustment = "PROBLEM_ANALYSIS_ADJUSTMENT",
+    Relations = "RELATIES",
+    RelationAddress = "ADRES_RELATIES",
+    RelationCommunication = "COMM_RELATIES",
+    Remarks = "OPMERKINGEN",
+    Salary = "SALARY",
+    ServiceProvision = "ASS_DIENSTVERLENING",
+    ShortReintegrationReport = "SHORT_REINTEGRATION_REPORT",
+    Software = "ASS_SOFTWARE",
+    Supplier = "LEVERANCIERS",
+    TagValues = "TAG_VALUES",
+    Tasks = "TAKEN",
+    Transactions = "TRANSACTIES",
+    TurnoverGroup = "OMZETGROEPEN",
+    Unit = "EENHEDEN",
+    User = "GEBRUIKERS",
+    Vat = "BTW",
+    Warehouse = "MAGAZIJNEN"
+}

package/projects/corecomponents/src/lib/core/enum/value-comparison-type.ts

@@ -0,0 +1,11 @@
+// Represents different ways to compare two values, as per iOne client-server protocol.
+export enum ValueComparisonType {
+    Equal = '=',
+    LargerThan = '>',
+    LargerOrEqualThan = '>=',
+    SmallerThan = '<',
+    SmallerOrEqualThan = '<=',
+    NotEqual = '!=',
+    BetweenInclusive = '>=<',
+    Formula = 'x=y'
+}

package/projects/corecomponents/src/lib/core/function/any-nill.function.ts

@@ -0,0 +1,6 @@
+import {noneNill} from "./none-nill.function";
+
+// @returns true iff at least one of given values equals null or undefined.
+export function anyNill(...values: any[]): boolean {
+    return !noneNill(values);
+}

package/projects/corecomponents/src/lib/core/function/is-nill.function.ts

@@ -0,0 +1,4 @@
+// @returns true iff given value equals null or equals undefined
+export function isNill(value: any): boolean {
+    return value === null || value === undefined;
+}

package/projects/corecomponents/src/lib/core/function/none-nill.function.ts

@@ -0,0 +1,16 @@
+import {isNill} from "./is-nill.function";
+
+// @returns true iff for all items it holds that they do not equal null and not equal undefined. If at least one is null or undefined, this
+// function returns false.
+export function noneNill(...values: any[]): boolean {
+    if (values) {
+        for (let i: number = 0, len: number = values.length; i < len; i++) {
+            if (isNill(values[i])) {
+                return false;
+            }
+        }
+        return true;
+    } else {
+        return false;
+    }
+}

package/projects/corecomponents/src/lib/core/function/not-nill.function.ts

@@ -0,0 +1,4 @@
+// @returns true iff given value does not equals null and does not equal undefined
+export function notNill(value: any): boolean {
+    return value !== null && value !== undefined;
+}

package/projects/corecomponents/src/lib/core/interface/search-property.ts

@@ -0,0 +1,15 @@
+import {ValueComparisonType} from "../enum/value-comparison-type";
+import {SearchDataType} from "../enum/search-data-type";
+import {SearchPropertyState} from "../enum/search-property-state";
+
+export interface SearchProperty {
+    // name of data property in collection items, e.g. "lastName"
+    property?: string;
+    // for display of property to user
+    label?: string;
+    // The actual texts to search for, e.g. ["John", "Doe"]
+    values?: string[];
+    comparisonType?: ValueComparisonType;
+    dataType?: SearchDataType;
+    state?: SearchPropertyState;
+}

package/projects/corecomponents/src/lib/core/interface/sort-property.ts

@@ -0,0 +1,16 @@
+import {SortDirection} from "../enum/sort-direction";
+import {SortDataType} from "../enum/sort-data-type";
+
+export interface SortProperty {
+    property: string;
+    // localized, for display of property to user
+    label?: string;
+    direction?: SortDirection;
+    // assign the Number class as value to this prop for faster evals
+    evalType?: any;
+    // can be auto-set from direction
+    switcher?: number;
+    // default string, decides sort comparison algorithm
+    type?: SortDataType;
+    active?: boolean;
+}

package/projects/corecomponents/src/lib/core/model/bounds-constrained-number-value.ts

@@ -0,0 +1,222 @@
+import {Subject} from "rxjs";
+
+import {isNill} from "../function/is-nill.function";
+import {
+    DEFAULT_LOWER_BOUND_FOR_RANGE_COMPONENTS,
+    DEFAULT_UPPER_BOUND_FOR_RANGE_COMPONENTS
+} from '../constant/default-upper-bound-for-range-components';
+import {NumberUtils} from "../utils/number-utils";
+
+
+// A data type class that represents a stepped-bounds numerical value, with min max and step size. Value is always within these bounds and is auto corrected for incoming manipulation requests.
+export class BoundsConstrainedNumberValue {
+    public set value(value: number) {
+        this.setValue(value, true);
+    }
+
+    public get value(): number {
+        return this._value;
+    }
+
+    // Returns a display string of our .value number (NaN and undefined become the empty string).
+    public get valueAsSting(): string {
+        return this._valueAsString;
+    }
+
+    public set min(min: number) {
+        if (isNill(min)) {
+            return;
+        }
+
+        let shouldUpdateTrueMax: boolean = (this._min !== min);
+
+        this._min = min;
+
+        if (shouldUpdateTrueMax) {
+            this._updateTrueMax();
+        }
+    }
+
+    public get min(): number {
+        return this._min;
+    }
+
+    public set max(max: number) {
+        if (isNill(max)) {
+            return;
+        }
+
+        let shouldUpdateTrueMax: boolean = (this._max !== max);
+
+        this._max = max;
+
+        if (shouldUpdateTrueMax) {
+            this._updateTrueMax();
+        }
+    }
+
+    public get max(): number {
+        return this._max;
+    }
+
+    public get trueMax(): number {
+        return this._trueMax;
+    }
+
+    // The step interval size for allowed numbers Y = min + N * step, where N is integer or 0.
+    public set step(step: number) {
+        if (isNill(step)) {
+            return;
+        }
+
+        let shouldUpdateTrueMaxAndStepDecimals: boolean = (this._step !== step);
+
+        this._step = step;
+
+        if (shouldUpdateTrueMaxAndStepDecimals) {
+            this._updateTrueMax();
+            this._updateStepDecimals();
+        }
+    }
+
+    public set decimals(decimals: number) {
+        if (decimals > 0) {
+            this._decimals = decimals;
+        }
+    }
+    public get step(): number {
+        return this._step;
+    }
+
+    public get stepDecimals(): number {
+        return this._stepDecimals;
+    }
+
+    public get constraintsEnabled(): boolean {
+        return this._constraintsEnabled;
+    }
+
+    // emits when the value changed (e.g. after it was corrected for bounds)
+    public valueChange: Subject<number> = new Subject<number>();
+
+    // the actual numeric current value, which we ensure always complies to our current min, max and step
+    protected _value: number = 0;
+    protected _decimals: number; // number of decimals of the value.
+    protected _valueAsString: string = "0";
+    protected _min: number = DEFAULT_LOWER_BOUND_FOR_RANGE_COMPONENTS;
+    protected _max: number = DEFAULT_UPPER_BOUND_FOR_RANGE_COMPONENTS;
+    protected _step: number = 1;  // stepsize before the decimal.
+    protected _stepDecimals: number = 0; // derived from step
+    protected _trueMax: number = DEFAULT_UPPER_BOUND_FOR_RANGE_COMPONENTS; // derived from min, max and step
+
+    private _constraintsEnabled: boolean = true;
+
+    private _precision?: number;
+    private _scale?: number;
+
+    constructor() {
+    }
+
+    public roundedDecimals(value: number): number {
+        if (value >= 0) {
+            return 1 / Math.pow(10, value);
+        }
+        return 0;
+    }
+
+    public putPrecision(precision: number): void {
+        this._precision = precision;
+        this.max = NumberUtils.PrecisionScaleToMaxValue(this._precision, this._scale);
+    }
+
+    public putScale(scale: number): void {
+        this._scale = scale;
+        this.step = NumberUtils.DecimalsToStepIncrement(this._scale);
+        this.max = NumberUtils.PrecisionScaleToMaxValue(this._precision, this._scale);
+    }
+
+    // possibly corrects value for bounds
+    public init(silent: boolean = false): void {
+        this.setValue(this._value, silent);
+    }
+
+    // returns whether value really changed
+    public setValueByUserInputText(text: string, silent: boolean = false): boolean {
+        const prevVal: any = this.value;
+
+        if (NumberUtils.IsParsableNumberInput(text)) {
+            this.setValue(NumberUtils.ParseNumberInputOrDefault(text), silent);
+        } else {
+            this.setValue(undefined);
+        }
+
+        return prevVal !== this.value;
+    }
+
+    /**
+     * Makes sure current value adheres to our stepped bounds. Returns true if inner value really changed (after sanitizing), false if not.
+     * Returns whether value really changed.
+     */
+    public setValue(newValue: number, silent: boolean = false): boolean {
+        const oldValue: number = this._value;
+
+        if (!this._constraintsEnabled) {
+            this._setValue(newValue);
+        } else {
+            // cut off given newValue float excesses for cases such as "13.1000000000000000000001"
+            //newValue = NumberUtils.ParseFloat(newValue, NumberUtils.GetDecimalPlaces(this._step));
+
+            if (this._decimals === undefined) {
+                this._decimals = NumberUtils.GetDecimalPlaces(newValue);
+            }
+
+            newValue = NumberUtils.ParseFloat(newValue, this._decimals);
+            // dont perform bounds check if no min or max set.
+            if (isNaN(this._min) || isNaN(this._max)) {
+                this._setValue(newValue);
+            } else if (newValue >= this._min && newValue <= this._max) {
+                this._setValue(NumberUtils.GetNearestNumberWithinSteppedBounds(newValue, this._min, this._max, this.roundedDecimals(this._decimals)));
+            }
+        }
+
+        if (isNaN(this._value)) {
+            this._setValue(undefined);
+        }
+
+        if (!silent) {
+            this.valueChange.next(this._value);
+        }
+
+        return oldValue !== this._value;
+    }
+
+    public increment(steps: number = 1): void {
+        this.setValue(this._value + this._step * steps);
+    }
+
+    public decrement(steps: number = 1): void {
+        this.setValue(this._value - this._step * steps);
+    }
+
+    // afterwards, you may set any value, it won't be checked against our bounds anymore
+    public disableConstraints(): void {
+        this._constraintsEnabled = false;
+    }
+
+    public enableConstraints(): void {
+        this._constraintsEnabled = true;
+    }
+
+    private _updateTrueMax(): void {
+        this._trueMax = NumberUtils.GetTrueSteppedBoundsMax(this._min, this._max, this._step);
+    }
+
+    private _updateStepDecimals(): void {
+        this._stepDecimals = NumberUtils.GetDecimalPlaces(this._step);
+    }
+
+    private _setValue(value: number): void {
+        this._value = value;
+        this._valueAsString = NumberUtils.ToString(this._value);
+    }
+}

package/projects/corecomponents/src/lib/core/model/check-precision-and-scale-result.ts

@@ -0,0 +1,5 @@
+// Output object shape for NumberUtils.CheckPrecisionAndScale().
+export interface CheckPrecisionAndScaleResult {
+    isOk: boolean;
+    nearestOkNr?: number;
+}

package/projects/corecomponents/src/lib/core/model/check-within-stepped-bounds-result.ts

@@ -0,0 +1,8 @@
+/**
+ * Output object shape for NumberUtils.CheckWithinSteppedBounds(). For efficiency, this method also returns the found remainder if the given
+ * number was NOT within the specified stepped bounds.
+ */
+export interface CheckWithinSteppedBoundsResult {
+    isOk: boolean,
+    remainder?: number
+}

package/projects/corecomponents/src/lib/core/model/co-document-right.bo.ts

@@ -0,0 +1,9 @@
+import { ObjectRightType } from '../enum/object-right-type.enum';
+
+export class CoDocumentRight {
+
+    public userGroupId: number;
+    public documentId: number;
+    public rightLevel: ObjectRightType;
+
+}

package/projects/corecomponents/src/lib/core/model/co-document.bo.ts

@@ -0,0 +1,193 @@
+import { TableName } from '../enum/table-name.enum';
+import { CoDocumentType } from '../enum/co-document-type.enum';
+import { FileType } from '../enum/file-type.enum';
+import { FileTypeInternal } from '../enum/file-type-internal.enum';
+import { FileUtils } from '../utils/file-utils';
+import { CoDocumentImageDisplayKind } from '../enum/co-document-image-display-kind.enum';
+import { ObjectRightType } from '../enum/object-right-type.enum';
+import { Subject } from 'rxjs';
+import { CoDocumentRight } from './co-document-right.bo';
+// See DocumentDTO.
+export class CoDocument {
+    public set documentId(value: number) {
+        this._documentId = value;
+        // this._idObject.docId = value;
+    }
+
+    public get documentId(): number {
+        return this._documentId;
+    }
+
+    // @DateField()
+    public creationDate: Date;
+    // @DateField()
+    public modifiedDate: Date;
+    // public creationUser: string;
+    // public modifiedUser: string;
+    public description: string;
+    public thumbnailBody: string;
+    public table: TableName;
+    public key: string;
+    public filePath: string;
+    public documentType: CoDocumentType;
+    /**
+     * The database-fetched mimetype of this document. Note: is barely set to a value, and when it's set, it's usually garbage data.
+     * Use .mimeTypeInternal if you want the best educated guess of the true mime type of this document.
+     */
+    public mimeType: string;
+    public publication: number;
+    public fileSize: string;
+    public fileType: FileType;
+    public isLoaded: boolean;
+    public index: number;
+    public imageDimensions: string;
+    public title: string;
+    // @BooleanText("T")
+    // public downloadable: boolean;
+    // @BooleanText("T")
+    // public attachToNotification: boolean;
+    // @BooleanText("T")
+    // @DefaultSendValue("F")
+    // public pathIsUrl: boolean = false;
+    // public imageType: string;
+    public imageDisplayKind: CoDocumentImageDisplayKind;
+    // @ComplexArray(Tag)
+    // public tags: Tag[] = [];
+    public rightLevel: ObjectRightType;
+    // @ComplexArray(CoDocumentRight)
+    public rights: CoDocumentRight[] = [];
+
+    public set documentBody(documentBody: string) {
+        const prev: string = this._documentBody;
+
+        this._documentBody = documentBody;
+
+        if (prev !== this._documentBody) {
+            this.documentBodyChange.next(this._documentBody);
+        }
+    }
+
+    public get documentBody(): string {
+        return this._documentBody;
+    }
+
+    // @DefaultSendValue([])
+    // @ComplexArray(ArticleSeoValue)
+    // public seoTitles: ArticleSeoValue[] = [];
+    public fileName: string;
+    public retailFormulas: string[] = [];
+
+    // @NoDbField()
+    // public idForLink: number;
+
+    // The internal file type of this document (the MimeType iOneJS uses internally)
+    public get fileTypeInternal(): FileTypeInternal {
+        if (!this._fileTypeInternal) {
+            const fileType: FileTypeInternal = FileUtils.FileNameToFileTypeInternal(this.fileName);
+            if (fileType) {
+                this._fileTypeInternal = fileType;
+            }
+        }
+        return this._fileTypeInternal;
+    }
+
+    /**
+     * The mimetype of this document: uses database-fetched this.mimeType, or calculates / guesses the mime type of the document
+     * if that was not set.
+     */
+    public get mimeTypeInternal(): string {
+        if (this._mimeTypeInternal) {
+            return this._mimeTypeInternal;
+        } else {
+            this._initMimetypeInternal();
+            return this._mimeTypeInternal;
+        }
+    }
+
+    public set mimeTypeInternal(value: string) {
+        this._mimeTypeInternal = value;
+    }
+
+    // Gives either the document-(prio) or the thumbnail body. Or undefined if not exist.
+    public get bodyAsDataUri(): string {
+        if (this._documentBody) {
+            return this.documentBodyAsDataUri;
+        } else if (this.thumbnailBody) {
+            return this.thumbnailBodyAsDataUri;
+        }
+    }
+
+    // The body of this document as a data uri. The data uri also contains the mimetype in its string, and the fact that it's base64.
+    public get documentBodyAsDataUri(): string {
+        try {
+            return FileUtils.DocumentBodyToDataUri(this.documentBody, this.mimeTypeInternal);
+        } catch (error) {
+            return "";
+        }
+    }
+
+    // The Thumbnailbody of this document as a data uri. The data uri also contains the mimetype in its string, and the fact that it's base64.
+    public get thumbnailBodyAsDataUri(): string {
+        try {
+            return FileUtils.DocumentBodyToDataUri(this.thumbnailBody, this.mimeTypeInternal);
+        } catch (error) {
+            return "";
+        }
+    }
+
+    public get isAvatar(): boolean {
+        return this.imageDisplayKind === CoDocumentImageDisplayKind.Avatar;
+    }
+
+    // @DbFieldAlias("documentBody")
+    private _documentBody: string;
+    //
+    // @DbFieldAlias("documentId")
+    private _documentId: number;
+    //
+    // @NoDbField()
+    // @ComplexField(Subject)
+    public readonly documentBodyChange: Subject<string> = new Subject<string>();
+
+    // The internal representation of the MimeType, see enum MimeType (actual mimeType field is not filled in db often)
+    // @NoDbField()
+    private _fileTypeInternal: FileTypeInternal;
+    // eg "image/jpeg"
+    // @NoDbField()
+    private _mimeTypeInternal: string;
+    //
+    // @NoDbField()
+    // private _idObject: any = {};
+
+    public get readonly(): boolean {
+        return this.rightLevel === ObjectRightType.ReadOnly;
+    }
+
+    constructor() {
+    }
+
+    public getId(): any {
+        return this.documentId;
+    }
+
+    // Returns whether this is an image document or not.
+    public isImageDocument(): boolean {
+        return (this.fileTypeInternal === FileTypeInternal.Image);
+    }
+
+    // @BoSerializerStep()
+    public preventOverridingThumbnailToEmpty(): void {
+        if (!this.thumbnailBody) {
+            this.thumbnailBody = this._documentBody;
+        }
+    }
+
+    // POSTCONDITION: this._mimeTypeInternal contains, to our best abilities, the true mimeType of this document, a-la "image/jpg"
+    private _initMimetypeInternal(): void {
+        // if no fileType, default to FileType.Image for internal mimetype initialization
+        if ((this.fileType === FileType.Image || !this.fileType) && this.fileName) {
+            const fileExtension: string = this.fileName.substr(this.fileName.lastIndexOf(".") + 1);
+            this._mimeTypeInternal = "image/" + fileExtension;
+        }
+    }
+}

package/projects/corecomponents/src/lib/core/model/color-sequence.ts

@@ -0,0 +1,39 @@
+import { Color } from './color';
+import { ColorSequenceName } from '../enum/color-sequence-name.enum';
+import { NumberUtils } from '../utils/number-utils';
+
+// @BusinessObjectData({
+//     name: "ColorSequence",
+//     mapping: DataMapping.Simplebasedata
+// })
+export class ColorSequence {
+
+    public colors: Color[] = [];
+
+    public name: ColorSequenceName;
+
+    public addColor(color: Color): void {
+        this.colors.push(color);
+    }
+
+    // CYCLES through the colors in this sequence and returns the color on given index.
+    public getColor(index: number): Color {
+        if (!this.colors) {
+            return new Color();
+        }
+
+        return this.colors[index % this.colors.length];
+    }
+
+    public getId(): string {
+        return this.name;
+    }
+
+    public getRandomColor(): Color {
+        if (!this.colors) {
+            return new Color();
+        }
+
+        return this.colors[NumberUtils.RandomInt(0, this.colors.length - 1)];
+    }
+}

package/projects/corecomponents/src/lib/core/model/color.ts

@@ -0,0 +1,29 @@
+import { CssUtils } from '../utils/css-utils';
+
+// @BusinessObjectData({
+//     name: "Color",
+//     mapping: DataMapping.Simplebasedata
+// })
+
+export class Color {
+    public colorCode: string;
+    public description: string;
+    public rgbColor: string;
+
+    // This rgbColor of this color represented like '#abcdef', for direct use in CSS.
+    public get cssColor(): string {
+        return CssUtils.DbRgbColorStringToCssRgbColor(this.rgbColor);
+    }
+
+    constructor() {
+    }
+
+    // @override
+    public getId(): string {
+        return this.rgbColor;
+    }
+
+    public getTransparentCssColor(opacity: number = 0.5): string {
+        return CssUtils.TransparentColor(this.cssColor, opacity);
+    }
+}