raain-model 2.6.7 → 2.6.10

package/{rain/RainComputationQuality.js → src/rain/RainComputationQuality.ts}

@@ -1,75 +1,107 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RainComputationQuality = void 0;
-const RainComputationAbstract_1 = require("./RainComputationAbstract");
-const organization_1 = require("../organization");
-const RainComputation_1 = require("./RainComputation");
+import {RainComputationAbstract} from './RainComputationAbstract';
+import {Link, RaainNode} from '../organization';
+import {SpeedMatrixContainer} from '../quality';
+import {RainComputation} from './RainComputation';
+
+
 /**
  *  api/rains/:id/computations?format=compare&begin=...&gauges=[...]
  */
-class RainComputationQuality extends RainComputationAbstract_1.RainComputationAbstract {
-    constructor(json) {
+export class RainComputationQuality extends RainComputationAbstract {
+
+    public qualitySpeedMatrixContainer: SpeedMatrixContainer;
+    public error: string;
+
+    constructor(json: {
+        id: string,
+        date: Date,
+        isReady: boolean,
+        qualitySpeedMatrixContainer: SpeedMatrixContainer,
+
+        links?: Link[] | RaainNode[],
+        version?: string,
+        quality?: number,
+        progressIngest?: number,
+        progressComputing?: number,
+        timeSpentInMs?: number,
+        isDoneDate?: Date,
+        launchedBy?: string,
+        rain?: Link | RaainNode,
+        radars?: Link[] | RaainNode[],
+        rainComputation?: Link | RaainNode,
+        error?: string,
+    }) {
         super(json);
         this.qualitySpeedMatrixContainer = json.qualitySpeedMatrixContainer;
         this.addRainComputationLink(json.rainComputation);
         this.error = json.error;
     }
-    static _getRainComputationLinks(linkToPurify) {
+
+    private static _getRainComputationLinks(linkToPurify: any): any[] {
         if (!linkToPurify) {
             return [];
         }
-        if (linkToPurify instanceof organization_1.Link) {
+
+        if (linkToPurify instanceof Link) {
             return [linkToPurify];
-        }
-        else if (linkToPurify['_id']) {
-            return [new RainComputation_1.RainComputation({
-                    id: linkToPurify['_id'].toString(),
-                    date: linkToPurify.date,
-                    version: linkToPurify.version,
-                    isReady: true, results: [], // useless
-                })];
-        }
-        else if (linkToPurify.id) {
-            return [new RainComputation_1.RainComputation({
-                    id: linkToPurify.id.toString(),
-                    date: linkToPurify.date,
-                    version: linkToPurify.version,
-                    isReady: true, results: [], // useless
-                })];
+        } else if (linkToPurify['_id']) {
+            return [new RainComputation({
+                id: linkToPurify['_id'].toString(),
+                date: linkToPurify.date,
+                version: linkToPurify.version,
+                isReady: true, results: [], // useless
+            })];
+        } else if (linkToPurify.id) {
+            return [new RainComputation({
+                id: linkToPurify.id.toString(),
+                date: linkToPurify.date,
+                version: linkToPurify.version,
+                isReady: true, results: [], // useless
+            })];
         }
         return [];
     }
-    addRainComputationLink(linkToAdd) {
+
+    public addRainComputationLink(linkToAdd: Link | RaainNode): void {
         this.addLinks(RainComputationQuality._getRainComputationLinks(linkToAdd));
     }
-    merge(rainComputationQuality) {
+
+    merge(rainComputationQuality: RainComputationQuality) {
+
         this.date = this.mergeDateMin(this.date, rainComputationQuality.date);
         this.quality = this.mergeAvg(this.quality, rainComputationQuality.quality);
         this.progressIngest = this.mergeMin(this.progressIngest, rainComputationQuality.progressIngest);
         this.progressComputing = this.mergeMin(this.progressComputing, rainComputationQuality.progressComputing);
         this.timeSpentInMs = this.mergeSum(this.timeSpentInMs, rainComputationQuality.timeSpentInMs);
+
         if (this.qualitySpeedMatrixContainer && this.qualitySpeedMatrixContainer.merge) {
             this.qualitySpeedMatrixContainer = this.qualitySpeedMatrixContainer.merge(rainComputationQuality.qualitySpeedMatrixContainer);
         }
+
     }
-    toJSON(arg) {
+
+    public toJSON(arg?: any): any {
         const json = super.toJSON();
+
         if (this.qualitySpeedMatrixContainer && this.qualitySpeedMatrixContainer.toJSON) {
             json['qualitySpeedMatrixContainer'] = this.qualitySpeedMatrixContainer.toJSON(arg);
-        }
-        else if (this.qualitySpeedMatrixContainer) {
+        } else if (this.qualitySpeedMatrixContainer) {
             json['qualitySpeedMatrixContainer'] = this.qualitySpeedMatrixContainer;
         }
-        const rainComputation = this.getLinkId(RainComputation_1.RainComputation.TYPE);
-        if (rainComputation) {
-            json['rainComputation'] = rainComputation;
+
+        const rainComputationLink = this.getLink(RainComputation.TYPE);
+        if (rainComputationLink) {
+            json['rainComputation'] = rainComputationLink.getId();
         }
+
         if (this.error) {
             json['error'] = this.error;
         }
+
         return json;
     }
-    mergeStillComputed(v1, v2) {
+
+    protected mergeStillComputed(v1: any, v2: any): any {
         if (!v1 && !v2) {
             return undefined;
         }
@@ -81,7 +113,8 @@ class RainComputationQuality extends RainComputationAbstract_1.RainComputationAb
         }
         return null;
     }
-    mergeDateMin(d1, d2) {
+
+    protected mergeDateMin(d1: Date, d2: Date): Date {
         const stillComputed = this.mergeStillComputed(d1, d2);
         if (stillComputed === null) {
             return new Date(Math.min(new Date(d1).getTime(), new Date(d2).getTime()));
@@ -91,7 +124,8 @@ class RainComputationQuality extends RainComputationAbstract_1.RainComputationAb
         }
         return stillComputed;
     }
-    mergeDateMax(d1, d2) {
+
+    protected mergeDateMax(d1: Date, d2: Date): Date {
         const stillComputed = this.mergeStillComputed(d1, d2);
         if (stillComputed === null) {
             return new Date(Math.max(new Date(d1).getTime(), new Date(d2).getTime()));
@@ -101,41 +135,45 @@ class RainComputationQuality extends RainComputationAbstract_1.RainComputationAb
         }
         return stillComputed;
     }
-    mergeAvg(v1, v2) {
+
+    protected mergeAvg(v1: number, v2: number): number {
         const stillComputed = this.mergeStillComputed(v1, v2);
         if (stillComputed === null) {
             return (v1 + v2) / 2;
         }
         return stillComputed;
     }
-    mergeMin(v1, v2) {
+
+    protected mergeMin(v1: number, v2: number): number {
         const stillComputed = this.mergeStillComputed(v1, v2);
         if (stillComputed === null) {
             return Math.min(v1, v2);
         }
         return stillComputed;
     }
-    mergeMax(v1, v2) {
+
+    protected mergeMax(v1: number, v2: number): number {
         const stillComputed = this.mergeStillComputed(v1, v2);
         if (stillComputed === null) {
             return Math.max(v1, v2);
         }
         return stillComputed;
     }
-    mergeSum(v1, v2) {
+
+    protected mergeSum(v1: number, v2: number): number {
         const stillComputed = this.mergeStillComputed(v1, v2);
         if (stillComputed === null) {
             return v1 + v2;
         }
         return stillComputed;
     }
-    mergeConcat(a1, a2) {
+
+    protected mergeConcat(a1: Array<any>, a2: Array<any>): Array<any> {
         const stillComputed = this.mergeStillComputed(a1, a2);
         if (stillComputed === null) {
             return a1.concat(a2);
         }
         return stillComputed;
     }
+
 }
-exports.RainComputationQuality = RainComputationQuality;
-//# sourceMappingURL=RainComputationQuality.js.map

package/src/rain/RainMeasure.ts

@@ -0,0 +1,25 @@
+import {Measure} from '../organization';
+import {IPolarMeasureValue} from '../polar';
+import {ICartesianMeasureValue} from '../cartesian';
+
+/**
+ *  api/rains/:id/computations/:id?format=map => RainComputationMap getMapData() => RainMeasure[]
+ */
+export class RainMeasure extends Measure {
+
+    public static TYPE = 'rain-measure';
+
+    constructor(json: {
+        id: string,
+        values: IPolarMeasureValue[] | ICartesianMeasureValue[] | number[],
+        date?: Date,
+        validity?: number,
+        configurationAsJSON?: string,
+    }) {
+        super(json);
+    }
+
+    protected getLinkType(): string {
+        return RainMeasure.TYPE;
+    }
+}

package/{rain/RainNode.js → src/rain/RainNode.ts}

@@ -1,141 +1,180 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RainNode = void 0;
-const organization_1 = require("../organization");
-const radar_1 = require("../radar");
-const RainComputation_1 = require("./RainComputation");
-const gauge_1 = require("../gauge");
-const cartesian_1 = require("../cartesian");
+import {Link, RaainNode, TeamNode} from '../organization';
+import {RadarNode} from '../radar';
+import {RainComputation} from './RainComputation';
+import {GaugeNode} from '../gauge';
+import {LatLng} from '../cartesian';
+
 /**
  * api/rains/:id
  */
-class RainNode extends organization_1.RaainNode {
-    constructor(json) {
+export class RainNode extends RaainNode {
+
+    public static TYPE = 'rain';
+
+    public name: string;
+    public description: string;
+    public team: TeamNode;
+    public status: number;
+    public quality: number;
+    public latLngRectsAsJSON: string;
+
+    // internal
+    private configurationAsJSON: string;
+
+    constructor(json: {
+        id: string,
+        name: string,
+        team: TeamNode,
+        description?: string,
+        links?: Link[] | RaainNode[],
+        version?: string,
+        status?: number,
+        quality?: number,
+        radars?: RadarNode[],
+        gauges?: GaugeNode[],
+        latLngRectsAsJSON?: string,
+        configurationAsJSON?: any,
+        lastCompletedComputations?: RainComputation[],
+    }) {
         super(json);
-        const links = (json === null || json === void 0 ? void 0 : json.links) ? json.links : [];
+
+        const links = json?.links ? json.links as any[] : [];
+
         this.name = json.name;
         this.description = json.description;
         this.team = json.team;
         this.status = json.status >= 0 ? json.status : -1;
         this.quality = json.quality >= 0 ? json.quality : -1;
         this.latLngRectsAsJSON = json.latLngRectsAsJSON;
-        this.addRadars(links.filter(l => l instanceof radar_1.RadarNode));
+
+        this.addRadars(links.filter(l => l instanceof RadarNode));
         this.addRadars(json.radars);
-        this.addGauges(links.filter(l => l instanceof gauge_1.GaugeNode));
+        this.addGauges(links.filter(l => l instanceof GaugeNode));
         this.addGauges(json.gauges);
         this.setConfiguration(json.configurationAsJSON);
-        this.addCompletedComputations(links.filter(l => l instanceof RainComputation_1.RainComputation));
+        this.addCompletedComputations(links.filter(l => l instanceof RainComputation));
         this.addCompletedComputations(json.lastCompletedComputations);
     }
-    static _getRadarLinks(linksToPurify) {
+
+    private static _getRadarLinks(linksToPurify: any[]): any[] {
         if (!linksToPurify || linksToPurify.length === 0) {
             return [];
         }
+
         const linksPurified = linksToPurify.map(l => {
-            if (l instanceof organization_1.Link) {
+            if (l instanceof Link) {
                 return l;
-            }
-            else if (l && l['_id']) {
-                return new radar_1.RadarNode({ id: l['_id'].toString(), latitude: l.latitude, longitude: l.latitude, name: l.name, team: l.team });
-            }
-            else if (l && l.id) {
-                return new radar_1.RadarNode({ id: l.id.toString(), latitude: l.latitude, longitude: l.longitude, name: l.name, team: l.team });
+            } else if (l && l['_id']) {
+                return new RadarNode({id: l['_id'].toString(), latitude: l.latitude, longitude: l.latitude, name: l.name, team: l.team});
+            } else if (l && l.id) {
+                return new RadarNode({id: l.id.toString(), latitude: l.latitude, longitude: l.longitude, name: l.name, team: l.team});
             }
         });
+
         return linksPurified.filter(l => !!l);
     }
-    static _getRainComputationLinks(linksToPurify) {
+
+    private static _getRainComputationLinks(linksToPurify: any[]): any[] {
         if (!linksToPurify || linksToPurify.length === 0) {
             return [];
         }
+
         const linksPurified = linksToPurify.map(l => {
-            if (l instanceof organization_1.Link) {
+            if (l instanceof Link) {
                 return l;
-            }
-            else if (l && l['_id']) {
-                return new RainComputation_1.RainComputation({
+            } else if (l && l['_id']) {
+                return new RainComputation({
                     id: l['_id'].toString(),
                     date: l.date, version: l.version,
                     isReady: null, results: null,
                 });
-            }
-            else if (l && l.id) {
-                return new RainComputation_1.RainComputation({
+            } else if (l && l.id) {
+                return new RainComputation({
                     id: l.id.toString(),
                     date: l.date, version: l.version,
                     isReady: null, results: null
                 });
             }
         });
+
         return linksPurified.filter(l => !!l);
     }
-    static _getGaugeLinks(linksToPurify) {
+
+    private static _getGaugeLinks(linksToPurify: any[]): any[] {
         if (!linksToPurify || linksToPurify.length === 0) {
             return [];
         }
+
         const linksPurified = linksToPurify.map(l => {
-            if (l instanceof organization_1.Link) {
+            if (l instanceof Link) {
                 return l;
-            }
-            else if (l && l['_id']) {
-                return new gauge_1.GaugeNode({ id: l['_id'].toString(), latitude: l.latitude, longitude: l.longitude, name: l.name, team: l.team });
-            }
-            else if (l && l.id) {
-                return new gauge_1.GaugeNode({ id: l.id.toString(), latitude: l.latitude, longitude: l.longitude, name: l.name, team: l.team });
+            } else if (l && l['_id']) {
+                return new GaugeNode({id: l['_id'].toString(), latitude: l.latitude, longitude: l.longitude, name: l.name, team: l.team});
+            } else if (l && l.id) {
+                return new GaugeNode({id: l.id.toString(), latitude: l.latitude, longitude: l.longitude, name: l.name, team: l.team});
             }
         });
+
         return linksPurified.filter(l => !!l);
     }
-    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;
     }
-    toJSON() {
-        var _a;
+
+    public toJSON(): any {
         const json = super.toJSON();
         json['name'] = this.name;
         json['description'] = this.description;
         json['status'] = this.status;
         json['quality'] = this.quality;
-        json['team'] = ((_a = this.team) === null || _a === void 0 ? void 0 : _a.id) || this.team;
+        json['team'] = this.team?.id || this.team;
         json['latLngRectsAsJSON'] = this.latLngRectsAsJSON;
         json['configurationAsJSON'] = this.configurationAsJSON;
-        json['radars'] = this.getLinks().filter(l => l.getLinkType() === radar_1.RadarNode.TYPE).map(l => l.getId());
-        json['gauges'] = this.getLinks().filter(l => l.getLinkType() === gauge_1.GaugeNode.TYPE).map(l => l.getId());
-        json['lastCompletedComputations'] = this.getLinks().filter(l => l.getLinkType() === RainComputation_1.RainComputation.TYPE).map(l => l.getId());
+        json['radars'] = this.links.filter(l => l.getLinkType() === RadarNode.TYPE).map(l => l.getId());
+        json['gauges'] = this.links.filter(l => l.getLinkType() === GaugeNode.TYPE).map(l => l.getId());
+        json['lastCompletedComputations'] = this.links.filter(l => l.getLinkType() === RainComputation.TYPE).map(l => l.getId());
         return json;
     }
-    addRadars(linksToAdd) {
+
+    public addRadars(linksToAdd: Link[] | RadarNode[]): void {
         this.addLinks(RainNode._getRadarLinks(linksToAdd));
         this.setDefaultLatLng(linksToAdd);
     }
-    addCompletedComputations(linksToAdd) {
+
+    public addCompletedComputations(linksToAdd: Link[] | RainComputation[]): void {
         this.addLinks(RainNode._getRainComputationLinks(linksToAdd));
     }
-    addGauges(linksToAdd) {
+
+    public addGauges(linksToAdd: Link[] | GaugeNode[]): void {
         this.addLinks(RainNode._getGaugeLinks(linksToAdd));
     }
-    getCenter() {
-        let center = new cartesian_1.LatLng({ lat: 0, lng: 0 });
-        this.setDefaultLatLng(this['radars']);
+
+    public getCenter(): LatLng {
+
+        let center = new LatLng({lat: 0, lng: 0});
+
+        this.setDefaultLatLng(this['radars'])
+
         if (this.latLngRectsAsJSON && this.latLngRectsAsJSON !== '[]') {
             const rects = JSON.parse(this.latLngRectsAsJSON);
-            let latMax, lngMax, latMin, lngMin;
+            let latMax: number, lngMax: number, latMin: number, lngMin: number;
             for (const rect of rects) {
                 const topLeft = rect[0];
                 const bottomRight = rect[1];
@@ -144,16 +183,21 @@ class RainNode extends organization_1.RaainNode {
                 latMin = typeof latMin === 'undefined' ? bottomRight.lat : Math.min(bottomRight.lat, latMin);
                 lngMax = typeof lngMax === 'undefined' ? bottomRight.lng : Math.max(bottomRight.lng, lngMax);
             }
-            center = new cartesian_1.LatLng({ lat: ((latMax - latMin) / 2) + latMin, lng: ((lngMax - lngMin) / 2) + lngMin });
+
+            center = new LatLng({lat: ((latMax - latMin) / 2) + latMin, lng: ((lngMax - lngMin) / 2) + lngMin})
         }
+
         return center;
     }
-    getLimitPoints() {
-        let limitPoints;
+
+    public getLimitPoints(): [LatLng, LatLng] {
+        let limitPoints: [LatLng, LatLng];
+
         this.setDefaultLatLng(this['radars']);
+
         if (this.latLngRectsAsJSON && this.latLngRectsAsJSON !== '[]') {
             const rects = JSON.parse(this.latLngRectsAsJSON);
-            let latMax, lngMax, latMin, lngMin;
+            let latMax: number, lngMax: number, latMin: number, lngMin: number;
             for (const rect of rects) {
                 const rectA = rect[0];
                 const rectB = rect[1];
@@ -162,29 +206,30 @@ class RainNode extends organization_1.RaainNode {
                 latMin = Math.min(rectA.lat, rectB.lat, typeof latMin !== 'undefined' ? latMin : rectB.lat);
                 lngMax = Math.max(rectA.lng, rectB.lng, typeof lngMax !== 'undefined' ? lngMax : rectB.lng);
             }
-            limitPoints = [new cartesian_1.LatLng({ lat: latMin, lng: lngMin }), new cartesian_1.LatLng({ lat: latMax, lng: lngMax })];
+
+            limitPoints = [new LatLng({lat: latMin, lng: lngMin}), new LatLng({lat: latMax, lng: lngMax})];
         }
+
         return limitPoints;
     }
-    getLinkType() {
+
+    protected getLinkType(): string {
         return RainNode.TYPE;
     }
-    setDefaultLatLng(radars) {
+
+    private setDefaultLatLng(radars: any[]) {
         // TODO put a default latLngRectsAsJSON based on cartesianTools earth ?
-        if ((radars === null || radars === void 0 ? void 0 : radars.length) && (!this.latLngRectsAsJSON || this.latLngRectsAsJSON === '[]')) {
+        if (radars?.length && (!this.latLngRectsAsJSON || this.latLngRectsAsJSON === '[]')) {
             const latLngRects = [];
             for (const radarNode of radars) {
-                if (radarNode instanceof radar_1.RadarNode) {
+                if (radarNode instanceof RadarNode) {
                     latLngRects.push([
-                        new cartesian_1.LatLng({ lat: radarNode.latitude + 1, lng: radarNode.longitude - 1 }),
-                        new cartesian_1.LatLng({ lat: radarNode.latitude - 1, lng: radarNode.longitude + 1 })
-                    ]);
+                        new LatLng({lat: radarNode.latitude + 1, lng: radarNode.longitude - 1}),
+                        new LatLng({lat: radarNode.latitude - 1, lng: radarNode.longitude + 1})]);
                 }
             }
+
             this.latLngRectsAsJSON = JSON.stringify(latLngRects);
         }
     }
 }
-exports.RainNode = RainNode;
-RainNode.TYPE = 'rain';
-//# sourceMappingURL=RainNode.js.map

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2018",
+    "module": "commonjs",
+    "declaration": true,
+    "sourceMap": true,
+    "outDir": "dist"
+  },
+  "exclude": [
+    "node_modules",
+    "dist",
+    "examples",
+    "specs",
+    "coverage",
+    ".coverage"
+  ]
+}

package/tslint.json

@@ -0,0 +1,79 @@
+{
+  "extends": "tslint:recommended",
+  "rules": {
+    "variable-name": false,
+    "array-type": false,
+    "arrow-parens": false,
+    "deprecation": {
+      "severity": "warn"
+    },
+    "import-blacklist": [
+      true,
+      "rxjs/Rx"
+    ],
+    "interface-name": false,
+    "max-classes-per-file": false,
+    "max-line-length": [
+      true,
+      140
+    ],
+    "member-access": false,
+    "member-ordering": [
+      true,
+      {
+        "order": [
+          "static-field",
+          "instance-field",
+          "static-method",
+          "instance-method"
+        ]
+      }
+    ],
+    "no-consecutive-blank-lines": false,
+    "no-console": [
+      true,
+      "debug",
+      "info",
+      "time",
+      "timeEnd",
+      "trace"
+    ],
+    "no-empty": false,
+    "no-inferrable-types": [
+      true,
+      "ignore-params"
+    ],
+    "no-non-null-assertion": true,
+    "no-redundant-jsdoc": true,
+    "no-switch-case-fall-through": true,
+    "no-use-before-declare": true,
+    "no-var-requires": false,
+    "object-literal-key-quotes": [
+      true,
+      "as-needed"
+    ],
+    "object-literal-sort-keys": false,
+    "ordered-imports": false,
+    "quotemark": [
+      true,
+      "single"
+    ],
+    "trailing-comma": false,
+    "no-output-on-prefix": true,
+    "use-input-property-decorator": true,
+    "use-output-property-decorator": true,
+    "use-host-property-decorator": true,
+    "no-input-rename": true,
+    "no-string-literal": false,
+    "no-output-rename": true,
+    "use-life-cycle-interface": true,
+    "use-pipe-transform-interface": true,
+    "one-variable-per-declaration": false,
+    "component-class-suffix": [
+      true,
+      "Page",
+      "Component"
+    ],
+    "directive-class-suffix": true
+  }
+}

package/typedoc.json

@@ -0,0 +1,31 @@
+{
+  "entryPoints": [
+    "src"
+  ],
+  "out": "docs",
+  "exclude": [
+    "**/*.spec.ts",
+    "**/*.test.ts"
+  ],
+  "excludePrivate": true,
+  "excludeProtected": true,
+  "theme": "default",
+  "name": "RadarToRain Model Documentation",
+  "excludeExternals": true,
+  "hideGenerator": true,
+  "categorizeByGroup": true,
+  "categoryOrder": [
+    "*",
+    "Rain",
+    "Radar",
+    "Cartesian",
+    "Organization",
+    "Polar",
+    "Quality",
+    "Speed"
+  ],
+  "sort": [
+    "source-order"
+  ],
+  "searchInComments": true
+}