raain-model 2.6.10 → 3.0.1

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/RainComputationAbstract.ts

@@ -1,262 +0,0 @@
-import {Link, RaainNode} from '../organization';
-import {RadarMeasure, RadarNode} from '../radar';
-import {RainNode} from './RainNode';
-import {CartesianMeasureValue, CartesianTools, CartesianValue, LatLng, RainCartesianMeasureValue} from '../cartesian';
-import {RainMeasure} from './RainMeasure';
-import {MergeLatLng, MergeStrategy} from './MergeStrategy';
-
-/**
- *  not used directly
- */
-export class RainComputationAbstract extends RaainNode {
-
-    public quality: number;
-    public progressIngest: number;
-    public progressComputing: number;
-    public timeSpentInMs: number;
-    public date: Date;
-    public isReady: boolean;
-    public isDoneDate: Date;
-    public launchedBy: string;
-    public name: string;
-
-    protected mergeTools: {
-        cartesianTools: CartesianTools;
-        latsLngs: MergeLatLng[][];
-        limitPoints: LatLng[];
-    };
-
-    constructor(json: {
-        id: string,
-        date: Date,
-        isReady: boolean,
-
-        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.date = json.date ? new Date(json.date) : null;
-        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, name: l.name, team: l.team});
-            } else if (l && l.id) {
-                return new RadarNode({
-                    id: l.id.toString(),// 'hex'
-                    latitude: 0, longitude: 0, name: l.name, team: l.team
-                });
-            }
-        });
-    }
-
-    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(),
-            name: linkToPurify.id.toString(),
-            team: null
-        });
-    }
-
-    public toJSON(): any {
-        const json = super.toJSON();
-        json['date'] = this.date.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));
-    }
-
-    public getBuiltMergeTools(rainMeasures: RainMeasure[], options: {
-        cartesianTools: CartesianTools,
-        mergeLimitPoints: LatLng[]
-    }) {
-        this.buildLatLngMatrix(options);
-        this.buildMergeTools(rainMeasures);
-        return this.mergeTools;
-    }
-
-    public getMergeLatLngIndex(cartesianValue: CartesianValue) {
-
-        const latLng = this.mergeTools.cartesianTools.getLatLngFromEarthMap(cartesianValue);
-        const latLngScale = this.mergeTools.cartesianTools.getScaleLatLngFromEarth(latLng);
-
-        const latIndex = Math.round((latLng.lat - this.mergeTools.limitPoints[0].lat) / latLngScale.lat);
-        const lngIndex = Math.round((latLng.lng - this.mergeTools.limitPoints[0].lng) / latLngScale.lng);
-
-        return {index: [latIndex, lngIndex], latLng};
-    }
-
-    protected buildLatLngMatrix(options: {
-        cartesianTools: CartesianTools,
-        mergeLimitPoints: LatLng[]
-    }) {
-        const latsLngs: MergeLatLng[][] = [];
-        this.mergeTools = {latsLngs, cartesianTools: options.cartesianTools, limitPoints: []};
-        if (!options.mergeLimitPoints) {
-            return this.mergeTools;
-        }
-
-        const downPoint = options.cartesianTools.getLatLngFromEarthMap(options.mergeLimitPoints[0]);
-        const topPoint = options.cartesianTools.getLatLngFromEarthMap(options.mergeLimitPoints[1]);
-        const scaleLat = options.cartesianTools.getScaleLatLng(downPoint);
-
-        for (let lat = downPoint.lat; lat <= topPoint.lat; lat += scaleLat.lat) {
-            lat = CartesianTools.LimitWithPrecision(lat);
-            const latLng = new LatLng({lat, lng: downPoint.lng});
-            const scaleLng = options.cartesianTools.getScaleLatLng(latLng);
-            const lngCount = Math.round((topPoint.lng - downPoint.lng) / scaleLng.lng) + 1;
-            const lngs = [];
-            for (let i = 0; i < lngCount; i++) {
-                const initValue: MergeLatLng = {sum: 0, max: 0, count: 0, latLng: undefined};
-                lngs.push(initValue);
-            }
-            latsLngs.push(lngs);
-        }
-
-        this.mergeTools = {latsLngs, cartesianTools: options.cartesianTools, limitPoints: [downPoint, topPoint]};
-        return this.mergeTools;
-    }
-
-    protected buildMergeTools(rainMeasures: RainMeasure[]) {
-        for (const rainMeasure of rainMeasures) {
-            for (const value of rainMeasure.values) {
-                if (typeof value['cartesianValues'] !== 'undefined') {
-                    const cartesianMeasureValue = new CartesianMeasureValue(value as any);
-                    const cartesianValues = cartesianMeasureValue.getCartesianValues();
-                    for (const cartesianValue of cartesianValues) {
-                        const {index, latLng} = this.getMergeLatLngIndex(cartesianValue);
-                        if (index[0] >= 0 && index[1] >= 0 && index[0] < this.mergeTools.latsLngs.length &&
-                            index[1] < this.mergeTools.latsLngs[index[0]].length) {
-                            this.mergeTools.latsLngs[index[0]][index[1]].latLng = CartesianTools.CreateLatLng(latLng);
-                            this.mergeTools.latsLngs[index[0]][index[1]].sum += cartesianValue.value;
-                            this.mergeTools.latsLngs[index[0]][index[1]].max = Math.max(
-                                cartesianValue.value, this.mergeTools.latsLngs[index[0]][index[1]].max);
-                            this.mergeTools.latsLngs[index[0]][index[1]].count++;
-                        } else {
-                            // throw new Error(`Wrong mergeRainMeasure ${latLngIndex[0]} ${latLngIndex[1]}`);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    protected getLinkType(): string {
-        throw Error('abstract');
-    }
-
-    protected mergeRainMeasures(rainMeasures: RainMeasure[],
-                                options: {
-                                    mergeStrategy: MergeStrategy,
-                                    mergeLimitPoints: [LatLng, LatLng],
-                                    removeNullValues?: boolean,
-                                }): RainMeasure[] {
-
-        if (rainMeasures.length === 0) {
-            return [];
-        }
-
-        this.buildMergeTools(rainMeasures);
-
-        const firstCartesianRainMeasure = rainMeasures[0];
-        const cartesianValuesMerged = this.buildMergeCartesianValues(options.mergeStrategy, options.removeNullValues);
-
-        const rm = new RainMeasure(firstCartesianRainMeasure.toJSON());
-        rm.values = [new RainCartesianMeasureValue({
-            cartesianValues: cartesianValuesMerged,
-            version: firstCartesianRainMeasure.getVersion(),
-            limitPoints: options.mergeLimitPoints,
-        })];
-
-        return [rm];
-    }
-
-    protected buildMergeCartesianValues(mergeStrategy: MergeStrategy, removeNullValues = false) {
-        const cartesianValuesMerged: CartesianValue[] = [];
-        for (const [latIndex, latValues] of this.mergeTools.latsLngs.entries()) {
-            for (const [lngIndex, mergeValue] of latValues.entries()) {
-                let value = mergeValue.sum;
-                if (mergeStrategy === MergeStrategy.AVERAGE) {
-                    value = mergeValue.count ? value / mergeValue.count : -1;
-                } else if (mergeStrategy === MergeStrategy.MAX) {
-                    value = mergeValue.max;
-                }
-
-                if (mergeValue.count && !(removeNullValues && !value)) {
-                    const lat = mergeValue.latLng.lat;
-                    const lng = mergeValue.latLng.lng;
-                    cartesianValuesMerged.push(new CartesianValue({value, lat, lng}));
-                }
-            }
-        }
-        return cartesianValuesMerged;
-    }
-
-}

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/src/rain/RainNode.ts

@@ -1,235 +0,0 @@
-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
- */
-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?.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 RadarNode));
-        this.addRadars(json.radars);
-        this.addGauges(links.filter(l => l instanceof GaugeNode));
-        this.addGauges(json.gauges);
-        this.setConfiguration(json.configurationAsJSON);
-        this.addCompletedComputations(links.filter(l => l instanceof RainComputation));
-        this.addCompletedComputations(json.lastCompletedComputations);
-    }
-
-    private static _getRadarLinks(linksToPurify: any[]): any[] {
-        if (!linksToPurify || linksToPurify.length === 0) {
-            return [];
-        }
-
-        const linksPurified = linksToPurify.map(l => {
-            if (l instanceof Link) {
-                return l;
-            } 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);
-    }
-
-    private static _getRainComputationLinks(linksToPurify: any[]): any[] {
-        if (!linksToPurify || linksToPurify.length === 0) {
-            return [];
-        }
-
-        const linksPurified = linksToPurify.map(l => {
-            if (l instanceof Link) {
-                return l;
-            } 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({
-                    id: l.id.toString(),
-                    date: l.date, version: l.version,
-                    isReady: null, results: null
-                });
-            }
-        });
-
-        return linksPurified.filter(l => !!l);
-    }
-
-    private static _getGaugeLinks(linksToPurify: any[]): any[] {
-        if (!linksToPurify || linksToPurify.length === 0) {
-            return [];
-        }
-
-        const linksPurified = linksToPurify.map(l => {
-            if (l instanceof Link) {
-                return l;
-            } 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);
-    }
-
-    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;
-    }
-
-    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'] = this.team?.id || this.team;
-        json['latLngRectsAsJSON'] = this.latLngRectsAsJSON;
-        json['configurationAsJSON'] = this.configurationAsJSON;
-        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;
-    }
-
-    public addRadars(linksToAdd: Link[] | RadarNode[]): void {
-        this.addLinks(RainNode._getRadarLinks(linksToAdd));
-        this.setDefaultLatLng(linksToAdd);
-    }
-
-    public addCompletedComputations(linksToAdd: Link[] | RainComputation[]): void {
-        this.addLinks(RainNode._getRainComputationLinks(linksToAdd));
-    }
-
-    public addGauges(linksToAdd: Link[] | GaugeNode[]): void {
-        this.addLinks(RainNode._getGaugeLinks(linksToAdd));
-    }
-
-    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: number, lngMax: number, latMin: number, lngMin: number;
-            for (const rect of rects) {
-                const topLeft = rect[0];
-                const bottomRight = rect[1];
-                latMax = typeof latMax === 'undefined' ? topLeft.lat : Math.max(topLeft.lat, latMax);
-                lngMin = typeof lngMin === 'undefined' ? topLeft.lng : Math.min(topLeft.lng, lngMin);
-                latMin = typeof latMin === 'undefined' ? bottomRight.lat : Math.min(bottomRight.lat, latMin);
-                lngMax = typeof lngMax === 'undefined' ? bottomRight.lng : Math.max(bottomRight.lng, lngMax);
-            }
-
-            center = new LatLng({lat: ((latMax - latMin) / 2) + latMin, lng: ((lngMax - lngMin) / 2) + lngMin})
-        }
-
-        return center;
-    }
-
-    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: number, lngMax: number, latMin: number, lngMin: number;
-            for (const rect of rects) {
-                const rectA = rect[0];
-                const rectB = rect[1];
-                latMax = Math.max(rectA.lat, rectB.lat, typeof latMax !== 'undefined' ? latMax : rectA.lat);
-                lngMin = Math.min(rectA.lng, rectB.lng, typeof lngMin !== 'undefined' ? lngMin : rectA.lng);
-                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 LatLng({lat: latMin, lng: lngMin}), new LatLng({lat: latMax, lng: lngMax})];
-        }
-
-        return limitPoints;
-    }
-
-    protected getLinkType(): string {
-        return RainNode.TYPE;
-    }
-
-    private setDefaultLatLng(radars: any[]) {
-        // TODO put a default latLngRectsAsJSON based on cartesianTools earth ?
-        if (radars?.length && (!this.latLngRectsAsJSON || this.latLngRectsAsJSON === '[]')) {
-            const latLngRects = [];
-            for (const radarNode of radars) {
-                if (radarNode instanceof RadarNode) {
-                    latLngRects.push([
-                        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);
-        }
-    }
-}

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"
-  ]
-}