raain-model 2.6.10 → 2.6.11

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/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/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;
-}

package/src/rain/RainComputation.ts

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

package/src/rain/RainMeasure.ts

@@ -1,25 +0,0 @@
-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/tsconfig.json

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

package/tslint.json

@@ -1,79 +0,0 @@
-{
-  "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
-  }
-}