@colijnit/corecomponents_v12 12.0.13 → 12.0.16

package/esm2015/lib/core/model/bounds-constrained-number-value.js

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

package/esm2015/lib/core/model/check-precision-and-scale-result.js

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

package/esm2015/lib/core/model/check-within-stepped-bounds-result.js

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

package/esm2015/lib/core/model/co-document-right.bo.js

@@ -0,0 +1,3 @@
+export class CoDocumentRight {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY28tZG9jdW1lbnQtcmlnaHQuYm8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlY29tcG9uZW50cy9zcmMvbGliL2NvcmUvbW9kZWwvY28tZG9jdW1lbnQtcmlnaHQuYm8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLGVBQWU7Q0FNM0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYmplY3RSaWdodFR5cGUgfSBmcm9tICcuLi9lbnVtL29iamVjdC1yaWdodC10eXBlLmVudW0nO1xuXG5leHBvcnQgY2xhc3MgQ29Eb2N1bWVudFJpZ2h0IHtcblxuICAgIHB1YmxpYyB1c2VyR3JvdXBJZDogbnVtYmVyO1xuICAgIHB1YmxpYyBkb2N1bWVudElkOiBudW1iZXI7XG4gICAgcHVibGljIHJpZ2h0TGV2ZWw6IE9iamVjdFJpZ2h0VHlwZTtcblxufVxuIl19

package/esm2015/lib/core/model/co-document.bo.js

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