raain-model 2.6.10 → 3.0.1

package/src/organization/Measure.ts

@@ -1,61 +0,0 @@
-import {IPolarMeasureValue} from '../polar';
-import {RaainNode} from './RaainNode';
-import {ICartesianMeasureValue} from '../cartesian';
-
-export class Measure extends RaainNode {
-    public date: Date;
-    //   -> why array ? because you have different angle/axis from the Radar
-    public values: IPolarMeasureValue[] | ICartesianMeasureValue[] | number[];
-    public validity: number;
-
-    // internal
-    private configurationAsJSON: string;
-
-    constructor(json: {
-                    id: string,
-                    values: IPolarMeasureValue[] | ICartesianMeasureValue[] | number[],
-                    date?: Date,
-                    validity?: number,
-                    configurationAsJSON?: string,
-                    version?: string,
-                }
-    ) {
-        super(json);
-        this.values = json.values ? json.values : [];
-        this.date = json.date ? new Date(json.date) : undefined;
-        this.validity = json.validity >= 0 ? json.validity : -1;
-        this.setConfiguration(json.configurationAsJSON);
-    }
-
-    public setConfiguration(configuration: string | any) {
-        let conf = configuration;
-        try {
-            conf = JSON.parse(configuration);
-        } catch (ignored) {
-        }
-
-        if (conf) {
-            this.configurationAsJSON = JSON.stringify(conf);
-        }
-    }
-
-    public toJSON(options: { removeValues?: boolean } = {}): any {
-        const json = super.toJSON();
-        json['date'] = this.date?.toISOString();
-        json['validity'] = this.validity;
-        json['configurationAsJSON'] = this.configurationAsJSON;
-
-        if (!options?.removeValues) {
-            json['values'] = this.values;
-        }
-        return json;
-    }
-
-    public getConfiguration(): any {
-        try {
-            return JSON.parse(this.configurationAsJSON);
-        } catch (e) {
-        }
-        return null;
-    }
-}

package/src/organization/TeamNode.ts

@@ -1,91 +0,0 @@
-import {PeopleNode} from './PeopleNode';
-import {RaainNode} from './RaainNode';
-
-/**
- * Represents a team in the RAAIN system.
- * This class manages team members and their contracts.
- *
- * @remarks
- * Used in the API endpoint: api/teams?name=customerTeam
- *
- * @example
- * ```typescript
- * const teamNode = new TeamNode({
- *   id: 'team1',
- *   name: 'Customer Team',
- *   description: 'Main customer support team',
- *   contracts: ['basic', 'premium'],
- *   contacts: [peopleNode1, peopleNode2]
- * });
- * ```
- */
-export class TeamNode extends RaainNode {
-
-    /** Type identifier for team nodes */
-    public static TYPE = 'team';
-
-    /** Unique identifier for the team */
-    public id: any | string;
-
-    /** Name of the team */
-    public name: string;
-
-    /** Description of the team */
-    public description: string;
-
-    /** Array of contract types associated with the team */
-    public contracts: string[];
-
-    /** Array of team members */
-    public contacts: PeopleNode[];
-
-    /**
-     * Creates a new TeamNode instance.
-     *
-     * @param json - Configuration object
-     * @param json.id - Unique identifier
-     * @param json.name - Optional name of the team
-     * @param json.description - Optional description
-     * @param json.contracts - Optional array of contract types
-     * @param json.contacts - Optional array of team members
-     */
-    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;
-    }
-
-    /**
-     * Converts the team node to a JSON object.
-     *
-     * @returns A JSON object containing the team's data
-     */
-    public toJSON(): any {
-        return {
-            id: this.id,
-            name: this.name,
-            description: this.description,
-            contracts: this.contracts,
-            contacts: this.contacts,
-        } as any;
-    }
-
-    /**
-     * Returns the link type for team nodes.
-     *
-     * @returns The string 'team'
-     */
-    protected getLinkType(): string {
-        return TeamNode.TYPE;
-    }
-}

package/src/polar/IPolarMeasureValue.ts

@@ -1,21 +0,0 @@
-import {MeasureValuePolarContainer} from './MeasureValuePolarContainer';
-import {PolarValue} from './PolarValue';
-
-export interface IPolarMeasureValue {
-
-    getAzimuthsCount(): number;
-
-    getPolarEdgesCount(): number;
-
-    getPolarsStringified(): string;
-
-    getPolars(): MeasureValuePolarContainer[];
-
-    toJSON(options?: any): any;
-
-    toJSONWithPolarStringified(): any;
-
-    getPolarValue(json: { azimuthInDegrees: number, distanceInMeters: number }): PolarValue;
-
-    setPolarValue(json: { azimuthInDegrees: number, distanceInMeters: number, value: number }): void;
-}

package/src/polar/PolarFilter.ts

@@ -1,46 +0,0 @@
-export class PolarFilter {
-    azimuthMin: number;
-    azimuthMax: number;
-    edgeMin: number;
-    edgeMax: number;
-
-    constructor(json?: {
-        azimuthMin?: number;
-        azimuthMax?: number;
-        edgeMin?: number;
-        edgeMax?: number;
-    }) {
-        if (typeof json?.azimuthMin !== 'undefined') this.azimuthMin = json.azimuthMin;
-        if (typeof json?.azimuthMax !== 'undefined') this.azimuthMax = json.azimuthMax;
-        if (typeof json?.edgeMin !== 'undefined') this.edgeMin = json.edgeMin;
-        if (typeof json?.edgeMax !== 'undefined') this.edgeMax = json.edgeMax;
-    }
-
-    protected static min(a: number, b: number): number {
-        if (typeof a === 'undefined') return b;
-        if (typeof b === 'undefined') return a;
-        return Math.min(a, b);
-    }
-
-    protected static max(a: number, b: number): number {
-        if (typeof a === 'undefined') return b;
-        if (typeof b === 'undefined') return a;
-        return Math.max(a, b);
-    }
-
-    merging(polarFilter?: PolarFilter): PolarFilter {
-        return new PolarFilter({
-            azimuthMin: PolarFilter.max(polarFilter?.azimuthMin, this.azimuthMin),
-            azimuthMax: PolarFilter.min(polarFilter?.azimuthMax, this.azimuthMax),
-            edgeMin: PolarFilter.max(polarFilter?.edgeMin, this.edgeMin),
-            edgeMax: PolarFilter.min(polarFilter?.edgeMax, this.edgeMax),
-        });
-    }
-
-    equal(polarFilter: PolarFilter): boolean {
-        return this.azimuthMin === polarFilter.azimuthMin &&
-            this.azimuthMax === polarFilter.azimuthMax &&
-            this.edgeMin === polarFilter.edgeMin &&
-            this.edgeMax === polarFilter.edgeMax;
-    }
-}

package/src/polar/PolarValue.ts

@@ -1,16 +0,0 @@
-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/RainPolarMeasureValue.ts

@@ -1,57 +0,0 @@
-import {IPolarMeasureValue} from './IPolarMeasureValue';
-import {IVersion} from '../organization';
-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: {
-        polarMeasureValue: RainPolarMeasureValue | PolarMeasureValue | string,
-        version?: string
-    }) {
-        super(json);
-
-        if (json.polarMeasureValue instanceof RainPolarMeasureValue) {
-            this.version = json.polarMeasureValue.version;
-            return;
-        }
-
-        this.version = json.version;
-    }
-
-    static From(obj: IPolarMeasureValue | any): RainPolarMeasureValue {
-        let version: string,
-            polarMeasureValue: PolarMeasureValue;
-
-        if (typeof obj.version === 'string') {
-            version = obj.version;
-        }
-
-        if (typeof obj.polarMeasureValue !== 'undefined') {
-            polarMeasureValue = obj.polarMeasureValue;
-        }
-
-        return new RainPolarMeasureValue({polarMeasureValue, version});
-    }
-
-    public toJSON(options = {
-        stringify: false
-    }): any {
-        const json: any = super.toJSON(options);
-        json.version = this.version;
-        return json;
-    }
-
-    public toJSONWithPolarStringified(): any {
-        return this.toJSON({stringify: true});
-    }
-
-    public getVersion(): string {
-        return this.version;
-    }
-}

package/src/quality/history/CartesianGaugeHistory.ts

@@ -1,23 +0,0 @@
-import {CartesianValue} from '../../cartesian/CartesianValue';
-
-export class CartesianGaugeHistory {
-    public gaugeId: string;
-    public gaugeLabel: string;
-    public date: Date;
-    public value: CartesianValue;
-    public configurationAsJSON: string;
-
-    constructor(json: {
-        gaugeId: string,
-        gaugeLabel: string,
-        date: Date,
-        value: CartesianValue,
-        configurationAsJSON: string,
-    }) {
-        this.gaugeId = json.gaugeId;
-        this.gaugeLabel = json.gaugeLabel;
-        this.date = json.date;
-        this.value = json.value;
-        this.configurationAsJSON = json.configurationAsJSON;
-    }
-}

package/src/quality/history/CartesianRainHistory.ts

@@ -1,15 +0,0 @@
-import {CartesianValue} from '../../cartesian';
-
-export class CartesianRainHistory {
-
-    public date: Date;
-    public computedValue: CartesianValue;
-
-    constructor(json: {
-        date: Date,
-        computedValue: CartesianValue
-    }) {
-        this.date = json.date;
-        this.computedValue = json.computedValue;
-    }
-}

package/src/quality/history/PositionHistory.ts

@@ -1,31 +0,0 @@
-import {PositionValue} from '../position/PositionValue';
-
-export class PositionHistory extends PositionValue {
-    public id: string;
-    public label: string;
-    public date: Date;
-    public valueFromGauge: number;
-    public valueFromRain: number;
-    public configurationAsJSON: string;
-
-    constructor(json: {
-        id: string,
-        label: string,
-        date: Date,
-        x: number,
-        y: number,
-        value: number,
-        valueFromGauge?: number,
-        valueFromRain?: number,
-        configurationAsJSON?: string,
-    }) {
-        super(json);
-
-        this.id = json.id;
-        this.label = json.label;
-        this.date = json.date;
-        this.valueFromGauge = json.valueFromGauge;
-        this.valueFromRain = json.valueFromRain;
-        this.configurationAsJSON = json.configurationAsJSON;
-    }
-}

package/src/quality/position/Position.ts

@@ -1,59 +0,0 @@
-export class Position {
-    static DEFAULT_PRECISION = 6;
-    public x: number;
-    public y: number;
-    private readonly precision: number;
-
-    constructor(json: {
-        x: number,
-        y: number
-    }) {
-        this.x = json.x;
-        this.y = json.y;
-        this.precision = Position.DEFAULT_PRECISION;
-    }
-
-    static uniq = (a: Position[]): Position[] => {
-        const set = [];
-        for (const p of a) {
-            const same = set.filter(s => s.x === p.x && s.y === p.y);
-            if (same.length <= 0) {
-                set.push(p);
-            }
-        }
-        return set;
-    }
-
-    setPrecision(precision: number = Position.DEFAULT_PRECISION) {
-        const tenPower = Math.pow(10, precision);
-        const xy = this.getXY(precision);
-        this.x = xy.x;
-        this.y = xy.y;
-    }
-
-    getXY(precision?: number): { x: number, y: number } {
-        if (typeof precision === 'undefined') {
-            return {x: this.x, y: this.y};
-        }
-
-        const tenPower = Math.pow(10, precision);
-        return {
-            x: Math.round(this.x * tenPower) / tenPower,
-            y: Math.round(this.y * tenPower) / tenPower,
-        };
-    }
-
-    samePosition(p: Position, precision?: number) {
-        const xy = this.getXY(precision);
-        return xy.x === p.x && xy.y === p.y;
-    }
-
-    getPrecision(): number {
-        return this.precision;
-    }
-
-    getXYScaled(scale: number): { x: number, y: number } {
-        const precision = Math.round(Math.log10(1 / scale));
-        return this.getXY(precision);
-    }
-}

package/src/quality/position/PositionValue.ts

@@ -1,15 +0,0 @@
-import {Position} from '../position/Position';
-
-
-export class PositionValue extends Position {
-    public value: number;
-
-    constructor(json: {
-        x: number,
-        y: number,
-        value: number
-    }) {
-        super(json);
-        this.value = json.value;
-    }
-}

package/src/radar/RadarMeasure.ts

@@ -1,41 +0,0 @@
-import {Measure} from '../organization';
-import {IPolarMeasureValue} from '../polar';
-import {ICartesianMeasureValue} from '../cartesian';
-import {RadarNode} from './RadarNode';
-
-/**
- *  api/radars/:id/measures/:id
- */
-export class RadarMeasure extends Measure {
-
-    public static TYPE = 'radar-measure';
-
-    constructor(json: {
-                    id: string,
-                    values: IPolarMeasureValue[] | ICartesianMeasureValue[] | number[],
-                    date?: Date,
-                    validity?: number,
-                    configurationAsJSON?: string,
-                    radar?: string,
-                }
-    ) {
-        super(json);
-        if (json.radar) {
-            this.addLinks([new RadarNode({id: json.radar, latitude: NaN, longitude: NaN, team: null, name: null})]);
-        }
-    }
-
-    public toJSON(options?: any): any {
-        const json = super.toJSON(options);
-        const radarLink = this.getLink(RadarNode.TYPE);
-        if (radarLink) {
-            json['radar'] = radarLink.getId();
-        }
-
-        return json;
-    }
-
-    protected getLinkType(): string {
-        return RadarMeasure.TYPE;
-    }
-}

package/src/radar/RadarNode.ts

@@ -1,78 +0,0 @@
-import {Link, RaainNode, TeamNode} from '../organization';
-
-/**
- *  api/radars/:id
- */
-export class RadarNode extends RaainNode {
-
-    public static TYPE = 'radar';
-
-    public name: string;
-    public description: string;
-    public technicalInfos: string;
-    public latitude: number;
-    public longitude: number;
-    public team: TeamNode;
-
-    // internal
-    private configurationAsJSON: string;
-
-    constructor(json: {
-        id: string,
-        latitude: number,
-        longitude: number,
-        name: string,
-        team: TeamNode,
-        description?: string,
-        technicalInfos?: string,
-        links?: Link[] | RaainNode[],
-        version?: string,
-        configurationAsJSON?: any,
-    }) {
-        super(json);
-        this.latitude = json.latitude;
-        this.longitude = json.longitude;
-        this.name = json.name;
-        this.description = json.description;
-        this.technicalInfos = json.technicalInfos;
-        this.team = json.team;
-        this.setConfiguration(json.configurationAsJSON);
-    }
-
-    public toJSON(): any {
-        const json = super.toJSON();
-        json['name'] = this.name;
-        json['description'] = this.description;
-        json['technicalInfos'] = this.technicalInfos;
-        json['latitude'] = this.latitude;
-        json['longitude'] = this.longitude;
-        json['team'] = this.team?.id || this.team;
-        json['configurationAsJSON'] = this.configurationAsJSON;
-        return json;
-    }
-
-    public setConfiguration(configuration: string | any) {
-        let conf = configuration;
-        try {
-            conf = JSON.parse(configuration);
-        } catch (ignored) {
-        }
-
-        if (conf) {
-            this.configurationAsJSON = JSON.stringify(conf);
-        }
-    }
-
-    public getConfiguration(): any {
-        try {
-            return JSON.parse(this.configurationAsJSON);
-        } catch (e) {
-        }
-        return null;
-    }
-
-    protected getLinkType(): string {
-        return RadarNode.TYPE;
-    }
-
-}

package/src/radar/RadarNodeMap.ts

@@ -1,61 +0,0 @@
-import {RadarMeasure} from './RadarMeasure';
-import {RadarNode} from './RadarNode';
-import {Link, RaainNode, TeamNode} from '../organization';
-
-/**
- *  api/radars/:radarId?format=map&...
- */
-export class RadarNodeMap extends RadarNode {
-
-    public date: Date;
-    private map: string; // RadarMeasure[]; stringified
-
-    constructor(json: {
-        id: string,
-        latitude: number,
-        longitude: number,
-        date: Date,
-        map: RadarMeasure[] | string,
-        name: string,
-        description: string,
-        team: TeamNode,
-        links?: Link[] | RaainNode[],
-        version?: string,
-        configurationAsJSON?: any,
-    }) {
-        super(json);
-        this.date = new Date(json.date);
-        this.setMapData(json.map);
-    }
-
-    public toJSON(): any {
-        const json = super.toJSON();
-        if (this.map) {
-            json['map'] = this.map;
-        }
-        json['date'] = this.date.toISOString();
-        return json;
-    }
-
-    public setMapData(mapData: RadarMeasure[] | string) {
-        if (!mapData) {
-            return;
-        }
-
-        let map = mapData;
-        try {
-            if (typeof (mapData) !== 'string') {
-                map = JSON.stringify(mapData);
-            }
-        } catch (e) {
-        }
-        this.map = map.toString();
-    }
-
-    public getMapData(): RadarMeasure[] {
-        if (!this.map) {
-            return [];
-        }
-        return JSON.parse(this.map);
-    }
-}

package/src/rain/MergeStrategy.ts

@@ -1,15 +0,0 @@
-import {LatLng} from '../cartesian';
-
-export enum MergeStrategy {
-    NONE = 'none',
-    SUM = 'sum',
-    AVERAGE = 'average',
-    MAX = 'max',
-}
-
-export interface MergeLatLng {
-    sum: number;
-    max: number;
-    count: number;
-    latLng: LatLng;
-}