raain-model 2.6.8 → 2.6.10

package/src/quality/history/PositionHistory.ts

@@ -0,0 +1,31 @@
+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/{quality/index.d.ts → src/quality/index.ts}

@@ -1,9 +1,12 @@
 export * from './QualityPoint';
 export * from './SpeedMatrix';
 export * from './SpeedMatrixContainer';
+
 export * from './history/CartesianGaugeHistory';
 export * from './history/CartesianRainHistory';
 export * from './history/PositionHistory';
+
 export * from './tools/QualityTools';
+
 export * from './position/Position';
 export * from './position/PositionValue';

package/src/quality/position/Position.ts

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,15 @@
+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/{quality/tools/QualityTools.js → src/quality/tools/QualityTools.ts}

@@ -1,10 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QualityTools = void 0;
-const cartesian_1 = require("../../cartesian");
-const Position_1 = require("../position/Position");
-class QualityTools {
-    static IndexOfDualArray(array, itemToFind) {
+import {LatLng} from '../../cartesian';
+import {Position} from '../position/Position';
+
+export class QualityTools {
+
+    public static IndexOfDualArray(array, itemToFind) {
         for (const [index, value] of array.entries()) {
             if (value[0] === itemToFind[0] && value[1] === itemToFind[1]) {
                 return index;
@@ -12,7 +11,8 @@ class QualityTools {
         }
         return -1;
     }
-    static Precision(a) {
+
+    public static Precision(a) {
         if (!isFinite(a)) {
             return 0;
         }
@@ -23,17 +23,20 @@ class QualityTools {
         }
         return p;
     }
-    static MapLatLngToPosition(latLng) {
+
+    public static MapLatLngToPosition(latLng: LatLng): Position {
         const x = latLng.lng;
         const y = latLng.lat;
-        return new Position_1.Position({ x, y });
+        return new Position({x, y});
     }
-    static MapPositionToLatLng(position) {
+
+    public static MapPositionToLatLng(position: Position): LatLng {
         const lng = position.x;
         const lat = position.y;
-        return new cartesian_1.LatLng({ lat, lng });
+        return new LatLng({lat, lng});
     }
-    static CreateNDimArray(dimensions, defaultValue) {
+
+    public static CreateNDimArray(dimensions: any[], defaultValue?: any): any[] {
         if (dimensions.length > 0) {
             const dim = dimensions[0];
             const rest = dimensions.slice(1);
@@ -45,11 +48,9 @@ class QualityTools {
                 }
             }
             return newArray;
-        }
-        else {
+        } else {
             return undefined;
         }
     }
+
 }
-exports.QualityTools = QualityTools;
-//# sourceMappingURL=QualityTools.js.map

package/src/radar/RadarMeasure.ts

@@ -0,0 +1,41 @@
+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/{radar/RadarNode.js → src/radar/RadarNode.ts}

@@ -1,12 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RadarNode = void 0;
-const organization_1 = require("../organization");
+import {Link, RaainNode, TeamNode} from '../organization';
+
 /**
  *  api/radars/:id
  */
-class RadarNode extends organization_1.RaainNode {
-    constructor(json) {
+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;
@@ -16,41 +38,41 @@ class RadarNode extends organization_1.RaainNode {
         this.team = json.team;
         this.setConfiguration(json.configurationAsJSON);
     }
-    toJSON() {
-        var _a;
+
+    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'] = ((_a = this.team) === null || _a === void 0 ? void 0 : _a.id) || this.team;
+        json['team'] = this.team?.id || this.team;
         json['configurationAsJSON'] = this.configurationAsJSON;
         return json;
     }
-    setConfiguration(configuration) {
+
+    public setConfiguration(configuration: string | any) {
         let conf = configuration;
         try {
             conf = JSON.parse(configuration);
+        } catch (ignored) {
         }
-        catch (ignored) {
-        }
+
         if (conf) {
             this.configurationAsJSON = JSON.stringify(conf);
         }
     }
-    getConfiguration() {
+
+    public getConfiguration(): any {
         try {
             return JSON.parse(this.configurationAsJSON);
-        }
-        catch (e) {
+        } catch (e) {
         }
         return null;
     }
-    getLinkType() {
+
+    protected getLinkType(): string {
         return RadarNode.TYPE;
     }
+
 }
-exports.RadarNode = RadarNode;
-RadarNode.TYPE = 'radar';
-//# sourceMappingURL=RadarNode.js.map

package/src/radar/RadarNodeMap.ts

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,15 @@
+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;
+}

package/src/rain/RainComputation.ts

@@ -0,0 +1,96 @@
+import {Link, RaainNode} from '../organization';
+import {RainPolarMeasureValue} from '../polar';
+import {CartesianTools, LatLng, RainCartesianMeasureValue} from '../cartesian';
+import {RainComputationAbstract} from './RainComputationAbstract';
+import {RainMeasure} from './RainMeasure';
+import {MergeStrategy} from './MergeStrategy';
+
+/**
+ *  api/rains/:rainId/computations/:computationId
+ *  or as an array on
+ *  api/rains/:id/computations?format=id&begin=...
+ */
+export class RainComputation extends RainComputationAbstract {
+
+    public static TYPE = 'rain-computation';
+
+    // why "results" ? because "values" came from Measure.values, "results" came from computation
+    // why array ? because you can have different angle/axis from the Radar
+    public results: RainPolarMeasureValue[] | RainCartesianMeasureValue[];
+
+    constructor(json: {
+        id: string,
+        date: Date,
+        isReady: boolean,
+        results: RainPolarMeasureValue[] | RainCartesianMeasureValue[],
+        links?: Link[] | RaainNode[],
+        version?: string,
+        quality?: number,
+        progressIngest?: number,
+        progressComputing?: number,
+        timeSpentInMs?: number,
+        isDoneDate?: Date,
+        launchedBy?: string,
+        rain?: Link | RaainNode,
+        radars?: Link[] | RaainNode[],
+
+    }) {
+        super(json);
+        this.setResults(json.results);
+    }
+
+    public toJSON(options = {
+        stringify: false
+    }): any {
+        const json = super.toJSON();
+        json['results'] = this.results.map(r => r.toJSON(options));
+        return json;
+    }
+
+    mergeCartesianResults(options: {
+        mergeStrategy: MergeStrategy,
+        mergeLimitPoints: [LatLng, LatLng],
+        cartesianTools: CartesianTools,
+        removeNullValues?: boolean,
+    }): RainMeasure[] {
+
+        this.buildLatLngMatrix(options);
+
+        return this.mergeRainMeasures([new RainMeasure({
+            id: this.id,
+            values: this.results,
+            date: this.date
+        })], options);
+    }
+
+    protected getLinkType(): string {
+        return RainComputation.TYPE;
+    }
+
+    private setResults(results: string[] | RainPolarMeasureValue[] | RainCartesianMeasureValue[]) {
+        if (typeof results === 'string') {
+            results = JSON.parse(results);
+        }
+
+        if (!results || results.length === 0 || !Array.isArray(results)) {
+            this.results = [];
+            return;
+        }
+
+        this.results = results.map(r => {
+            if (typeof r === 'string' && r.indexOf('polarMeasureValue') >= 0) {
+                return new RainPolarMeasureValue(JSON.parse(r));
+            } else if (r.polarMeasureValue) {
+                return new RainPolarMeasureValue(r);
+            }
+            if (typeof r === 'string' && r.indexOf('cartesian') >= 0) {
+                return new RainCartesianMeasureValue(JSON.parse(r));
+            } else if (r.cartesianValues) {
+                return new RainCartesianMeasureValue(r);
+            } else {
+                return r;
+            }
+        });
+    }
+
+}