raain-model 1.10.25 → 1.11.4

package/{organization/RaainNode.js → src/organization/RaainNode.ts}

@@ -1,61 +1,80 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RaainNode = void 0;
-const Link_1 = require("./Link");
-class RaainNode {
-    constructor(json) {
-        if (!(json === null || json === void 0 ? void 0 : json.id)) {
+import {Link} from './Link';
+import {IVersion} from './IVersion';
+
+export class RaainNode implements IVersion {
+
+    public readonly id: string;
+    public readonly version: string;
+    private links: Link[];
+
+    constructor(json: {
+        id: string,
+        links?: Link[] | RaainNode[],
+        version?: string
+    }) {
+
+        if (!json?.id) {
             throw new Error('RaainNode needs a valid Object or ID');
         }
+
         this.id = json.id;
         this.setLinks(json.links ? json.links : []);
         this.version = json.version ? json.version : undefined;
     }
-    static _getPurifiedLinks(linksToPurify) {
+
+    private static _getPurifiedLinks(linksToPurify: any[]): Link[] {
         if (!linksToPurify || linksToPurify.length === 0) {
             return [];
         }
+
         const linksPurified = linksToPurify.map(l => {
-            if (l instanceof Link_1.Link || Link_1.Link.isCloneable(l)) {
-                return Link_1.Link.clone(l);
-            }
-            else if (l && l.getLinkType && l.id) {
-                return new Link_1.Link(l.getLinkType(), '../' + l.getLinkType() + 's/' + l.id);
+            if (l instanceof Link || Link.isCloneable(l)) {
+                return Link.clone(l);
+            } else if (l && l.getLinkType && l.id) {
+                return new Link(l.getLinkType(), '../' + l.getLinkType() + 's/' + l.id);
             }
         });
+
         function uniqBy(a, key) {
             const seen = {};
             return a.filter((item) => {
                 if (!item) {
                     return false;
                 }
+
                 const k = key(item);
                 return seen.hasOwnProperty(k) ? false : (seen[k] = true);
             });
         }
+
         return uniqBy(linksPurified, JSON.stringify);
     }
-    toJSON() {
+
+    public toJSON(): JSON {
         return {
             id: this.id,
             links: this.links,
             version: this.version,
-        };
+        } as any;
     }
-    getId() {
+
+    public getId(): string {
         return this.id.toString();
     }
-    setLinks(linksToSet) {
+
+    public setLinks(linksToSet: Link[] | RaainNode[]) {
         this.links = RaainNode._getPurifiedLinks(linksToSet);
     }
-    addLinks(linksToAdd) {
+
+    public addLinks(linksToAdd: Link[] | RaainNode[]) {
         if (!this.links) {
             this.links = [];
         }
-        const concatLinks = this.links.concat(linksToAdd);
+        const concatLinks = this.links.concat((linksToAdd as Link[]));
         this.links = RaainNode._getPurifiedLinks(concatLinks);
     }
-    getLink(linkType, index) {
+
+    public getLink(linkType: string, index?: number): Link {
         if (!this.links || !linkType) {
             return null;
         }
@@ -66,7 +85,8 @@ class RaainNode {
         }
         return linksFound[index];
     }
-    getLinkId(linkType, index) {
+
+    public getLinkId(linkType: string, index?: number): string {
         index = !index ? 0 : index;
         const link = this.getLink(linkType, index);
         if (link) {
@@ -74,22 +94,26 @@ class RaainNode {
         }
         return null;
     }
-    getLinksCount(linkType) {
+
+    public getLinksCount(linkType?: string): number {
         if (!linkType) {
             return this.links.length;
         }
-        const linksFound = this.links.filter(l => (l === null || l === void 0 ? void 0 : l.rel) === linkType);
+
+        const linksFound = this.links.filter(l => l?.rel === linkType);
         return linksFound.length;
     }
-    getLinks() {
-        return this.links.map(l => Link_1.Link.clone(l));
+
+    public getLinks(): Link[] {
+        return this.links.map(l => Link.clone(l));
     }
-    getVersion() {
+
+    public getVersion() {
         return this.version;
     }
-    getLinkType() {
+
+    protected getLinkType(): string {
         throw new Error('to implement');
     }
+
 }
-exports.RaainNode = RaainNode;
-//# sourceMappingURL=RaainNode.js.map

package/src/organization/TeamNode.ts

@@ -0,0 +1,46 @@
+import {PeopleNode} from './PeopleNode';
+import {RaainNode} from './RaainNode';
+
+/**
+ *  api/teams?name=customerTeam
+ */
+export class TeamNode extends RaainNode {
+
+    public static TYPE = 'team';
+
+    public id: any | string;
+    public name: string;
+    public description: string;
+    public contracts: string[];
+    public contacts: PeopleNode[];
+
+    constructor(json: {
+        id: any | string,
+        name?: string,
+        description?: string,
+        contracts?: string[],
+        contacts?: PeopleNode[]
+    }) {
+        super(json);
+
+        this.id = json.id;
+        this.name = json.name;
+        this.description = json.description;
+        this.contracts = json.contracts;
+        this.contacts = json.contacts;
+    }
+
+    public toJSON(): JSON {
+        return {
+            id: this.id,
+            name: this.name,
+            description: this.description,
+            contracts: this.contracts,
+            contacts: this.contacts,
+        } as any;
+    }
+
+    protected getLinkType(): string {
+        return TeamNode.TYPE;
+    }
+}

package/src/polar/AbstractPolarMeasureValue.ts

@@ -0,0 +1,121 @@
+import {MeasureValuePolarContainer} from './MeasureValuePolarContainer';
+import {IPolarMeasureValue} from './IPolarMeasureValue';
+import {PolarMeasureValue} from './PolarMeasureValue';
+import {PolarValue} from './PolarValue';
+
+export class AbstractPolarMeasureValue implements IPolarMeasureValue {
+
+    protected polars: PolarMeasureValue;
+
+    constructor(json: {
+        polars: AbstractPolarMeasureValue | PolarMeasureValue | string
+    }) {
+
+        if (!json?.polars) {
+            throw new Error('PolarMeasureValue needs polars');
+        }
+
+        let polars = json.polars;
+        if (typeof polars === 'string') {
+            if (polars.indexOf('polars') > 0) {
+                polars = JSON.parse(polars);
+            } else {
+                this.setPolarsAsString(polars);
+                return;
+            }
+        }
+
+        if (polars instanceof PolarMeasureValue) {
+            this.setPolarsAsContainer(polars.getPolars());
+            return;
+        }
+
+        let polarMeasure = polars;
+        if (polars && typeof polars['polars'] !== 'undefined' && typeof polars['angle'] !== 'undefined') {
+            polarMeasure = polars['polars'];
+        }
+
+        let subPolars = polarMeasure;
+        if (polarMeasure && polarMeasure['polars']) {
+            subPolars = polarMeasure['polars'];
+        }
+
+        if (subPolars instanceof PolarMeasureValue) {
+            this.setPolarsAsContainer(subPolars.getPolars());
+            return;
+        }
+
+        if (typeof subPolars === 'string') {
+            this.setPolarsAsString(subPolars);
+            return;
+        }
+
+        if (Array.isArray(subPolars)) {
+            this.setPolarsAsContainer(subPolars);
+            return;
+        }
+
+        throw new Error('PolarMeasureValue needs valid typed polars');
+    }
+
+    getPolarsStringified(): string {
+        return this.polars.getPolarsStringified();
+    }
+
+    getPolars(): MeasureValuePolarContainer[] {
+        return this.polars.getPolars();
+    }
+
+    setPolarsAsString(s: string): void {
+        this.polars = new PolarMeasureValue({measureValuePolarContainers: s});
+    }
+
+    setPolarsAsContainer(s: MeasureValuePolarContainer[]): void {
+        this.polars = new PolarMeasureValue({measureValuePolarContainers: s});
+    }
+
+    getPolarValue(json: { azimuthIndex: number, edgeIndex: number, strict?: boolean }): PolarValue {
+        return this.polars.getPolarValue(json);
+    }
+
+    setPolarValue(json: { azimuthIndex: number, edgeIndex: number, value: number }): void {
+        return this.polars.setPolarValue(json);
+    }
+
+    getAzimuthsCount(): number {
+        return this.polars.getPolars().length;
+    }
+
+    getPolarEdgesCount(): number {
+        const polars = this.polars.getPolars();
+        if (polars.length > 0) {
+            return polars[0].polarEdges.length;
+        }
+        return 0;
+    }
+
+    getDistance(): number {
+        const polars = this.polars.getPolars();
+        if (polars.length > 0) {
+            return polars[0].distance;
+        }
+        return 1;
+    }
+
+    public toJSON(stringify = false): JSON {
+        let polars: any = this.polars;
+        if (stringify) {
+            polars = this.polars.toJSONWithPolarStringified();
+        }
+
+        const json: any = {
+            polars,
+        };
+        return json;
+    }
+
+    public toJSONWithPolarStringified(): JSON {
+        const json: any = this.polars.toJSONWithPolarStringified();
+        return json;
+    }
+}

package/src/polar/GaugePolarMeasureValue.ts

@@ -0,0 +1,15 @@
+import {IPolarMeasureValue} from './IPolarMeasureValue';
+import {AbstractPolarMeasureValue} from './AbstractPolarMeasureValue';
+import {PolarMeasureValue} from './PolarMeasureValue';
+
+/**
+ * Gauge with single polar value container
+ */
+export class GaugePolarMeasureValue extends AbstractPolarMeasureValue implements IPolarMeasureValue {
+
+    constructor(json: {
+        polars: string | PolarMeasureValue | AbstractPolarMeasureValue
+    }) {
+        super(json);
+    }
+}

package/src/polar/IPolarMeasureValue.ts

@@ -0,0 +1,21 @@
+import {MeasureValuePolarContainer} from './MeasureValuePolarContainer';
+import {PolarValue} from './PolarValue';
+
+export interface IPolarMeasureValue {
+
+    getPolarsStringified(): string;
+
+    getPolars(): MeasureValuePolarContainer[];
+
+    setPolarsAsString(s: string): void;
+
+    setPolarsAsContainer(s: MeasureValuePolarContainer[]): void;
+
+    toJSON(): JSON;
+
+    toJSONWithPolarStringified(): JSON;
+
+    getPolarValue(json: { azimuthIndex: number, edgeIndex: number }): PolarValue;
+
+    setPolarValue(json: { azimuthIndex: number, edgeIndex: number, value: number }): void;
+}

package/src/polar/MeasureValuePolarContainer.ts

@@ -0,0 +1,28 @@
+export class MeasureValuePolarContainer {
+    public azimuth: number;
+    public distance: number;
+    public polarEdges: number[];
+
+    constructor(json: {
+        azimuth: number,
+        distance: number,
+        polarEdges: number[]
+    }) {
+
+        if (typeof json?.azimuth === 'undefined') {
+            throw new Error('MeasureValuePolarContainer needs a valid Object');
+        }
+
+        this.azimuth = json.azimuth;
+        this.distance = json.distance;
+        this.polarEdges = json.polarEdges;
+    }
+
+    public toJSON(): JSON {
+        return {
+            azimuth: this.azimuth,
+            distance: this.distance,
+            polarEdges: this.polarEdges,
+        } as any;
+    }
+}

package/{polar/PolarMeasureValue.js → src/polar/PolarMeasureValue.ts}

@@ -1,50 +1,62 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PolarMeasureValue = void 0;
-const MeasureValuePolarContainer_1 = require("./MeasureValuePolarContainer");
-const PolarValue_1 = require("./PolarValue");
-class PolarMeasureValue {
-    constructor(json) {
+import {MeasureValuePolarContainer} from './MeasureValuePolarContainer';
+import {IPolarMeasureValue} from './IPolarMeasureValue';
+import {PolarValue} from './PolarValue';
+
+export class PolarMeasureValue implements IPolarMeasureValue {
+    private polars: MeasureValuePolarContainer[];
+
+    constructor(json: {
+        measureValuePolarContainers: MeasureValuePolarContainer[] | string
+    }) {
         if (typeof json.measureValuePolarContainers === 'string') {
             this.setPolarsAsString(json.measureValuePolarContainers);
             return;
         }
+
         if (json.measureValuePolarContainers instanceof PolarMeasureValue && json.measureValuePolarContainers.getPolars()) {
             this.setPolarsAsContainer(json.measureValuePolarContainers.getPolars());
             return;
         }
+
         this.setPolarsAsContainer(json.measureValuePolarContainers);
     }
-    getPolarsStringified() {
+
+    getPolarsStringified(): string {
         return JSON.stringify(this.getPolars());
     }
-    getPolars() {
+
+    getPolars(): MeasureValuePolarContainer[] {
         return this.polars;
     }
-    setPolarsAsString(s) {
+
+    setPolarsAsString(s: string): void {
         try {
             let polars = JSON.parse(s);
+
             if (polars && polars.polars) {
                 polars = polars.polars;
             }
+
             if (typeof polars === 'string') {
                 polars = JSON.parse(polars);
             }
-            this.polars = polars.map(convertedPolar => new MeasureValuePolarContainer_1.MeasureValuePolarContainer(convertedPolar));
-        }
-        catch (e) {
+
+            this.polars = polars.map(convertedPolar => new MeasureValuePolarContainer(convertedPolar));
+        } catch (e) {
             console.warn('setPolarsAsString pb: ', e, typeof s, s);
             this.polars = [];
         }
     }
-    setPolarsAsContainer(measureValuePolarContainers) {
-        let parsed = measureValuePolarContainers ? measureValuePolarContainers : [];
+
+    setPolarsAsContainer(measureValuePolarContainers: MeasureValuePolarContainer[]): void {
+        let parsed: any = measureValuePolarContainers ? measureValuePolarContainers : [];
         if (!('length' in parsed)) {
             parsed = [];
         }
         this.polars = parsed;
     }
-    getPolarValue(json) {
+
+    getPolarValue(json: { azimuthIndex: number, edgeIndex: number, strict?: boolean }): PolarValue {
         let azimuthIndex = json.azimuthIndex;
         if (!json.strict) {
             azimuthIndex = this.updateIndex(this.polars, json.azimuthIndex);
@@ -53,6 +65,7 @@ class PolarMeasureValue {
         if (!azimuthContainer) {
             return null;
         }
+
         let edgeIndex = json.edgeIndex;
         if (!json.strict) {
             edgeIndex = this.updateIndex(azimuthContainer.polarEdges, json.edgeIndex);
@@ -61,13 +74,19 @@ class PolarMeasureValue {
         if (typeof edgeValue === 'undefined') {
             return null;
         }
-        return new PolarValue_1.PolarValue({
+
+        return new PolarValue({
             value: edgeValue,
             polarAzimuthInDegrees: azimuthContainer.azimuth,
             polarDistanceInMeters: azimuthContainer.distance * edgeIndex
         });
     }
-    setPolarValue(json) {
+
+    setPolarValue(json: {
+        azimuthIndex: number,
+        edgeIndex: number,
+        value: number
+    }): void {
         const azimuthIndex = this.updateIndex(this.polars, json.azimuthIndex);
         const azimuthContainer = this.polars[azimuthIndex];
         if (!azimuthContainer) {
@@ -76,25 +95,25 @@ class PolarMeasureValue {
         const edgeIndex = this.updateIndex(azimuthContainer.polarEdges, json.edgeIndex);
         azimuthContainer.polarEdges[edgeIndex] = json.value;
     }
-    toJSON() {
+
+    public toJSON(): JSON {
         return {
             polars: this.polars
-        };
+        } as any;
     }
-    toJSONWithPolarStringified() {
+
+    public toJSONWithPolarStringified(): JSON {
         return {
             polars: this.getPolarsStringified()
-        };
+        } as any;
     }
-    updateIndex(array, index) {
+
+    protected updateIndex(array: Array<any>, index: number): number {
         if (array.length <= index) {
             index = index - array.length;
-        }
-        else if (index < 0) {
+        } else if (index < 0) {
             index = array.length + index;
         }
         return index;
     }
 }
-exports.PolarMeasureValue = PolarMeasureValue;
-//# sourceMappingURL=PolarMeasureValue.js.map

package/src/polar/PolarValue.ts

@@ -0,0 +1,16 @@
+export class PolarValue {
+    public value: number;
+    public polarAzimuthInDegrees: number;
+    public polarDistanceInMeters: number;
+
+    constructor(json: {
+        value: number,
+        polarAzimuthInDegrees: number,
+        polarDistanceInMeters: number
+    }) {
+        this.value = json.value;
+        this.polarAzimuthInDegrees = json.polarAzimuthInDegrees;
+        this.polarDistanceInMeters = json.polarDistanceInMeters;
+    }
+}
+

package/src/polar/RadarPolarMeasureValue.ts

@@ -0,0 +1,43 @@
+import {IPolarMeasureValue} from './IPolarMeasureValue';
+import {AbstractPolarMeasureValue} from './AbstractPolarMeasureValue';
+import {PolarMeasureValue} from './PolarMeasureValue';
+
+/**
+ * Radar with polar value containers
+ */
+export class RadarPolarMeasureValue extends AbstractPolarMeasureValue implements IPolarMeasureValue {
+
+    public angle: number;
+
+    constructor(json: {
+        polars: RadarPolarMeasureValue | PolarMeasureValue | string,
+        angle?: number
+    }) {
+        super(json);
+
+        if (json.polars instanceof RadarPolarMeasureValue) {
+            this.angle = json.polars.angle;
+            return;
+        }
+
+        if (typeof json.polars === 'string') {
+            const object = JSON.parse(json.polars);
+            this.angle = json.angle ? json.angle : object.angle;
+            return;
+        }
+
+        this.angle = json.angle;
+    }
+
+    public toJSON(stringify = false): JSON {
+        const json: any = super.toJSON(stringify);
+        json.angle = this.angle;
+        return json;
+    }
+
+    public toJSONWithPolarStringified(): JSON {
+        const json: any = super.toJSONWithPolarStringified();
+        json.angle = this.angle;
+        return json;
+    }
+}

package/src/polar/RainPolarMeasureValue.ts

@@ -0,0 +1,57 @@
+import {IPolarMeasureValue} from './IPolarMeasureValue';
+import {IVersion} from '../organization/IVersion';
+import {AbstractPolarMeasureValue} from './AbstractPolarMeasureValue';
+import {PolarMeasureValue} from './PolarMeasureValue';
+
+/**
+ * Computed Rain with polar value containers
+ */
+export class RainPolarMeasureValue extends AbstractPolarMeasureValue implements IPolarMeasureValue, IVersion {
+
+    private readonly version: string;
+
+    constructor(json: {
+        polars: RainPolarMeasureValue | PolarMeasureValue | string,
+        version?: string
+    }) {
+        super(json);
+
+        if (json.polars instanceof RainPolarMeasureValue) {
+            this.version = json.polars.version;
+            return;
+        }
+
+        this.version = json.version;
+    }
+
+    static From(obj: any): RainPolarMeasureValue {
+        let version: string,
+            polars: PolarMeasureValue;
+
+        if (typeof obj.version === 'string') {
+            version = obj.version;
+        }
+
+        if (typeof obj.polars !== 'undefined') {
+            polars = obj.polars;
+        }
+
+        return new RainPolarMeasureValue({polars, version});
+    }
+
+    public toJSON(stringify = false): JSON {
+        const json: any = super.toJSON(stringify);
+        json.version = this.version;
+        return json;
+    }
+
+    public toJSONWithPolarStringified(): JSON {
+        const json: any = super.toJSONWithPolarStringified();
+        json.version = this.version;
+        return json;
+    }
+
+    public getVersion(): string {
+        return this.version;
+    }
+}