@iotready/nextjs-components-library 1.0.0-preview3 → 1.0.0-preview31

package/server-actions/influx.js

@@ -1,55 +1,180 @@
 "use server";
+import { parse } from "csv-parse";
 import moment from "moment";
-/* export async function getInfluxDataV2(influxConfig: InfluxConfig, field: string, timeStart: string, timeEnd: string, deviceID: string, timeGroup: string, raw: boolean): Promise<Point[]> {
-  const query = `
-  from(bucket: "${influxConfig.bucket}")
-    |> range(start: ${timeStart}, stop: ${timeEnd})
-    |> filter(fn: (r) => r._measurement == "${influxConfig.measurement}")
-    |> filter(fn: (r) => r["_field"] == "${field}")
-    |> filter(fn: (r) => r["deviceid"] == "${deviceID}")
-    |> aggregateWindow(every: ${timeGroup}m, fn: last, createEmpty: false)
-    |> yield(name: "last")
+import { FilterTagMode } from "./types";
+export async function getInfluxAlerts(influxConfig, fields, limit, offset, sort, filter, timeStart, timeEnd, aggregate = false) {
+    const conditions = fields
+        .map((field) => `r["valueName"] == "${field}"`)
+        .join(" or ");
+    let query = `
+    import "contrib/tomhollingworth/events"
+    from(bucket: "${influxConfig.bucket}")`;
+    if (timeStart && timeEnd) {
+        query += ` |> range(start: ${timeStart}, stop: ${timeEnd})`;
+    }
+    query += `
+    |> filter(fn: (r) => r["_measurement"] == "${influxConfig.measurement}" and r["${filter.field}"] == "${filter.value}" and (${conditions}))
+    |> filter(fn: (r) => r["d"] == "3" or r["d"] !~ /./) // Include only events with tag d == 3 or no tag d
+    |> sort(columns: ["_time"]) // Ordina gli eventi cronologicamente
+    |> group(columns: ["valueName"]) // Raggruppa per il tag
+  `;
+    if (aggregate) {
+        // Aggregate same consecutive values
+        query += `
+      |> duplicate(column: "_value", as: "prev_value")
+      |> difference(columns: ["prev_value"], keepFirst: true)
+      |> filter(fn: (r) => r.prev_value != 0 or not exists r.prev_value)
+    `;
+    }
+    const queryCount = `${query} |> group() |> count()`;
+    query += `
+    |> events.duration(unit: 1s, stop: 2020-01-02T00:00:00Z)
+    |> keep(columns: ["_time", "valueName", "_value", "duration"])
+    |> group() // Raggruppa tutti i dati in un unico gruppo
+  `;
+    if (sort && sort.field === "time" && sort.sort === "desc") {
+        query += ` |> sort(columns: ["_time"], desc: true)`;
+    }
+    else {
+        query += ` |> sort(columns: ["_time"])`;
+    }
+    query += ` |> limit(n:${limit}, offset:${offset})`;
+    const responses = await Promise.all([
+        fetch(encodeURI(`${influxConfig.url}/api/v2/query?org=${influxConfig.orgId}`), {
+            method: "POST",
+            headers: {
+                Authorization: `Token ${influxConfig.accessToken}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                query: query,
+                type: "flux"
+            })
+        }),
+        fetch(encodeURI(`${influxConfig.url}/api/v2/query?org=${influxConfig.orgId}`), {
+            method: "POST",
+            headers: {
+                Authorization: `Token ${influxConfig.accessToken}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                query: queryCount,
+                type: "flux"
+            })
+        })
+    ]);
+    if (!responses[0].ok) {
+        throw new Error(`Failed to fetch data from InfluxDB: ${responses[0].statusText}`);
+    }
+    const data = await responses[0].text();
+    const count = await responses[1].text();
+    const rows = [];
+    const parsedData = parse(data.trim(), { columns: true });
+    parsedData.forEach((row) => {
+        rows.push({
+            time: row["_time"],
+            duration: parseInt(row["duration"], 10),
+            value: parseInt(row["_value"], 10),
+            valueName: row["valueName"]
+        });
+    });
+    const parsedCount = count.split("\n")[1].split(",");
+    let countData = parsedCount[3];
+    return {
+        data: rows,
+        count: countData
+    };
+}
+export async function getDwSlots(influxConfig, timeStart, timeEnd, filter) {
+    const field = "dw";
+    const query = `
+    SELECT ("value") FROM "${influxConfig.measurement}"
+    WHERE "${filter.field}" = '${filter.value}'
+    AND "valueName" = '${field}'
+    AND time >= '${moment.unix(timeStart).toISOString()}'
+    AND time <= '${moment.unix(timeEnd).toISOString()}'
   `;
-
-  const response = await fetch(`${influxConfig.url}/api/v2/query?org=${influxConfig.orgId}`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Authorization': `Token ${influxConfig.accessToken}`,
-      'Accept': 'application/csv'
-    },
-    body: JSON.stringify({
-      query: query
-    })
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch data from InfluxDB: ${response.statusText}`);
-  }
-  const data = await response.text();
-  return data.split('\n').map(line => {
-    const row = line.split(',');
-    const timestamp = row[5];
-    const value = parseFloat(row[6]);
-    console.log(timestamp, value);
-    if (isNaN(value)) {
-      return null;
-    }
-    return { x: new Date(timestamp).getTime(), y: value };
-  }).filter(point => point !== null);
-}*/ // NOT WORKING, NEED TO FIX
-export async function getInfluxDataV1(influxConfig, field, timeStart, timeEnd, deviceID, timeGroup, raw) {
+    const response = await fetch(encodeURI(`${influxConfig.url}/query?db=${influxConfig.dbName}&epoch=s&q=${query}`), {
+        headers: {
+            Authorization: `Basic ${btoa(`${influxConfig.username}:${influxConfig.password}`)}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch DW data: ${response.statusText}`);
+    }
+    const data = await response.json();
+    const series = data?.results?.[0]?.series?.[0];
+    if (!series?.values || !Array.isArray(series.values)) {
+        return data; // niente da fare, ritorna i dati grezzi
+    }
+    const values = series.values;
+    // Modifiche ai valori
+    if (values.length > 0) {
+        // Aggiungi punto all'inizio se il primo valore è 0
+        if (values[0][1] === 0) {
+            values.unshift([moment.unix(timeStart).unix(), 1]);
+        }
+        // Aggiungi punto alla fine se l'ultimo valore è 1
+        if (values[values.length - 1][1] === 1) {
+            values.push([moment.unix(timeEnd).unix(), 0]);
+        }
+    }
+    return data; // stessa struttura di Influx, con values modificati
+}
+export async function getInfluxDataV1(influxConfig, field, timeStart, timeEnd, filter, timeGroup, raw, fill, filterTag, tagInclude = FilterTagMode.Include) {
     let query;
+    let preStartValue = null;
+    // Costruzione filtro tag
+    let filterTagCondition = "";
+    if (filterTag !== undefined && filterTag !== null) {
+        switch (tagInclude) {
+            case FilterTagMode.Include:
+                filterTagCondition = ` AND ("d" = '${filterTag}' OR "d" !~ /./)`;
+                break;
+            case FilterTagMode.Exclude:
+                filterTagCondition = ` AND ("d" != '${filterTag}' OR "d" !~ /./)`;
+                break;
+            case FilterTagMode.DW:
+                filterTagCondition = ` AND "d" = '${filterTag}'`;
+                break;
+        }
+    }
     if (raw) {
-        query = `SELECT ("value") FROM "${influxConfig.measurement}" WHERE "deviceid" = '${deviceID}' AND "valueName" = '${field}' AND time >= '${moment
+        query = `SELECT ("value") FROM "${influxConfig.measurement}" WHERE "${filter.field}" = '${filter.value}' AND "valueName" = '${field}'${filterTagCondition} AND time >= '${moment
             .unix(timeStart)
             .toISOString()}' AND time <= '${moment.unix(timeEnd).toISOString()}'`;
     }
     else {
-        query = `SELECT last("value") FROM "${influxConfig.measurement}" WHERE "deviceid" = '${deviceID}' AND "valueName" = '${field}' AND time >= '${moment
+        query = `SELECT last("value") FROM "${influxConfig.measurement}" WHERE "${filter.field}" = '${filter.value}' AND "valueName" = '${field}'${filterTagCondition} AND time >= '${moment
             .unix(timeStart)
             .toISOString()}' AND time <= '${moment
             .unix(timeEnd)
-            .toISOString()}' GROUP BY time(${timeGroup}) fill(null)`;
+            .toISOString()}' GROUP BY time(${timeGroup})`;
+        if (fill === "none") {
+            query += ` fill(none)`;
+        }
+        else if (fill === "previous") {
+            query += ` fill(previous)`;
+        }
+        else {
+            query += ` fill(null)`;
+        }
+    }
+    if (fill !== "null") {
+        // Query to get the last data point before timeStart
+        const preStartQuery = `SELECT last("value") FROM "${influxConfig.measurement}" WHERE "${filter.field}" = '${filter.value}' AND "valueName" = '${field}'${filterTagCondition} AND time < '${moment
+            .unix(timeStart)
+            .toISOString()}'`;
+        const preStartResponse = await fetch(encodeURI(`${influxConfig.url}/query?db=${influxConfig.dbName}&epoch=s&q=${preStartQuery}`), {
+            headers: {
+                Authorization: `Basic ${btoa(`${influxConfig.username}:${influxConfig.password}`)}`
+            }
+        });
+        if (!preStartResponse.ok) {
+            throw new Error(`Failed to fetch pre-start data from InfluxDB: ${preStartResponse.statusText}`);
+        }
+        const preStartData = await preStartResponse.json();
+        preStartValue = preStartData.results[0].series?.[0]?.values?.[0]?.[1];
     }
     const response = await fetch(encodeURI(`${influxConfig.url}/query?db=${influxConfig.dbName}&epoch=s&q=${query}`), {
         headers: {
@@ -57,7 +182,6 @@ export async function getInfluxDataV1(influxConfig, field, timeStart, timeEnd, d
         }
     });
     if (!response.ok) {
-        console.log(response);
         throw new Error(`Failed to fetch data from InfluxDB: ${response.statusText}`);
     }
     const data = await response.json();
@@ -72,61 +196,34 @@ export async function getInfluxDataV1(influxConfig, field, timeStart, timeEnd, d
             }
         ];
     }
-    else {
-        // Always override the name to be the field
-        data.results[0].series.forEach((series) => {
-            series.name = field; // Force the series name to be the field name
-        });
-    }
-    return data;
-}
-export async function getManyMeasuresV1(influxConfig, fields, limit, offset, sort, deviceID, timeStart, timeEnd) {
-    if (fields.length > 0) {
-        const conditions = fields
-            .map((field) => `"valueName" = '${field}'`)
-            .join(" OR ");
-        let queryCount = `SELECT count(*) FROM "${influxConfig.measurement}" WHERE "deviceid" = '${deviceID}' AND (${conditions})`;
-        let queryPagination = `SELECT "valueName", "value" FROM "${influxConfig.measurement}" WHERE "deviceid" = '${deviceID}' AND (${conditions})`;
-        if (timeStart) {
-            queryCount += ` AND time >= '${moment.unix(timeStart).toISOString()}'`;
-            queryPagination += ` AND time >= '${moment
-                .unix(timeStart)
-                .toISOString()}'`;
-        }
-        if (timeEnd) {
-            queryCount += ` AND time <= '${moment.unix(timeEnd).toISOString()}'`;
-            queryPagination += ` AND time <= '${moment.unix(timeEnd).toISOString()}'`;
-        }
-        if (sort && sort.field === "time") {
-            queryPagination = `${queryPagination} ORDER BY "${sort.field}" ${sort.sort}`;
-        }
-        queryPagination = `${queryPagination} LIMIT ${limit} OFFSET ${offset}`;
-        const responses = await Promise.all([
-            fetch(encodeURI(`${influxConfig.url}/query?db=${influxConfig.dbName}&epoch=s&q=${queryPagination}`), {
-                headers: {
-                    Authorization: `Basic ${btoa(`${influxConfig.username}:${influxConfig.password}`)}`
-                }
-            }),
-            fetch(encodeURI(`${influxConfig.url}/query?db=${influxConfig.dbName}&epoch=s&q=${queryCount}`), {
-                headers: {
-                    Authorization: `Basic ${btoa(`${influxConfig.username}:${influxConfig.password}`)}`
-                }
-            })
-        ]);
-        if (!responses[0].ok) {
-            throw new Error(`Failed to fetch data from InfluxDB: ${responses[0].statusText}`);
+    // Always override the name to be the field
+    data.results[0].series.forEach((series) => {
+        series.name = field; // Force the series name to be the field name
+    });
+    // 1000000 REMOVED AND ADDED TO MOVE THE POINT AWAY IN THE CHART
+    if (fill !== "null") {
+        if (preStartValue !== null && preStartValue !== undefined) {
+            // Insert the pre-start value at the beginning of the dataset
+            data.results[0].series[0].values.unshift([
+                timeStart - 1000000,
+                preStartValue
+            ]);
         }
-        const data = await responses[0].json();
-        const count = await responses[1].json();
-        return { data, count };
-    }
-    else {
-        return null;
+        // Set the last point as the timeEnd and last value of the dataset
+        const lastSeries = data.results[0].series[0];
+        const lastValue = lastSeries?.values &&
+            lastSeries.values.length > 0 &&
+            lastSeries.values.slice(-1)[0].length > 1
+            ? lastSeries.values.slice(-1)[0][1]
+            : null;
+        data.results[0].series[0].values.push([timeEnd + 1000000, lastValue]);
     }
+    return data;
 }
-export async function getFirstTimestamp(influxConfig, deviceID) {
-    // Query per ottenere il primo timestamp e il valore ordinato per "time" in modo crescente
-    const query = `SELECT "time", "value" FROM "${influxConfig.measurement}" WHERE "deviceid" = '${deviceID}' ORDER BY time ASC LIMIT 1`;
+export async function exportDataV1(influxConfig, field, timeStart, timeEnd, filter) {
+    const query = `SELECT ("value") FROM "${influxConfig.measurement}" WHERE "${filter.field}" = '${filter.value}' AND "valueName" = '${field}' AND time >= '${moment
+        .unix(timeStart)
+        .toISOString()}' AND time <= '${moment.unix(timeEnd).toISOString()}'`;
     const response = await fetch(encodeURI(`${influxConfig.url}/query?db=${influxConfig.dbName}&epoch=s&q=${query}`), {
         headers: {
             Authorization: `Basic ${btoa(`${influxConfig.username}:${influxConfig.password}`)}`
@@ -136,10 +233,22 @@ export async function getFirstTimestamp(influxConfig, deviceID) {
         throw new Error(`Failed to fetch data from InfluxDB: ${response.statusText}`);
     }
     const data = await response.json();
-    // Verifica che ci siano risultati nella risposta
-    if (data?.results[0]?.series && data?.results[0]?.series[0]?.values[0]?.[0]) {
-        // Ritorna il primo timestamp
-        return data.results[0].series[0].values[0][0];
+    // Ensure the name is manually set to the field
+    if (!data.results[0].series) {
+        // Set default value with null time and null value
+        data.results[0].series = [
+            {
+                name: field, // Manually set the series name as the field
+                columns: ["time", "value"],
+                values: [] // Set null point for time and value
+            }
+        ];
+    }
+    else {
+        // Always override the name to be the field
+        data.results[0].series.forEach((series) => {
+            series.name = field; // Force the series name to be the field name
+        });
     }
-    return null; // Se non ci sono record, ritorna null
+    return data;
 }

package/server-actions/trackle.d.ts

@@ -1,19 +1,25 @@
+import { TrackleDeviceType } from "../types";
 export type TrackleConfig = {
+    orgName: string;
     apiUrl: string;
-    createCustomerUrl: string;
     clientId: string;
     clientSecret: string;
     tokenUrl: string;
     cookieName: string;
     cookieSecure: boolean;
     apiTimeout: number;
+    productID: number;
 };
 export declare function logOut(trackleConfig: TrackleConfig): Promise<void>;
 export declare function createCustomer(trackleConfig: TrackleConfig, uid: string): Promise<{
     organization: string;
     uid: string;
 }>;
-export declare function getDevices(trackleConfig: TrackleConfig, productId?: number, uid?: string, group?: string, selected?: string): Promise<{
+export declare function removeCustomer(trackleConfig: TrackleConfig, uid: string): Promise<{
+    organization: string;
+    uid: string;
+}>;
+export declare function getDevices(trackleConfig: TrackleConfig, productId?: number, uid?: string, query?: string): Promise<{
     devices: any[];
 }>;
 export declare function getDevice(trackleConfig: TrackleConfig, id: string, productId?: number, uid?: string): Promise<{
@@ -31,5 +37,5 @@ export declare function post(trackleConfig: TrackleConfig, id: string, endpoint:
 export declare function put(trackleConfig: TrackleConfig, id: string, endpoint: string, value: any, productId?: number, uid?: string): Promise<{
     return_value: number;
 }>;
-export declare function addDevicesToGroup(trackleConfig: TrackleConfig, productId: number, uid: string, group: string, devicesToPatch: any[]): Promise<string[]>;
-export declare function removeDevicesFromGroup(trackleConfig: TrackleConfig, productId: number, uid: string, group: string, devicesToPatch: any[]): Promise<string[]>;
+export declare function addDevicesToGroup(trackleConfig: TrackleConfig, productId: number, uid: string, group: string, devicesToPatch: TrackleDeviceType[]): Promise<TrackleDeviceType[]>;
+export declare function removeDevicesFromGroup(trackleConfig: TrackleConfig, productId: number, uid: string, group: string, devicesToPatch: TrackleDeviceType[]): Promise<TrackleDeviceType[]>;

package/server-actions/trackle.js

@@ -48,34 +48,35 @@ export async function logOut(trackleConfig) {
     cookies().delete(trackleConfig.cookieName);
 }
 export async function createCustomer(trackleConfig, uid) {
-    return await wretch(trackleConfig.createCustomerUrl)
+    return await wretch(`${trackleConfig.apiUrl}/orgs/${trackleConfig.orgName}/customers`)
         .headers({
         Authorization: `Basic ${btoa(`${trackleConfig.clientId}:${trackleConfig.clientSecret}`)}`
     })
         .post({ uid })
         .json();
 }
-export async function getDevices(trackleConfig, productId, uid, group, selected) {
-    let queryParams = "last_handshake_at!=null";
-    if (group !== "all") {
-        queryParams = `last_handshake_at!=null&state.groups=/${group}/`;
-        if (!uid) {
-            queryParams += "&quarantined=false";
-        }
+export async function removeCustomer(trackleConfig, uid) {
+    return await wretch(`${trackleConfig.apiUrl}/orgs/${trackleConfig.orgName}/customers/${uid}`)
+        .headers({
+        Authorization: `Basic ${btoa(`${trackleConfig.clientId}:${trackleConfig.clientSecret}`)}`
+    })
+        .delete().json();
+}
+export async function getDevices(trackleConfig, productId, uid, query) {
+    const api = uid ? wretchApi(trackleConfig, uid) : wretchApi(trackleConfig);
+    let response;
+    try {
+        response = await api
+            .get(uid
+            ? `/devices${query ? "?" + query : ""}`
+            : `/products/${productId}/devices${query ? "?" + query : ""}`)
+            .setTimeout(trackleConfig.apiTimeout)
+            .json();
     }
-    else if (selected !== "all") {
-        queryParams = `last_handshake_at!=null&state.groups!=/${selected}/`;
-        if (!uid) {
-            queryParams += "&quarantined=false";
-        }
+    catch (error) {
+        console.error("Error fetching devices:", error);
+        throw error;
     }
-    const api = uid ? wretchApi(trackleConfig, uid) : wretchApi(trackleConfig);
-    const response = await api
-        .get(uid
-        ? `/devices?${queryParams}`
-        : `/products/${productId}/devices?${queryParams}`)
-        .setTimeout(trackleConfig.apiTimeout)
-        .json();
     return (uid ? { devices: response } : response);
 }
 export async function getDevice(trackleConfig, id, productId, uid) {
@@ -123,7 +124,9 @@ export async function put(trackleConfig, id, endpoint, value, productId, uid) {
 export async function addDevicesToGroup(trackleConfig, productId, uid, group, devicesToPatch) {
     const devicesPatched = [];
     for (const device of devicesToPatch) {
-        const newGroups = device?.groups && device?.groups instanceof Array ? device?.groups : [];
+        const newGroups = device.state?.groups && device.state?.groups instanceof Array
+            ? device.state?.groups
+            : [];
         if (!newGroups.includes(group)) {
             newGroups.push(group);
             await wretchApi(trackleConfig, uid)
@@ -133,7 +136,7 @@ export async function addDevicesToGroup(trackleConfig, productId, uid, group, de
             })
                 .setTimeout(trackleConfig.apiTimeout)
                 .res();
-            devicesPatched.push(device.id);
+            devicesPatched.push(device);
         }
     }
     return devicesPatched;
@@ -141,7 +144,9 @@ export async function addDevicesToGroup(trackleConfig, productId, uid, group, de
 export async function removeDevicesFromGroup(trackleConfig, productId, uid, group, devicesToPatch) {
     const devicesPatched = [];
     for (const device of devicesToPatch) {
-        let newGroups = device?.groups && device?.groups instanceof Array ? device?.groups : [];
+        let newGroups = device.state?.groups && device.state?.groups instanceof Array
+            ? device.state?.groups
+            : [];
         if (newGroups.includes(group)) {
             newGroups = newGroups.filter((newGroup) => newGroup !== group);
             await wretchApi(trackleConfig, uid)
@@ -151,7 +156,7 @@ export async function removeDevicesFromGroup(trackleConfig, productId, uid, grou
             })
                 .setTimeout(trackleConfig.apiTimeout)
                 .res();
-            devicesPatched.push(device.id);
+            devicesPatched.push(device);
         }
     }
     return devicesPatched;

package/server-actions/types.d.ts

@@ -0,0 +1,16 @@
+export type InfluxConfig = {
+    url: string;
+    accessToken: string;
+    bucket: string;
+    orgId: string;
+    measurement: string;
+    dbName: string;
+    username: string;
+    password: string;
+};
+export declare enum FilterTagMode {
+    Include = "include",// include tag + quelli senza tag
+    Exclude = "exclude",// esclude il tag
+    DW = "dw"
+}
+export type InfluxFillType = "null" | "none" | "previous";

package/server-actions/types.js

@@ -0,0 +1,6 @@
+export var FilterTagMode;
+(function (FilterTagMode) {
+    FilterTagMode["Include"] = "include";
+    FilterTagMode["Exclude"] = "exclude";
+    FilterTagMode["DW"] = "dw"; // solo esattamente quel tag
+})(FilterTagMode || (FilterTagMode = {}));

package/types/device.d.ts

@@ -0,0 +1,19 @@
+export type AssetType = {
+    id: string;
+    device?: TrackleDeviceType;
+    [key: string]: any;
+};
+export type TrackleDeviceType = {
+    id: string;
+    state: {
+        groups: string[] | null;
+    };
+    managers: string[] | null;
+    [key: string]: any;
+};
+export type DevicePositionType = {
+    deviceID: string;
+    name: string;
+    lat: number;
+    lng: number;
+};

package/types/device.js

@@ -0,0 +1 @@
+export {};

package/types/index.d.ts

@@ -1 +1,2 @@
 export * from "./user";
+export * from "./device";

package/types/index.js

@@ -1 +1,2 @@
 export * from "./user";
+export * from "./device";

package/types/user.d.ts

@@ -4,6 +4,7 @@ export type UserType = {
     name: string;
     picture?: string;
     role: string;
+    demo?: any;
     lastSignInAt?: number;
     firstname?: string;
     lastname?: string;