raain-app 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 raain.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,12 @@
+# R2R App
+
+## Setup
+
+## Features
+
+Following [release notes](./RELEASE.md).
+
+| admin | public | status      | feature |
+|:-----:|:------:|:------------|:--------|
+|   x   |        | in progress | ????    |
+|   x   |   x    | next        | ????    |

package/RELEASE.md

@@ -0,0 +1,3 @@
+# Release notes
+
+- 1.0.x : first deploy

package/cache.service.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class Cache {
+    private readonly _cache;
+    constructor();
+    getValue(key: string, asyncGetter: any): Promise<any>;
+    putValue(key: string, value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Cache, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Cache>;
+}

package/esm2020/cache.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class Cache {
+    constructor() {
+        this._cache = {};
+    }
+    async getValue(key, asyncGetter) {
+        if (!this._cache.hasOwnProperty(key)) {
+            console.log('cache not done: ', key);
+            this.putValue(key, await asyncGetter());
+        }
+        else {
+            console.log('cache done: ', key);
+        }
+        return this._cache[key];
+    }
+    putValue(key, value) {
+        this._cache[key] = value;
+        const length = Object.getOwnPropertyNames(this._cache).length;
+        if (length > 30) {
+            console.warn('cache size exceed ? do a restart ?', length);
+        }
+    }
+}
+Cache.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: Cache, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+Cache.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: Cache, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: Cache, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/fidj-storage.model.mjs

@@ -0,0 +1,162 @@
+import { Link } from 'raain-model';
+export class FidjStorageNode {
+    constructor() {
+        this.radars = [];
+        this.rains = [];
+        this.gauges = [];
+        this.events = [];
+        this.infos = {};
+    }
+    static getEmptyNode() {
+        return new FidjStorageNode();
+    }
+    static getDemoNode() {
+        const demoNode = new FidjStorageNode();
+        const link = new Link('rain', 'https://demo/api/rains/2');
+        /*
+        demoNode.radars = [
+          new RadarNode({
+            id: '5efd04569cb1f4161bd69dc7',
+            name: 'demo radar A',
+            links: [link],
+            latitude: 48.774569,
+            longitude: 2.008407
+          }),
+          new RadarNode({
+            id: 'dr2',
+            name: 'demo radar B',
+            links: [link],
+            latitude: 0.11,
+            longitude: -0.753
+          }),
+          new RadarNode({
+            id: 'dr3',
+            name: 'demo radar C',
+            latitude: 0.13,
+            longitude: -0.753,
+            links: []
+          }),
+          new RadarNode({
+            id: 'dr4',
+            name: 'demo radar D',
+            latitude: 0.14,
+            longitude: -0.74,
+            links: []
+          })];
+        demoNode.rains = [
+          new RainNode({
+            id: '5efd04569cb1f4161bd69dc8',
+            name: 'Demo rain zone A',
+            links: [new Link('radar', 'https://demo/api/radars/5efcfe619cb1f4161bd69dc3')],
+            status: 0,
+            quality: 75,
+            latitude: 48.774569,
+            longitude: 2.008407
+          }),
+          new RainNode({
+            id: 'dz2',
+            name: 'Demo rain zone B',
+            radars: [demoNode.radars[0], demoNode.radars[1]],
+            status: 1,
+            quality: 50,
+            latitude: 48.774569,
+            longitude: 2.008407
+          }),
+          new RainNode({
+            id: 'dz3',
+            name: 'Demo rain zone C',
+            radars: [demoNode.radars[0], demoNode.radars[1]],
+            status: 2,
+            quality: 75,
+            latitude: 48.774569,
+            longitude: 2.008407
+          }),
+          new RainNode({
+            id: 'dz4',
+            name: 'Demo rain zone D',
+            radars: [demoNode.radars[0], demoNode.radars[1]],
+            status: 3,
+            quality: 95,
+            latitude: 48.774569,
+            longitude: 2.008407
+          })];
+    
+        demoNode.gauges = [
+          new GaugeNode({
+            id: 'g1',
+            name: 'Gauge A',
+            latitude: 48.7748,
+            longitude: 2.28407,
+          }),
+          new GaugeNode({
+            id: 'g2',
+            name: 'Gauge B',
+            latitude: 48.874569,
+            longitude: 2.108407,
+          })];
+        demoNode.events = [{
+          id: 'e2',
+          title: 'Need support ?',
+          status: 0,
+          red: false,
+          description: 'This area is dedicated to support you and your team. Support is made on Radar or Rain quality, ' +
+            'or any feedback we can have about your production system. Our goal : improving your data.',
+          created: new Date(),
+          modified: new Date()
+        }];
+        demoNode.team = {
+          id: 'p1',
+          email: 'demo@demo.com',
+          name: 'demo guy',
+          description: 'the demo guy'
+        };
+    
+         */
+        return demoNode;
+    }
+}
+class FidjStorageResult {
+}
+export class FidjStorage {
+    constructor(storage) {
+        this.storage = storage;
+        this.node = FidjStorageNode.getEmptyNode();
+        this.fidjMetaResult = { data: new FidjStorageNode() };
+    }
+    async storeData(fidjAngularService, data) {
+        this.node = JSON.parse(JSON.stringify(data));
+        this.fidjMetaResult.data = this.node;
+        if (this.isDemoMode) {
+            this.storage.set('fidjMetaResult', JSON.stringify(this.fidjMetaResult));
+            return;
+        }
+        await fidjAngularService.put(this.fidjMetaResult);
+    }
+    async getRefreshedNodeCopy(fidjAngularService) {
+        if (this.isDemoMode) {
+            const fidjMetaResult = this.storage.get('fidjMetaResult');
+            if (fidjMetaResult) {
+                this.fidjMetaResult = JSON.parse(fidjMetaResult);
+                this.node = this.fidjMetaResult.data;
+            }
+            return JSON.parse(JSON.stringify(this.node));
+        }
+        const firstDemoData = () => {
+            this.node = FidjStorageNode.getDemoNode();
+            this.storeData(fidjAngularService, this.node);
+        };
+        await fidjAngularService.sync(firstDemoData);
+        const fidjFindAllResults = await fidjAngularService.findAll();
+        if (fidjFindAllResults && fidjFindAllResults.length > 0) {
+            if (fidjFindAllResults[0].data) {
+                this.fidjMetaResult = fidjFindAllResults[0];
+                this.node = this.fidjMetaResult.data;
+            }
+        }
+        return JSON.parse(JSON.stringify(this.node));
+    }
+    setDemoMode(isDemo) {
+        this.isDemoMode = isDemo;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fidj-storage.model.js","sourceRoot":"","sources":["../../src/app/shared/fidj-storage.model.ts"],"names":[],"mappings":"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","sourcesContent":["import {FidjService} from 'fidj';\nimport {EventNode, GaugeNode, Link, PeopleNode, RadarNode, RainNode} from 'raain-model';\nimport {Storage} from './storage.service';\n\nexport class FidjStorageNode {\n\n  public radars: RadarNode[] = [];\n  public rains: RainNode[] = [];\n  public gauges: GaugeNode[] = [];\n  public team: PeopleNode;\n  public events: EventNode[] = [];\n\n  public infos: any = {};\n\n  static getEmptyNode() {\n    return new FidjStorageNode();\n  }\n\n  static getDemoNode() {\n    const demoNode = new FidjStorageNode();\n    const link = new Link('rain', 'https://demo/api/rains/2');\n    /*\n    demoNode.radars = [\n      new RadarNode({\n        id: '5efd04569cb1f4161bd69dc7',\n        name: 'demo radar A',\n        links: [link],\n        latitude: 48.774569,\n        longitude: 2.008407\n      }),\n      new RadarNode({\n        id: 'dr2',\n        name: 'demo radar B',\n        links: [link],\n        latitude: 0.11,\n        longitude: -0.753\n      }),\n      new RadarNode({\n        id: 'dr3',\n        name: 'demo radar C',\n        latitude: 0.13,\n        longitude: -0.753,\n        links: []\n      }),\n      new RadarNode({\n        id: 'dr4',\n        name: 'demo radar D',\n        latitude: 0.14,\n        longitude: -0.74,\n        links: []\n      })];\n    demoNode.rains = [\n      new RainNode({\n        id: '5efd04569cb1f4161bd69dc8',\n        name: 'Demo rain zone A',\n        links: [new Link('radar', 'https://demo/api/radars/5efcfe619cb1f4161bd69dc3')],\n        status: 0,\n        quality: 75,\n        latitude: 48.774569,\n        longitude: 2.008407\n      }),\n      new RainNode({\n        id: 'dz2',\n        name: 'Demo rain zone B',\n        radars: [demoNode.radars[0], demoNode.radars[1]],\n        status: 1,\n        quality: 50,\n        latitude: 48.774569,\n        longitude: 2.008407\n      }),\n      new RainNode({\n        id: 'dz3',\n        name: 'Demo rain zone C',\n        radars: [demoNode.radars[0], demoNode.radars[1]],\n        status: 2,\n        quality: 75,\n        latitude: 48.774569,\n        longitude: 2.008407\n      }),\n      new RainNode({\n        id: 'dz4',\n        name: 'Demo rain zone D',\n        radars: [demoNode.radars[0], demoNode.radars[1]],\n        status: 3,\n        quality: 95,\n        latitude: 48.774569,\n        longitude: 2.008407\n      })];\n\n    demoNode.gauges = [\n      new GaugeNode({\n        id: 'g1',\n        name: 'Gauge A',\n        latitude: 48.7748,\n        longitude: 2.28407,\n      }),\n      new GaugeNode({\n        id: 'g2',\n        name: 'Gauge B',\n        latitude: 48.874569,\n        longitude: 2.108407,\n      })];\n    demoNode.events = [{\n      id: 'e2',\n      title: 'Need support ?',\n      status: 0,\n      red: false,\n      description: 'This area is dedicated to support you and your team. Support is made on Radar or Rain quality, ' +\n        'or any feedback we can have about your production system. Our goal : improving your data.',\n      created: new Date(),\n      modified: new Date()\n    }];\n    demoNode.team = {\n      id: 'p1',\n      email: 'demo@demo.com',\n      name: 'demo guy',\n      description: 'the demo guy'\n    };\n\n     */\n    return demoNode;\n  }\n}\n\nclass FidjStorageResult {\n  data: FidjStorageNode;\n}\n\nexport class FidjStorage {\n\n  private isDemoMode: boolean;\n  private node: FidjStorageNode = FidjStorageNode.getEmptyNode();\n  private fidjMetaResult: FidjStorageResult = {data: new FidjStorageNode()};\n\n  constructor(private storage: Storage) {\n  }\n\n  public async storeData(fidjAngularService: FidjService, data) {\n    this.node = JSON.parse(JSON.stringify(data));\n    this.fidjMetaResult.data = this.node;\n\n    if (this.isDemoMode) {\n      this.storage.set('fidjMetaResult', JSON.stringify(this.fidjMetaResult));\n      return;\n    }\n\n    await fidjAngularService.put(this.fidjMetaResult);\n  }\n\n  public async getRefreshedNodeCopy(fidjAngularService: FidjService): Promise<FidjStorageNode> {\n\n    if (this.isDemoMode) {\n      const fidjMetaResult = this.storage.get('fidjMetaResult');\n      if (fidjMetaResult) {\n        this.fidjMetaResult = JSON.parse(fidjMetaResult);\n        this.node = this.fidjMetaResult.data;\n      }\n      return JSON.parse(JSON.stringify(this.node));\n    }\n\n    const firstDemoData = () => {\n      this.node = FidjStorageNode.getDemoNode();\n      this.storeData(fidjAngularService, this.node);\n    };\n\n    await fidjAngularService.sync(firstDemoData);\n    const fidjFindAllResults: any = await fidjAngularService.findAll();\n\n    if (fidjFindAllResults && fidjFindAllResults.length > 0) {\n      if (fidjFindAllResults[0].data) {\n        this.fidjMetaResult = fidjFindAllResults[0];\n        this.node = this.fidjMetaResult.data;\n      }\n    }\n\n    return JSON.parse(JSON.stringify(this.node));\n  }\n\n  setDemoMode(isDemo: boolean) {\n    this.isDemoMode = isDemo;\n  }\n}\n"]}

package/esm2020/index.mjs

@@ -0,0 +1,18 @@
+export * from './raain-map/raain-map.component';
+export * from './raain-compare/raain-compare.component';
+export * from './raain-configuration/raain-configuration.component';
+export * from './raain-date-focus/raain-date-focus.component';
+export * from './raain-speed/raain-speed.component';
+export * from './raain-compare-stack/raain-compare-stack.component';
+export * from './raain-test/raain-test.component';
+export * from './tools';
+export * from './cache.service';
+export * from './fidj-storage.model';
+export * from './profile.service';
+export * from './radar.service';
+export * from './shared.const';
+export * from './shared.pipe';
+export * from './shared.module';
+export * from './storage.service';
+export * from './xytype';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBwL3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxxREFBcUQsQ0FBQztBQUNwRSxjQUFjLCtDQUErQyxDQUFDO0FBQzlELGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxxREFBcUQsQ0FBQztBQUNwRSxjQUFjLG1DQUFtQyxDQUFDO0FBRWxELGNBQWMsU0FBUyxDQUFDO0FBRXhCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3JhYWluLW1hcC9yYWFpbi1tYXAuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcmFhaW4tY29tcGFyZS9yYWFpbi1jb21wYXJlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3JhYWluLWNvbmZpZ3VyYXRpb24vcmFhaW4tY29uZmlndXJhdGlvbi5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9yYWFpbi1kYXRlLWZvY3VzL3JhYWluLWRhdGUtZm9jdXMuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcmFhaW4tc3BlZWQvcmFhaW4tc3BlZWQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcmFhaW4tY29tcGFyZS1zdGFjay9yYWFpbi1jb21wYXJlLXN0YWNrLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3JhYWluLXRlc3QvcmFhaW4tdGVzdC5jb21wb25lbnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL3Rvb2xzJztcblxuZXhwb3J0ICogZnJvbSAnLi9jYWNoZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZmlkai1zdG9yYWdlLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZmlsZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcmFkYXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NoYXJlZC5jb25zdCc7XG5leHBvcnQgKiBmcm9tICcuL3NoYXJlZC5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vc2hhcmVkLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2Uuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3h5dHlwZSc7XG4iXX0=