raain-model 1.10.25 → 1.11.4

package/{quality/tools/QualityTools.js → src/quality/tools/QualityTools.ts}

@@ -1,10 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QualityTools = void 0;
-const LatLng_1 = require("../../cartesian/LatLng");
-const Position_1 = require("../position/Position");
-class QualityTools {
-    static IndexOfDualArray(array, itemToFind) {
+import {LatLng} from '../../cartesian/LatLng';
+import {Position} from '../position/Position';
+import {CartesianValue} from '../../cartesian/CartesianValue';
+
+export class QualityTools {
+
+    // scale of Pixel regarding LatLng : 1 => 100km, 0.01 => 1km, 0.005 => 500m
+    public static DEFAULT_SCALE = 0.01;
+
+    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 +15,8 @@ class QualityTools {
         }
         return -1;
     }
-    static Precision(a) {
+
+    public static Precision(a) {
         if (!isFinite(a)) {
             return 0;
         }
@@ -23,12 +27,15 @@ class QualityTools {
         }
         return p;
     }
-    static RoundLatLng(latOrLng, scale = QualityTools.DEFAULT_SCALE, needPrecision = false) {
+
+    public static RoundLatLng(latOrLng: number, scale = QualityTools.DEFAULT_SCALE, needPrecision = false): number {
+
         const result = Math.round(latOrLng / scale) * scale;
         if (!needPrecision) {
             return result;
         }
         return parseFloat(parseFloat('' + result).toPrecision(12));
+
         // alternative ?
         // let decimalPlaces = 0;
         // if (('' + scale).indexOf('0.') === 0) {
@@ -40,15 +47,21 @@ class QualityTools {
         // const n = (latOrLng * p) * (1 + Number.EPSILON);
         // return Math.round(n) / p;
     }
-    static LimitWithPrecision(latOrLng, precision = 12) {
+
+    public static LimitWithPrecision(latOrLng: number, precision = 12): number {
         return parseFloat(parseFloat('' + latOrLng).toPrecision(precision));
     }
-    static IsEqualsLatLng(latOrLng1, latOrLng2, cartesianStep = QualityTools.DEFAULT_SCALE) {
+
+    public static IsEqualsLatLng(latOrLng1: number, latOrLng2: number, cartesianStep = QualityTools.DEFAULT_SCALE): boolean {
         return QualityTools.RoundLatLng(latOrLng1, cartesianStep, true) === QualityTools.RoundLatLng(latOrLng2, cartesianStep, true);
     }
-    static IsAroundLatLng(latLngCenter, latLngAround, stepRange, cartesianStep = QualityTools.DEFAULT_SCALE) {
+
+    public static IsAroundLatLng(latLngCenter: LatLng, latLngAround: LatLng, stepRange: number,
+                                 cartesianStep = QualityTools.DEFAULT_SCALE): boolean {
+
         let isAround = false;
-        const min = -stepRange * cartesianStep, max = stepRange * cartesianStep;
+        const min = -stepRange * cartesianStep,
+            max = stepRange * cartesianStep;
         for (let lat = min; !isAround && lat <= max; lat += cartesianStep) {
             for (let lng = min; !isAround && lng <= max; lng += cartesianStep) {
                 isAround = QualityTools.RoundLatLng(latLngCenter.lat, cartesianStep, true)
@@ -59,23 +72,30 @@ class QualityTools {
                 }
             }
         }
+
         return isAround;
     }
-    static IsNotAroundLatLng(latLngCenter, latLngAround, stepRange, cartesianStep = QualityTools.DEFAULT_SCALE) {
+
+    public static IsNotAroundLatLng(latLngCenter: LatLng, latLngAround: LatLng, stepRange: number,
+                                    cartesianStep = QualityTools.DEFAULT_SCALE): boolean {
+
         const max = (stepRange * cartesianStep) + Number.EPSILON;
+
         let isOut = QualityTools.RoundLatLng(latLngCenter.lat, cartesianStep)
             > QualityTools.RoundLatLng(latLngAround.lat + max, cartesianStep)
             || QualityTools.RoundLatLng(latLngCenter.lat, cartesianStep)
-                < QualityTools.RoundLatLng(latLngAround.lat - max, cartesianStep);
+            < QualityTools.RoundLatLng(latLngAround.lat - max, cartesianStep);
         if (!isOut) {
             isOut = QualityTools.RoundLatLng(latLngCenter.lng, cartesianStep)
                 > QualityTools.RoundLatLng(latLngAround.lng + max, cartesianStep)
                 || QualityTools.RoundLatLng(latLngCenter.lng, cartesianStep)
-                    < QualityTools.RoundLatLng(latLngAround.lng - max, cartesianStep);
+                < QualityTools.RoundLatLng(latLngAround.lng - max, cartesianStep);
         }
+
         return isOut;
     }
-    static MapLatLngToPosition(latLng, rounded, cartesianPixelWidth) {
+
+    public static MapLatLngToPosition(latLng: LatLng, rounded?: boolean, cartesianPixelWidth?: LatLng): Position {
         let x = latLng.lng;
         let y = latLng.lat;
         if (rounded) {
@@ -85,46 +105,57 @@ class QualityTools {
             x = QualityTools.RoundLatLng(x, cartesianPixelWidth.lng, true);
             y = QualityTools.RoundLatLng(y, cartesianPixelWidth.lat, true);
         }
-        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 LatLng_1.LatLng({ lat, lng });
+        return new LatLng({lat, lng});
     }
-    static DegToRad(azimuthInDegrees) {
+
+    public static DegToRad(azimuthInDegrees: number) {
         return azimuthInDegrees * Math.PI / 180;
     }
-    static GetAzimuthRad(angleInDegrees) {
+
+    public static GetAzimuthRad(angleInDegrees: number): number {
         return QualityTools.DegToRad(-angleInDegrees + 90);
     }
-    static ComputeLatSteps(cartesianValues) {
+
+    public static ComputeLatSteps(cartesianValues: CartesianValue[]): number[] {
         const lats = cartesianValues.map(c => c.lat).sort((a, b) => a - b);
         return QualityTools.UniqNum(lats);
     }
-    static ComputeLngSteps(cartesianValues) {
+
+    public static ComputeLngSteps(cartesianValues: CartesianValue[]): number[] {
         const lngs = cartesianValues.map(c => c.lng).sort((a, b) => a - b);
         return QualityTools.UniqNum(lngs);
     }
-    static LogCartesianValues(cartesianValues) {
-        console.log('>> raain-quality ### logCartesianValues with', cartesianValues.length, QualityTools.DEFAULT_SCALE, ' in progress...');
+
+    public static LogCartesianValues(cartesianValues: CartesianValue[]) {
+        console.log('>> raain-quality ### logCartesianValues with', cartesianValues.length,
+            QualityTools.DEFAULT_SCALE, ' in progress...');
         const pointsToShow = {};
         const latSteps = QualityTools.ComputeLatSteps(cartesianValues);
         const lngSteps = QualityTools.ComputeLngSteps(cartesianValues);
         // console.log('>> raain-quality ### logCartesianValues latSteps:', latSteps, 'lngSteps:', lngSteps);
-        const labelX = (v) => {
-            return QualityTools.LabelWithSign(v);
-        };
-        const labelY = (v) => {
-            return QualityTools.LabelWithSign(v);
-        };
+
+        const labelX = (v: number) => {
+            return QualityTools.LabelWithSign(v)
+        }
+        const labelY = (v: number) => {
+            return QualityTools.LabelWithSign(v)
+        }
         const valueDisplay = (v) => {
             return '' + Math.round(v * 100) / 100;
-        };
+        }
+
         for (let lat of latSteps) {
             const xObject = {};
             for (let lng of lngSteps) {
-                const latLng = new LatLng_1.LatLng({ lat, lng });
+
+                const latLng = new LatLng({lat, lng});
                 latLng.setPrecision(12);
                 lat = latLng.lat;
                 lng = latLng.lng;
@@ -132,22 +163,28 @@ class QualityTools {
             }
             pointsToShow[labelY(lat)] = xObject;
         }
+
         for (const [index, point] of cartesianValues.entries()) {
-            let value = valueDisplay(point.value);
+            let value = valueDisplay(point.value)
             if (pointsToShow[labelY(point.lat)][labelX(point.lng)] !== '0') {
                 value = '' + value + '?' + pointsToShow[labelY(point.lat)][labelX(point.lng)];
             }
+
             pointsToShow[labelY(point.lat)][labelX(point.lng)] = value;
         }
+
         console.table(pointsToShow);
     }
-    static UniqNum(a) {
+
+    public static UniqNum(a: number[]) {
         return [...new Set(a)];
     }
-    static UniqStr(a) {
+
+    public static UniqStr(a: number[]) {
         return [...new Set(a)];
     }
-    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);
@@ -159,24 +196,20 @@ class QualityTools {
                 }
             }
             return newArray;
-        }
-        else {
+        } else {
             return undefined;
         }
-    }
-    ;
-    static LabelWithSign(val) {
+    };
+
+    protected static LabelWithSign(val: number) {
         const value = val;
         if (value < 0) {
             return '' + value;
-        }
-        else if (value === 0) {
+        } else if (value === 0) {
             return ' ' + 0;
         }
         return '+' + value;
     }
+
+
 }
-// scale of Pixel regarding LatLng : 1 => 100km, 0.01 => 1km, 0.005 => 500m
-QualityTools.DEFAULT_SCALE = 0.01;
-exports.QualityTools = QualityTools;
-//# sourceMappingURL=QualityTools.js.map

package/src/radar/RadarMeasure.ts

@@ -0,0 +1,27 @@
+import {Measure} from '../organization/Measure';
+import {IPolarMeasureValue} from '../polar/IPolarMeasureValue';
+import {ICartesianMeasureValue} from '../cartesian/ICartesianMeasureValue';
+
+/**
+ *  api/radars/:id/measures/:id
+ */
+export class RadarMeasure extends Measure {
+
+    public static TYPE = 'radar-measure';
+
+    constructor(json: {
+                    id: string,
+                    values: IPolarMeasureValue[] | ICartesianMeasureValue[] | Measure[] | number[],
+                    date?: Date,
+                    validity?: number,
+                    configurationAsJSON?: string | any,
+                }
+    ) {
+        super(json);
+    }
+
+    protected getLinkType(): string {
+        return RadarMeasure.TYPE;
+    }
+}
+

package/src/radar/RadarNode.ts

@@ -0,0 +1,46 @@
+import {RaainNode} from '../organization/RaainNode';
+import {Link} from '../organization/Link';
+import {TeamNode} from '../organization/TeamNode';
+
+/**
+ *  api/radars/:id
+ */
+export class RadarNode extends RaainNode {
+
+    public static TYPE = 'radar';
+
+    public name: string;
+    public latitude: number;
+    public longitude: number;
+    public team: TeamNode;
+
+    constructor(json: {
+        id: string,
+        latitude: number,
+        longitude: number,
+        name?: string,
+        links?: Link[] | RaainNode[],
+        team?: TeamNode,
+        version?: string,
+    }) {
+        super(json);
+        this.latitude = json.latitude;
+        this.longitude = json.longitude;
+        this.name = json.name;
+        this.team = json.team;
+    }
+
+    public toJSON(): JSON {
+        const json = super.toJSON();
+        json['name'] = this.name;
+        json['latitude'] = this.latitude;
+        json['longitude'] = this.longitude;
+        json['team'] = this.team?.id || this.team;
+        return json;
+    }
+
+    protected getLinkType(): string {
+        return RadarNode.TYPE;
+    }
+
+}

package/src/radar/RadarNodeMap.ts

@@ -0,0 +1,65 @@
+import {RadarMeasure} from './RadarMeasure';
+import {RadarNode} from './RadarNode';
+import {Link} from '../organization/Link';
+import {RaainNode} from '../organization/RaainNode';
+import {TeamNode} from '../organization/TeamNode';
+
+/**
+ *  api/radars/:radarId?format=map&...
+ */
+export class RadarNodeMap extends RadarNode {
+
+    public periodBegin: Date;
+    public periodEnd: Date;
+    private map: string; // RadarMeasure[]; stringified
+
+    constructor(json: {
+        id: string,
+        latitude: number,
+        longitude: number,
+        periodBegin: Date,
+        periodEnd: Date,
+        map: RadarMeasure[] | string,
+        name?: string,
+        links?: Link[] | RaainNode[],
+        team?: TeamNode,
+        version?: string,
+    }) {
+        super(json);
+        this.periodBegin = new Date(json.periodBegin);
+        this.periodEnd = new Date(json.periodEnd);
+        this.setMapData(json.map);
+    }
+
+    public toJSON(): JSON {
+        const json = super.toJSON();
+        if (this.map) {
+            json['map'] = this.map;
+        }
+        json['periodBegin'] = this.periodBegin.toISOString();
+        json['periodEnd'] = this.periodEnd.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/RainComputation.ts

@@ -0,0 +1,82 @@
+import {RaainNode} from '../organization/RaainNode';
+import {Link} from '../organization/Link';
+import {RainPolarMeasureValue} from '../polar/RainPolarMeasureValue';
+import {RainCartesianMeasureValue} from '../cartesian/RainCartesianMeasureValue';
+import {RainComputationAbstract} from './RainComputationAbstract';
+
+/**
+ *  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 array ? because you can have different angle from the Radar
+    public results: RainPolarMeasureValue[] | RainCartesianMeasureValue[];
+
+    // not "values" (aka Measure.values), but "results" from computation
+
+    constructor(json: {
+        id: string,
+        periodBegin: Date,
+        periodEnd: Date,
+        isReady: boolean,
+
+        results: RainPolarMeasureValue[] | RainCartesianMeasureValue[],
+
+        links?: Link[] | RaainNode[],
+        version?: string,
+        quality?: number,
+        progressIngest?: number,
+        progressComputing?: number,
+        timeSpentInMs?: number,
+        isDoneDate?: Date,
+        launchedBy?: string,
+        rain?: RaainNode[],
+        radars?: Link[] | RaainNode[],
+
+    }) {
+        super(json);
+        this.setResults(json.results);
+    }
+
+    public toJSON(stringify = false): JSON {
+        const json = super.toJSON();
+        json['results'] = this.results.map(r => r.toJSON(stringify));
+        return json;
+    }
+
+    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('polars') >= 0) {
+                return new RainPolarMeasureValue(JSON.parse(r));
+            } else if (r.polars) {
+                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;
+            }
+        });
+    }
+
+}
+

package/src/rain/RainComputationAbstract.ts

@@ -0,0 +1,137 @@
+import {RaainNode} from '../organization/RaainNode';
+import {Link} from '../organization/Link';
+import {RadarNode} from '../radar/RadarNode';
+import {RainNode} from './RainNode';
+import {RadarMeasure} from '../radar/RadarMeasure';
+
+/**
+ *  not used directly
+ */
+export class RainComputationAbstract extends RaainNode {
+
+    public quality: number;
+    public progressIngest: number;
+    public progressComputing: number;
+    public timeSpentInMs: number;
+    public periodBegin: Date;
+    public periodEnd: Date;
+    public isReady: boolean;
+    public isDoneDate: Date;
+    public launchedBy: string;
+    public name: string;
+
+    constructor(json: {
+        id: string,
+        periodBegin: Date,
+        periodEnd: Date,
+        isReady: boolean,
+
+        links?: Link[] | RaainNode[],
+        version?: string,
+        quality?: number,
+        progressIngest?: number,
+        progressComputing?: number,
+        timeSpentInMs?: number,
+        isDoneDate?: Date,
+        launchedBy?: string,
+        rain?: RaainNode[],
+        radars?: Link[] | RaainNode[],
+
+    }) {
+        super(json);
+
+        this.periodBegin = new Date(json.periodBegin);
+        this.periodEnd = new Date(json.periodEnd);
+        this.quality = json.quality >= 0 ? json.quality : -1;
+        this.progressIngest = json.progressIngest >= 0 ? json.progressIngest : -1;
+        this.progressComputing = json.progressComputing >= 0 ? json.progressComputing : -1;
+        this.timeSpentInMs = json.timeSpentInMs;
+        this.isReady = !!json.isReady;
+        this.isDoneDate = json.isDoneDate ? new Date(json.isDoneDate) : undefined;
+        this.launchedBy = json.launchedBy;
+
+        this.replaceRainLink(json.links);
+        this.replaceRainLink(json.rain);
+        this.addRadarLinks(json.links);
+        this.addRadarLinks(json.radars);
+    }
+
+    private static _getRadarLinks(linksToPurify: any[]): any[] {
+        if (!linksToPurify || linksToPurify.length === 0) {
+            return [];
+        }
+
+        return linksToPurify.map(l => {
+            if (l instanceof Link) {
+                return l;
+            } else if (l && l['_id']) {
+                return new RadarNode({id: l['_id'].toString(), latitude: 0, longitude: 0});
+            } else if (l && l.id) {
+                return new RadarNode({
+                    id: l.id.toString(),// 'hex'
+                    latitude: 0, longitude: 0
+                });
+            }
+        });
+    }
+
+    private static _getRadarMeasureLinks(linksToPurify: any[]): any[] {
+        if (!linksToPurify || linksToPurify.length === 0) {
+            return [];
+        }
+
+        return linksToPurify.map(l => {
+            if (l instanceof Link) {
+                return l;
+            } else if (l && l['_id']) {
+                return new RadarMeasure({id: l['_id'].toString(), values: []});
+            } else if (l && l.id) {
+                return new RadarMeasure({id: l.id.toString(), values: []}); // 'hex'
+            }
+        });
+    }
+
+    private static _getRainLink(linkToPurify: RaainNode): RainNode {
+        if (!linkToPurify || !linkToPurify.id) {
+            return null;
+        }
+
+        return new RainNode({
+            id: linkToPurify.id.toString(), // 'hex'
+            latitude: 0, longitude: 0
+        });
+    }
+
+    public toJSON(): JSON {
+        const json = super.toJSON();
+        json['periodBegin'] = this.periodBegin.toISOString();
+        json['periodEnd'] = this.periodEnd.toISOString();
+        json['quality'] = this.quality;
+        json['progressIngest'] = this.progressIngest;
+        json['progressComputing'] = this.progressComputing;
+        json['timeSpentInMs'] = this.timeSpentInMs;
+        json['isReady'] = this.isReady;
+        json['isDoneDate'] = this.isDoneDate?.toISOString();
+        json['launchedBy'] = this.launchedBy;
+        json['name'] = this.name;
+        return json;
+    }
+
+    public addRadarLinks(linksToAdd: Link[] | RaainNode[]): void {
+        this.addLinks(RainComputationAbstract._getRadarLinks(linksToAdd));
+    }
+
+    public replaceRainLink(linksToAdd: Link | RaainNode | any): void {
+        this.addLinks([RainComputationAbstract._getRainLink(linksToAdd)]);
+    }
+
+    public addRadarMeasureLinks(linksToAdd: Link[] | any[]): void {
+        this.addLinks(RainComputationAbstract._getRadarMeasureLinks(linksToAdd));
+    }
+
+    protected getLinkType(): string {
+        throw Error('abstract');
+    }
+
+}
+

package/src/rain/RainComputationMap.ts

@@ -0,0 +1,68 @@
+import {RainComputationAbstract} from './RainComputationAbstract';
+import {Link} from '../organization/Link';
+import {RainMeasure} from './RainMeasure';
+import {RaainNode} from '../organization/RaainNode';
+
+/**
+ *  api/rains/:id/computations/:computationId?format=map&...
+ *  or with
+ *  api/rains/:id/computations?format=map&begin=...
+ */
+export class RainComputationMap extends RainComputationAbstract {
+
+    private map: string; // RainMeasure[]; stringified
+
+    constructor(json: {
+        id: string,
+        periodBegin: Date,
+        periodEnd: Date,
+        isReady: boolean,
+
+        map: RainMeasure[] | string,
+
+        links?: Link[] | RaainNode[],
+        version?: string,
+        quality?: number,
+        progressIngest?: number,
+        progressComputing?: number,
+        timeSpentInMs?: number,
+        isDoneDate?: Date,
+        launchedBy?: string,
+        rain?: RaainNode[],
+        radars?: Link[] | RaainNode[],
+    }) {
+        super(json);
+        this.setMapData(json.map);
+    }
+
+    public toJSON(): JSON {
+        const json = super.toJSON();
+        if (this.map) {
+            json['map'] = this.map;
+            delete json['results'];
+        }
+        return json;
+    }
+
+    public setMapData(mapData: RainMeasure[] | string) {
+        if (!mapData) {
+            return;
+        }
+
+        let map = mapData;
+        try {
+            if (typeof (mapData) !== 'string') {
+                map = JSON.stringify(mapData);
+            }
+        } catch (e) {
+        }
+        this.map = map.toString();
+    }
+
+    public getMapData(): RainMeasure[] {
+        if (!this.map) {
+            return [];
+        }
+        return JSON.parse(this.map);
+    }
+}