@iotready/nextjs-components-library 1.0.0-preview2 → 1.0.0-preview21

package/components/groups/GroupUpdate.d.ts

@@ -12,7 +12,7 @@ declare const GroupUpdate: ({ userInfo, groupInfo, usersGroup, usersList, device
     handleAddUserToGroup: (groupID: string, userName: string, userID: string) => Promise<any>;
     handleRemoveUserFromGroup: (groupID: string, userID: string) => Promise<any>;
     handleUpdateDevice: (id: string, body: any, user: UserType) => Promise<any>;
-    handleGetGroups: (productID: number, userInfo?: UserType) => Promise<any>;
+    handleGetGroups: (userInfo?: UserType) => Promise<any>;
     handleUpdateGroup: (id: string, group: any) => Promise<void>;
     handleDeleteGroup: (id: string) => Promise<void>;
     container?: "Box" | "Card";

package/components/groups/GroupUpdate.js

@@ -27,7 +27,7 @@ const GroupUpdate = ({ userInfo, groupInfo, usersGroup, usersList, devicesList,
             if (response) {
                 if (devicesList.length > 0) {
                     // should check if device is present in other groups the user is member of
-                    const groupsData = await handleGetGroups(1008, { role: 'support', uid: userId });
+                    const groupsData = await handleGetGroups({ role: 'support', uid: userId });
                     const userGroupIds = groupsData.map((group) => group.id);
                     // for all devices in the group set the selectedUser as manager
                     for (const device of devicesList) {

package/components/groups/GroupsDevices.d.ts

@@ -11,10 +11,10 @@ declare const GroupsDevices: ({ userInfo, handleGetUsersList, handleAddUserToGro
     }>;
     handleAddUserToGroup: (groupID: string, userName: string, userID: string) => Promise<any>;
     handleRemoveUserFromGroup: (groupID: string, userID: string) => Promise<any>;
-    handleGetGroups: (productID: number, userInfo?: UserType) => Promise<any>;
+    handleGetGroups: (userInfo?: UserType) => Promise<any>;
     handleGetUsersGroup: (groupID: string) => Promise<any>;
     handleCreateGroup: (group: any) => Promise<any>;
-    handleGetDevices: (user: UserType, group: string, selected: string) => Promise<any>;
+    handleGetDevices: (user: UserType, query: string) => Promise<any>;
     handleGetPositions: (devices: any) => Promise<any>;
     handleAddDevicesToGroup: (user: UserType, group: string, devicesToPatch: any[]) => Promise<any>;
     handleRemoveDevicesFromGroup: (user: UserType, group: string, devicesToPatch: any[]) => Promise<any>;

package/components/groups/GroupsDevices.js

@@ -28,7 +28,7 @@ const GroupsDevices = ({ userInfo, handleGetUsersList, handleAddUserToGroup, han
     const [selectedGroup, setSelectedGroup] = useState(group);
     const [groups, setGroups] = useState(null);
     const [usersList, setUsersList] = useState([]);
-    const [usersGroup, setUsersGroup] = useState([]);
+    const [usersGroup, setUsersGroup] = useState(null);
     const [groupInfo, setGroupInfo] = useState(null);
     const [openAdd, setOpenAdd] = useState(false);
     const [groupName, setGroupName] = useState('');
@@ -60,7 +60,7 @@ const GroupsDevices = ({ userInfo, handleGetUsersList, handleAddUserToGroup, han
                 moreData = usersList.users.length === pageSize;
                 page++;
             }
-            const userGroupsUserIds = usersGroup.map((ug) => ug.user.userId);
+            const userGroupsUserIds = usersGroup && usersGroup.map((ug) => ug.user.userId) || [];
             setUsersList(usersData.filter((user) => user.role === 'support' && !userGroupsUserIds.includes(user.uid)).map((user) => {
                 const userName = user.name ? user.name.replace("/", " ") : "";
                 return { label: `${userName} (${user.email})`, id: user.uid };
@@ -73,7 +73,20 @@ const GroupsDevices = ({ userInfo, handleGetUsersList, handleAddUserToGroup, han
     const fetchDevices = async (group, selected) => {
         try {
             setLoadingDevices(true);
-            const devices = await handleGetDevices(userInfo, group, selected);
+            let queryParams = "last_handshake_at!=null";
+            if (group !== "all") {
+                queryParams = `last_handshake_at!=null&state.groups=/${group}/`;
+                if (userInfo.role === "admin") {
+                    queryParams += "&quarantined=false";
+                }
+            }
+            else if (selected !== "all") {
+                queryParams = `last_handshake_at!=null&state.groups!=/${selected}/`;
+                if (userInfo.role === "admin") {
+                    queryParams += "&quarantined=false";
+                }
+            }
+            const devices = await handleGetDevices(userInfo, queryParams);
             setDevices(devices);
             if (enableMaps) {
                 const positions = await handleGetPositions(devices);
@@ -89,7 +102,7 @@ const GroupsDevices = ({ userInfo, handleGetUsersList, handleAddUserToGroup, han
     };
     const getGroups = async () => {
         try {
-            const responseData = await handleGetGroups(1008, userInfo);
+            const responseData = await handleGetGroups(userInfo);
             setGroups(responseData);
         }
         catch (err) {
@@ -119,7 +132,9 @@ const GroupsDevices = ({ userInfo, handleGetUsersList, handleAddUserToGroup, han
         if (currentGroup && !checkboxSelection) {
             setSelectedGroup(currentGroup);
             setGroupInfo(groups && groups.find((g) => g.id === currentGroup));
-            getUsersGroup(currentGroup);
+            if (currentGroup !== 'all') {
+                getUsersGroup(currentGroup);
+            }
             fetchDevices(currentGroup, currentGroup);
         }
     }, [currentGroup]);
@@ -130,7 +145,6 @@ const GroupsDevices = ({ userInfo, handleGetUsersList, handleAddUserToGroup, han
             const newGroup = {
                 name: groupName,
                 description,
-                productID: 1008, // Assuming this is the correct productID
             };
             const id = await handleCreateGroup(newGroup);
             await getGroups();
@@ -177,13 +191,13 @@ const GroupsDevices = ({ userInfo, handleGetUsersList, handleAddUserToGroup, han
             const devicesPatched = await handleAddDevicesToGroup(userInfo, selectedGroup, devicesToPatch);
             if (devicesPatched && devicesPatched.length > 0) {
                 // get all members of the group
-                const userIdsToAdd = usersGroup.map((ug) => ug.user.userId);
-                if (userIdsToAdd.length > 0) {
+                const userIdsToAdd = usersGroup && usersGroup.map((ug) => ug.user.userId) || [];
+                if (userIdsToAdd && userIdsToAdd.length > 0) {
                     for (const device of devicesToPatch) {
                         // add members to devices managers
                         await handleUpdateDevice(device.id, {
                             managers: [
-                                ...device.managers,
+                                ...(device?.managers || []),
                                 ...userIdsToAdd
                             ]
                         }, userInfo);
@@ -210,12 +224,12 @@ const GroupsDevices = ({ userInfo, handleGetUsersList, handleAddUserToGroup, han
             const devicesPatched = await handleRemoveDevicesFromGroup(userInfo, selectedGroup, devicesToPatch);
             if (devicesPatched && devicesPatched.length > 0) {
                 for (const device of devicesToPatch) {
-                    if (device.managers.length > 0) {
-                        let managersToKeep = device.managers || [];
+                    if (device.managers && device.managers.length > 0) {
+                        let managersToKeep = device.managers;
                         for (const manager of device.managers) {
                             // should check if device is present in other groups the user is member of
-                            const groupsData = await handleGetGroups(1008, { role: 'support', uid: manager });
-                            const userGroupIds = groupsData.map((group) => group.id);
+                            const groupsData = await handleGetGroups({ role: 'support', uid: manager });
+                            const userGroupIds = groupsData && groupsData.map((group) => group.id) || [];
                             const found = device.groups && device.groups.some((gID) => userGroupIds.includes(gID));
                             if (!found) {
                                 // @ts-ignore

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iotready/nextjs-components-library",
-  "version": "1.0.0-preview2",
+  "version": "1.0.0-preview21",
   "main": "index.js",
   "scripts": {
     "build": "rm -rf dist && tsc --project tsconfig.build.json && cp package.json dist/",
@@ -19,6 +19,7 @@
     "chartjs-adapter-moment": "^1.0.1",
     "chartjs-plugin-annotation": "^3.1.0",
     "chartjs-plugin-zoom": "^2.0.1",
+    "csv-parse": "^5.6.0",
     "firebase": "^10.13.1",
     "leaflet": "^1.9.4",
     "leaflet-defaulticon-compatibility": "^0.1.2",
@@ -42,4 +43,4 @@
     "eslint-config-next": "14.2.9",
     "typescript": "^5"
   }
-}
+}

package/server-actions/annotations.d.ts

@@ -0,0 +1,4 @@
+import { FirebaseConfig } from "./types";
+export declare const getAnnotations: (firebaseConfig: FirebaseConfig, deviceID: number) => Promise<{
+    id: string;
+}[]>;

package/server-actions/annotations.js

@@ -0,0 +1,15 @@
+"use server";
+import { initializeApp } from "firebase/app";
+import { collection, query, orderBy, getDocs, where } from "@firebase/firestore";
+import { getFirestore } from "@firebase/firestore";
+export const getAnnotations = async (firebaseConfig, deviceID) => {
+    // Initialize Firebase
+    const app = initializeApp(firebaseConfig);
+    const db = getFirestore(app);
+    const annotationsQuery = query(collection(db, "annotations"), where("target", "==", deviceID), orderBy("createdAt", "desc"));
+    const groupsSnapshot = await getDocs(annotationsQuery);
+    return groupsSnapshot.docs.map((doc) => ({
+        id: doc.id,
+        ...doc.data()
+    }));
+};

package/server-actions/groups.d.ts

@@ -1,11 +1,4 @@
-export type FirebaseConfig = {
-    apiKey: string;
-    authDomain: string;
-    projectId: string;
-    storageBucket: string;
-    messagingSenderId: string;
-    appId: string;
-};
+import { FirebaseConfig } from "./types";
 export declare const getGroups: (firebaseConfig: FirebaseConfig, productID: number, userID?: string) => Promise<{
     id: string;
 }[]>;

package/server-actions/index.d.ts

@@ -2,3 +2,4 @@ export * from "./groups";
 export * from "./influx";
 export * from "./logto";
 export * from "./trackle";
+export * from "./annotations";

package/server-actions/index.js

@@ -3,3 +3,4 @@ export * from "./groups";
 export * from "./influx";
 export * from "./logto";
 export * from "./trackle";
+export * from "./annotations";

package/server-actions/influx.d.ts

@@ -1,13 +1,5 @@
-export type InfluxConfig = {
-    url: string;
-    accessToken: string;
-    bucket: string;
-    orgId: string;
-    measurement: string;
-    dbName: string;
-    username: string;
-    password: string;
-};
-export declare function getInfluxDataV1(influxConfig: InfluxConfig, field: string, timeStart: number, timeEnd: number, deviceID: string, timeGroup: string, raw: boolean): Promise<any>;
-export declare function getManyMeasuresV1(influxConfig: InfluxConfig, fields: string[], limit: number, offset: number, sort: any, deviceID: string, timeStart?: number, timeEnd?: number): Promise<any>;
-export declare function getFirstTimestamp(influxConfig: InfluxConfig, deviceID: string): Promise<any>;
+import { FilterTagMode, InfluxConfig, InfluxFillType } from "./types";
+export declare function getInfluxAlerts(influxConfig: InfluxConfig, fields: string[], limit: number, offset: number, sort: any, deviceID: string, timeStart: number, timeEnd: number): Promise<any>;
+export declare function getDwSlots(influxConfig: InfluxConfig, timeStart: number, timeEnd: number, deviceID: string): Promise<any>;
+export declare function getInfluxDataV1(influxConfig: InfluxConfig, field: string, timeStart: number, timeEnd: number, deviceID: string, timeGroup: string, raw: boolean, fill?: InfluxFillType, filterTag?: number, tagInclude?: FilterTagMode): Promise<any>;
+export declare function exportDataV1(influxConfig: InfluxConfig, field: string, timeStart: number, timeEnd: number, deviceID: string): Promise<any>;

package/server-actions/influx.js

@@ -1,55 +1,175 @@
 "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, deviceID, timeStart, timeEnd) {
+    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["deviceid"] == "${deviceID}" and (${conditions}))
+  `;
+    // Add filter for tag d === 3
+    query += `
+    |> filter(fn: (r) => r["d"] == "3" or r["d"] !~ /./) // Include only events with tag d == 3 or no tag d
+  `;
+    const queryCount = `${query} |> group() |> count()`;
+    query += ` 
+    |> sort(columns: ["_time"]) // Ordina gli eventi cronologicamente
+    |> group(columns: ["valueName"]) // Raggruppa per il tag
+    |> 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[5];
+    return {
+        data: rows,
+        count: countData
+    };
+}
+export async function getDwSlots(influxConfig, timeStart, timeEnd, deviceID) {
+    const field = "dw";
+    const query = `
+    SELECT ("value") FROM "${influxConfig.measurement}"
+    WHERE "deviceid" = '${deviceID}'
+    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, deviceID, 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 "deviceid" = '${deviceID}' 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 "deviceid" = '${deviceID}' 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) {
+        // Query to get the last data point before timeStart
+        const preStartQuery = `SELECT last("value") FROM "${influxConfig.measurement}" WHERE "deviceid" = '${deviceID}' 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 +177,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 +191,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) {
+        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, deviceID) {
+    const query = `SELECT ("value") FROM "${influxConfig.measurement}" WHERE "deviceid" = '${deviceID}' 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 +228,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,20 @@
 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 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<{

package/server-actions/trackle.js

@@ -48,32 +48,19 @@ 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";
-        }
-    }
-    else if (selected !== "all") {
-        queryParams = `last_handshake_at!=null&state.groups!=/${selected}/`;
-        if (!uid) {
-            queryParams += "&quarantined=false";
-        }
-    }
+export async function getDevices(trackleConfig, productId, uid, query) {
     const api = uid ? wretchApi(trackleConfig, uid) : wretchApi(trackleConfig);
     const response = await api
         .get(uid
-        ? `/devices?${queryParams}`
-        : `/products/${productId}/devices?${queryParams}`)
+        ? `/devices${query ? "?" + query : ""}`
+        : `/products/${productId}/devices${query ? "?" + query : ""}`)
         .setTimeout(trackleConfig.apiTimeout)
         .json();
     return (uid ? { devices: response } : response);