raain-model 2.6.7 → 2.6.10

package/src/gauge/GaugeNode.ts

@@ -0,0 +1,133 @@
+import {Link, RaainNode, TeamNode} from '../organization';
+
+/**
+ * Represents a rain gauge station in the RAAIN system.
+ * This class manages gauge data collection and configuration.
+ *
+ * @remarks
+ * Used in the API endpoint: api/gauges/:id
+ *
+ * @example
+ * ```typescript
+ * const gaugeNode = new GaugeNode({
+ *   id: 'gauge1',
+ *   latitude: 48.8566,
+ *   longitude: 2.3522,
+ *   name: 'Paris Gauge',
+ *   team: teamNode,
+ *   description: 'Main rain gauge station'
+ * });
+ * ```
+ */
+export class GaugeNode extends RaainNode {
+
+    /** Type identifier for gauge nodes */
+    public static TYPE = 'gauge';
+
+    /** Name of the gauge station */
+    public name: string;
+
+    /** Description of the gauge station */
+    public description: string;
+
+    /** Latitude of the gauge station */
+    public latitude: number;
+
+    /** Longitude of the gauge station */
+    public longitude: number;
+
+    /** Associated team */
+    public team: TeamNode;
+
+    /** Internal configuration storage */
+    private configurationAsJSON: string;
+
+    /**
+     * Creates a new GaugeNode instance.
+     *
+     * @param json - Configuration object
+     * @param json.id - Unique identifier
+     * @param json.latitude - Latitude of the gauge station
+     * @param json.longitude - Longitude of the gauge station
+     * @param json.name - Name of the gauge station
+     * @param json.team - Associated team
+     * @param json.description - Optional description
+     * @param json.links - Optional array of links
+     * @param json.version - Optional version string
+     * @param json.configurationAsJSON - Optional configuration object
+     */
+    constructor(json: {
+        id: string,
+        latitude: number,
+        longitude: number,
+        name: string,
+        team: TeamNode,
+        description?: string,
+        links?: Link[] | RaainNode[],
+        version?: string,
+        configurationAsJSON?: any,
+    }) {
+        super(json);
+        this.latitude = json.latitude;
+        this.longitude = json.longitude;
+        this.name = json.name;
+        this.description = json.description;
+        this.team = json.team;
+        this.setConfiguration(json.configurationAsJSON);
+    }
+
+    /**
+     * Sets the configuration for the gauge node.
+     *
+     * @param configuration - Configuration object or JSON string
+     */
+    public setConfiguration(configuration: string | any) {
+        let conf = configuration;
+        try {
+            conf = JSON.parse(configuration);
+        } catch (ignored) {
+        }
+
+        if (conf) {
+            this.configurationAsJSON = JSON.stringify(conf);
+        }
+    }
+
+    /**
+     * Gets the configuration of the gauge node.
+     *
+     * @returns The configuration object or null if not set
+     */
+    public getConfiguration(): any {
+        try {
+            return JSON.parse(this.configurationAsJSON);
+        } catch (e) {
+        }
+        return null;
+    }
+
+    /**
+     * Converts the gauge node to a JSON object.
+     *
+     * @returns A JSON object containing the gauge node's data
+     */
+    public toJSON(): any {
+        const json = super.toJSON();
+        json['name'] = this.name;
+        json['description'] = this.description;
+        json['latitude'] = this.latitude;
+        json['longitude'] = this.longitude;
+        json['team'] = this.team?.id || this.team;
+        json['configurationAsJSON'] = this.configurationAsJSON;
+        return json;
+    }
+
+    /**
+     * Returns the link type for gauge nodes.
+     *
+     * @returns The string 'gauge'
+     */
+    protected getLinkType(): string {
+        return GaugeNode.TYPE;
+    }
+}

package/src/gauge/GaugeNodeMap.ts

@@ -0,0 +1,55 @@
+import {Link, RaainNode, TeamNode} from '../organization';
+import {GaugeNode} from './GaugeNode';
+import {GaugeMeasure} from './GaugeMeasure';
+
+/**
+ * api/gauges/:id?format=map&begin=...
+ */
+export class GaugeNodeMap extends GaugeNode {
+
+    private map: string; // GaugeMeasure[]; stringified
+
+    constructor(json: {
+        id: string,
+        latitude: number,
+        longitude: number,
+        name: string,
+        description: string,
+        team: TeamNode,
+        configurationAsJSON?: any,
+        map?: string,
+        links?: Link[] | RaainNode[],
+        version?: string,
+    }) {
+        super(json);
+        this.setMapData(json.map);
+    }
+
+    public toJSON(): any {
+        const json = super.toJSON();
+        json.map = this.map;
+        return json;
+    }
+
+    public setMapData(mapData: GaugeMeasure[] | string) {
+        if (!mapData) {
+            return;
+        }
+
+        let map = mapData;
+        try {
+            if (typeof (mapData) !== 'string') {
+                map = JSON.stringify(mapData);
+            }
+        } catch (e) {
+        }
+        this.map = map.toString();
+    }
+
+    public getMapData(): GaugeMeasure[] {
+        if (!this.map) {
+            return [];
+        }
+        return JSON.parse(this.map);
+    }
+}

package/src/organization/EventNode.ts

@@ -0,0 +1,43 @@
+/**
+ * api/notifications/:id
+ */
+export class EventNode {
+    public id: string;
+    public title: string;
+    public status: number;
+    public red: boolean;
+    public description: string;
+    public created: Date;
+    public modified: Date;
+
+    constructor(json: {
+                    id: string,
+                    title: string,
+                    status: number,
+                    red: boolean,
+                    description: string,
+                    created: Date,
+                    modified: Date
+                }
+    ) {
+        this.id = json.id;
+        this.title = json.title;
+        this.status = json.status;
+        this.red = json.red;
+        this.description = json.description;
+        this.created = json.created;
+        this.modified = json.modified;
+    }
+
+    public toJSON(): any {
+        return {
+            id: this.id,
+            title: this.title,
+            status: this.status,
+            red: this.red,
+            description: this.description,
+            created: this.created,
+            modified: this.modified,
+        } as any;
+    }
+}

package/{organization/Link.js → src/organization/Link.ts}

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Link = void 0;
 /**
  * Hateoas Links :
  * [ {
@@ -8,28 +5,34 @@ exports.Link = void 0;
  *    href: string // like "https://../rains/2"
  *  },...]
  */
-class Link {
-    constructor(rel, href) {
-        this.rel = rel;
-        this.href = href;
+export class Link {
+    constructor(
+        public rel: string,
+        public href: string
+    ) {
     }
-    static isCloneable(object) {
-        return object && object.rel && object.href;
+
+    public static isCloneable(object: any): boolean {
+        return object?.rel && object?.href;
     }
-    static clone(object) {
+
+    public static clone(object: any): Link | null {
+        if (!object?.rel || !object?.href) {
+            return null;
+        }
         return new Link(object.rel, object.href);
     }
-    getId() {
+
+    public getId(): string {
         const urls = this.href.split('/');
         // can be enforced : verify rel in -2 urls ?...
         return urls[urls.length - 1];
     }
-    getLinkType() {
+
+    public getLinkType(): string {
         // const urls = this.href.split('/');
         // can be enforced : verify rel in -2 urls ?...
         // return urls[1].substring(0, urls[1].length - 1);
         return this.rel;
     }
 }
-exports.Link = Link;
-//# sourceMappingURL=Link.js.map

package/src/organization/Measure.ts

@@ -0,0 +1,61 @@
+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/{organization/PeopleNode.js → src/organization/PeopleNode.ts}

@@ -1,17 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PeopleNode = void 0;
 /**
  *  api/teams/:id => contacts
  */
-class PeopleNode {
-    constructor(json) {
+export class PeopleNode {
+
+    public id: string;
+    public roles: string[];
+    public email: string;
+    public name: string;
+
+    constructor(json: {
+                    id: string,
+                    roles: string[],
+                    email: string,
+                    name: string,
+                }
+    ) {
         this.id = json.id;
         this.roles = json.roles;
         this.email = json.email;
         this.name = json.name;
     }
-    toJSON() {
+
+    public toJSON(): any {
         return {
             id: this.id,
             roles: this.roles,
@@ -19,14 +29,14 @@ class PeopleNode {
             name: this.name,
         };
     }
-    hasRole(role) {
+
+    hasRole(role: string): boolean {
         return this.roles.indexOf(role) >= 0;
     }
-    addRole(role) {
+
+    addRole(role: string) {
         if (!this.hasRole(role)) {
             this.roles.push(role);
         }
     }
 }
-exports.PeopleNode = PeopleNode;
-//# sourceMappingURL=PeopleNode.js.map

package/src/organization/RaainNode.ts

@@ -0,0 +1,205 @@
+import {Link} from './Link';
+import {IVersion} from './IVersion';
+
+/**
+ * Base class for all RAAIN nodes in the system.
+ * Implements versioning and link management functionality.
+ *
+ * @remarks
+ * This is the foundation class for all API entities in the RAAIN system.
+ * It provides common functionality for:
+ * - Version management
+ * - HATEOAS link handling
+ * - JSON serialization
+ *
+ * @example
+ * ```typescript
+ * const node = new RaainNode({
+ *   id: 'node1',
+ *   version: '1.0.0',
+ *   links: [
+ *     new Link('self', '/api/nodes/node1')
+ *   ]
+ * });
+ * ```
+ */
+export class RaainNode implements IVersion {
+    /** Unique identifier for the node */
+    public id: string;
+    /** Version string of the node */
+    public version: string;
+
+    /**
+     * Creates a new RaainNode instance.
+     *
+     * @param json - Configuration object
+     * @param json.id - Unique identifier
+     * @param json.links - Array of HATEOAS links
+     * @param json.version - Version string
+     */
+    constructor(json: {
+        id: string,
+        links?: Link[] | RaainNode[],
+        version?: string,
+    }) {
+        if (!json?.id) {
+            throw new Error('RaainNode needs a valid Object or ID');
+        }
+
+        this.id = json.id;
+        this.links = json.links ? json.links : [];
+        this.version = json.version ? json.version : undefined;
+    }
+
+    /** Array of HATEOAS links associated with the node */
+    protected _links: Link[];
+
+    /**
+     * Gets all links associated with the node.
+     *
+     * @returns Array of HATEOAS links
+     */
+    public get links(): Link[] {
+        return this._links;
+    }
+
+    /**
+     * Sets the links for the node.
+     *
+     * @param links - Array of links to set
+     */
+    public set links(links: Link[] | RaainNode[]) {
+        this._links = RaainNode._getPurifiedLinks(links);
+    }
+
+    private static _getPurifiedLinks(linksToPurify: any[]): Link[] {
+        if (!linksToPurify || linksToPurify.length === 0) {
+            return [];
+        }
+
+        const linksPurified = linksToPurify
+            .filter(l => l !== null && l !== undefined)
+            .map(l => {
+                if (l instanceof Link || Link.isCloneable(l)) {
+                    return Link.clone(l);
+                } else if (l && typeof l.getLinkType === 'function' && l.id) {
+                    const linkType = l.getLinkType();
+                    let href = '../' + linkType + 's';
+                    const l2 = l;
+                    if (l2.date?.toISOString) {
+                        href += '/' + l2.date.toISOString();
+                        if (l2.version) {
+                            href += '/' + l2.version;
+                        }
+                    }
+                    href += '/' + l2.id;
+                    return new Link(linkType, href);
+                }
+                return null;
+            })
+            .filter(l => l !== null);
+
+        function uniqBy(a: Link[], key: (a: any) => string) {
+            const seen = {};
+            return a.filter((item) => {
+                if (!item) {
+                    return false;
+                }
+                const k = key(item);
+                if (seen.hasOwnProperty(k)) {
+                    return false;
+                }
+                seen[k] = true;
+                return true;
+            });
+        }
+
+        return uniqBy(linksPurified, JSON.stringify);
+    }
+
+    /**
+     * Converts the node to a JSON object.
+     *
+     * @returns A JSON object containing the node's data
+     */
+    public toJSON(): any {
+        const json: any = {
+            id: this.id,
+            links: this.links
+        };
+
+        if (this.version) {
+            json.version = this.version;
+        }
+
+        return json;
+    }
+
+    public getLinks(linkType?: string): Link[] {
+        if (!this._links) {
+            return [];
+        }
+        if (!linkType) {
+            return this._links;
+        }
+        // return this.links.filter(l => l && l.rel && linkType === l.rel);
+        return this._links.filter(l => l.getLinkType() === linkType);
+
+    }
+
+    public getLink(linkType: string, index?: number): Link {
+        index = !index ? 0 : index;
+        const linksFound = this.getLinks(linkType);
+        if (linksFound.length <= index) {
+            return null;
+        }
+        return linksFound[index];
+    }
+
+    /**
+     * Gets all link IDs associated with the node.
+     *
+     * @returns Array of link IDs
+     */
+    public getLinkIds(): string[] {
+        return this._links.map(l => l.getId());
+    }
+
+    /**
+     * Gets the count of links, optionally filtered by type.
+     *
+     * @param linkType - Optional type of links to count
+     * @returns The number of links
+     */
+    public getLinksCount(linkType?: string): number {
+        if (!this._links) {
+            return 0;
+        }
+        if (!linkType) {
+            return this._links.length;
+        }
+        return this._links.filter(l => l.getLinkType() === linkType).length;
+    }
+
+    /**
+     * Adds new links to the node.
+     *
+     * @param links - Array of links to add
+     */
+    public addLinks(links: Link[] | RaainNode[]) {
+        if (!links) {
+            return;
+        }
+
+        this._links = RaainNode._getPurifiedLinks([...this._links, ...links]);
+    }
+
+    /**
+     * Gets the version string of the node.
+     *
+     * @returns The version string
+     */
+    public getVersion(): string | undefined {
+        return this.version;
+    }
+}

package/src/organization/TeamNode.ts

@@ -0,0 +1,91 @@
+import {PeopleNode} from './PeopleNode';
+import {RaainNode} from './RaainNode';
+
+/**
+ * Represents a team in the RAAIN system.
+ * This class manages team members and their contracts.
+ *
+ * @remarks
+ * Used in the API endpoint: api/teams?name=customerTeam
+ *
+ * @example
+ * ```typescript
+ * const teamNode = new TeamNode({
+ *   id: 'team1',
+ *   name: 'Customer Team',
+ *   description: 'Main customer support team',
+ *   contracts: ['basic', 'premium'],
+ *   contacts: [peopleNode1, peopleNode2]
+ * });
+ * ```
+ */
+export class TeamNode extends RaainNode {
+
+    /** Type identifier for team nodes */
+    public static TYPE = 'team';
+
+    /** Unique identifier for the team */
+    public id: any | string;
+
+    /** Name of the team */
+    public name: string;
+
+    /** Description of the team */
+    public description: string;
+
+    /** Array of contract types associated with the team */
+    public contracts: string[];
+
+    /** Array of team members */
+    public contacts: PeopleNode[];
+
+    /**
+     * Creates a new TeamNode instance.
+     *
+     * @param json - Configuration object
+     * @param json.id - Unique identifier
+     * @param json.name - Optional name of the team
+     * @param json.description - Optional description
+     * @param json.contracts - Optional array of contract types
+     * @param json.contacts - Optional array of team members
+     */
+    constructor(json: {
+        id: any | string,
+        name?: string,
+        description?: string,
+        contracts?: string[],
+        contacts?: PeopleNode[]
+    }) {
+        super(json);
+
+        this.id = json.id;
+        this.name = json.name;
+        this.description = json.description;
+        this.contracts = json.contracts;
+        this.contacts = json.contacts;
+    }
+
+    /**
+     * Converts the team node to a JSON object.
+     *
+     * @returns A JSON object containing the team's data
+     */
+    public toJSON(): any {
+        return {
+            id: this.id,
+            name: this.name,
+            description: this.description,
+            contracts: this.contracts,
+            contacts: this.contacts,
+        } as any;
+    }
+
+    /**
+     * Returns the link type for team nodes.
+     *
+     * @returns The string 'team'
+     */
+    protected getLinkType(): string {
+        return TeamNode.TYPE;
+    }
+}