@adventurelabs/scout-core 1.0.0

package/dist/helpers/plans.js

@@ -0,0 +1,61 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+// function that fetches the plans our db given a herd id
+export async function server_get_plans_by_herd(herd_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("plans")
+        .select("*")
+        .eq("herd_id", herd_id);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    else {
+        return IWebResponse.success(data).to_compatible();
+    }
+}
+// function that uploads plan to our db
+export async function server_create_plans(plans) {
+    // loop through plans and format
+    let formatted_plans = plans.map((plan) => {
+        let formatted_plan = { ...plan };
+        delete formatted_plan.id;
+        delete formatted_plan.inserted_at;
+        return formatted_plan;
+    });
+    const supabase = await newServerClient();
+    // insert data and return the response
+    const { data, error } = await supabase
+        .from("plans")
+        .insert(formatted_plans)
+        .select("*");
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    else {
+        return IWebResponse.success(data).to_compatible();
+    }
+}
+export async function server_delete_plans_by_ids(plan_ids) {
+    const supabase = await newServerClient();
+    const { error } = await supabase.from("plans").delete().in("id", plan_ids);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: false,
+        };
+    }
+    else {
+        return IWebResponse.success(true).to_compatible();
+    }
+}

package/dist/helpers/tags.d.ts

@@ -0,0 +1,7 @@
+import { IEventWithTags, ITag } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_create_tags(tags: ITag[]): Promise<IWebResponseCompatible<ITag[]>>;
+export declare function server_delete_tags_by_ids(tag_ids: number[]): Promise<IWebResponseCompatible<boolean>>;
+export declare function server_get_more_events_with_tags_by_herd(herd_id: number, offset: number, page_count?: number): Promise<IWebResponseCompatible<IEventWithTags[]>>;
+export declare function server_get_events_and_tags_for_device(device_id: number, limit?: number): Promise<IWebResponseCompatible<IEventWithTags[]>>;
+export declare function get_event_and_tags_by_event_id(event_id: number): Promise<IWebResponseCompatible<IEventWithTags>>;

package/dist/helpers/tags.js

@@ -0,0 +1,158 @@
+"use server";
+// add tag to db
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+export async function server_create_tags(tags) {
+    const supabase = await newServerClient();
+    // remove id key from tags
+    const formatted_tags = tags.map((tag) => {
+        const { id, ...rest } = tag;
+        return {
+            ...rest,
+            observation_type: rest.observation_type,
+        };
+    });
+    const { data, error } = await supabase
+        .from("tags")
+        .insert(formatted_tags)
+        .select("*");
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    else {
+        return IWebResponse.success(data).to_compatible();
+    }
+}
+export async function server_delete_tags_by_ids(tag_ids) {
+    const supabase = await newServerClient();
+    const { error } = await supabase.from("tags").delete().in("id", tag_ids);
+    if (error) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: false,
+        };
+    }
+    else {
+        return IWebResponse.success(true).to_compatible();
+    }
+}
+// export async function server_get_events_with_tags_by_herd(
+//   herd_id: number
+// ): Promise<IWebResponseCompatible<IEventWithTags[]>> {
+//   const supabase = await newServerClient();
+//   const { data, error } = await supabase
+//     .from("events")
+//     .select(
+//       `
+//       *,
+//       tags: tags (*)
+//       `
+//     )
+//     .eq("devices.herd_id", herd_id)
+//     .order("timestamp_observation", { ascending: false });
+//   if (error) {
+//     return {
+//       status: EnumWebResponse.ERROR,
+//       msg: error.message,
+//       data: [],
+//     };
+//   }
+//   return IWebResponse.success(data).to_compatible();
+// }
+export async function server_get_more_events_with_tags_by_herd(herd_id, offset, page_count = 10) {
+    const from = offset * page_count;
+    const to = from + page_count - 1;
+    const supabase = await newServerClient();
+    // make rpc call to get_events_with_tags_for_herd(herd_id, offset, limit)
+    const { data, error } = await supabase.rpc("get_events_and_tags_for_herd", {
+        herd_id_caller: herd_id,
+        offset_caller: from,
+        limit_caller: page_count,
+    });
+    if (error) {
+        console.warn("Error fetching events with tags by herd:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    // iterate through data if tags contains null, remove it
+    const filtered_data = data.map((event) => {
+        if (!event.tags)
+            return event;
+        event.tags = event.tags.filter((tag) => tag !== null);
+        return event;
+    });
+    return IWebResponse.success(filtered_data).to_compatible();
+}
+export async function server_get_events_and_tags_for_device(device_id, limit = 3) {
+    const supabase = await newServerClient();
+    // make rpc call to get_events_with_tags_for_device(device_id, limit)
+    const { data, error } = await supabase.rpc("get_events_and_tags_for_device", {
+        device_id_caller: device_id,
+        limit_caller: limit,
+    });
+    if (error) {
+        console.warn("Error fetching recent events with tags by device:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function get_event_and_tags_by_event_id(event_id) {
+    const supabase = await newServerClient();
+    // use actual sql query to get event and tags instead of rpc
+    const { data, error } = await supabase
+        .from("events")
+        .select(`
+      *,
+      tags: tags (*)
+      `)
+        .eq("id", event_id);
+    if (error) {
+        console.warn("Error fetching event with tags by event id:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: null,
+        };
+    }
+    if (!data[0]) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "Event not found",
+            data: null,
+        };
+    }
+    // Transform location to latitude/longitude
+    const transformedData = {
+        id: data[0].id,
+        inserted_at: data[0].inserted_at,
+        message: data[0].message,
+        media_url: data[0].media_url,
+        latitude: data[0].location
+            ? data[0].location.coordinates[1]
+            : null,
+        longitude: data[0].location
+            ? data[0].location.coordinates[0]
+            : null,
+        altitude: data[0].altitude,
+        heading: data[0].heading,
+        media_type: data[0].media_type,
+        device_id: data[0].device_id,
+        timestamp_observation: data[0].timestamp_observation,
+        is_public: data[0].is_public,
+        tags: data[0].tags || [],
+        earthranger_url: data[0].earthranger_url,
+    };
+    return IWebResponse.success(transformedData).to_compatible();
+}

package/dist/helpers/time.d.ts

@@ -0,0 +1,3 @@
+export declare function convertSecondsSinceEpochToDate(secondsSinceEpoch: number): Date;
+export declare function convertIsoStringToDate(isoString: string): Date;
+export declare function convertDateToTimeString(date: Date): string;

package/dist/helpers/time.js

@@ -0,0 +1,11 @@
+export function convertSecondsSinceEpochToDate(secondsSinceEpoch) {
+    return new Date(secondsSinceEpoch * 1000);
+}
+// convert iso ISO 8601 string to date
+export function convertIsoStringToDate(isoString) {
+    return new Date(isoString);
+}
+// convert date to time string of format "HH:MM:SS, DD/MM/YYYY"
+export function convertDateToTimeString(date) {
+    return `${date.toLocaleTimeString()}, ${date.toLocaleDateString()} UTC`;
+}

package/dist/helpers/ui.d.ts

@@ -0,0 +1,4 @@
+import { Role } from "../types/db";
+export declare function formatRoleCasing(role: Role): string;
+export declare function formatUsernameInitials(username: string): string;
+export declare function roundToXDecimals(num: number, decimals: number): number;

package/dist/helpers/ui.js

@@ -0,0 +1,12 @@
+export function formatRoleCasing(role) {
+    return role.charAt(0).toUpperCase() + role.slice(1);
+}
+export function formatUsernameInitials(username) {
+    if (!username) {
+        return "";
+    }
+    return username.slice(0, 2).toUpperCase();
+}
+export function roundToXDecimals(num, decimals) {
+    return Math.round(num * Math.pow(10, decimals)) / Math.pow(10, decimals);
+}

package/dist/helpers/users.d.ts

@@ -0,0 +1,6 @@
+import { IUser, IUserAndRole, IUserRolePerHerd, Role } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+export declare function server_get_user_roles(herd_id: number): Promise<IWebResponseCompatible<IUserRolePerHerd[]>>;
+export declare function server_get_user(): Promise<IWebResponseCompatible<IUser | null>>;
+export declare function server_get_users_with_herd_access(herd_id: number): Promise<IWebResponseCompatible<IUserAndRole[] | null>>;
+export declare function server_upsert_user_with_role(herd_id: number, username: string, role: Role): Promise<IWebResponseCompatible<IUserAndRole | null>>;

package/dist/helpers/users.js

@@ -0,0 +1,66 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { IWebResponse, EnumWebResponse, } from "../types/requests";
+export async function server_get_user_roles(herd_id) {
+    const supabase = await newServerClient();
+    // fetch user role for herd
+    const { data, error } = await supabase
+        .from("users_roles_per_herd")
+        .select("*")
+        .eq("herd_id", herd_id);
+    if (!data) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: `No user role found for herd ${herd_id}`,
+            data: null,
+        };
+    }
+    // TODO: DETERMINE WHEN TO PASS ERROR
+    let response = IWebResponse.success(data);
+    return response.to_compatible();
+}
+export async function server_get_user() {
+    const supabase = await newServerClient();
+    const { data } = await supabase.auth.getUser();
+    const new_user = data.user;
+    return IWebResponse.success(new_user).to_compatible();
+}
+export async function server_get_users_with_herd_access(herd_id) {
+    const supabase = await newServerClient();
+    const { data, error } = await supabase
+        .from("users_roles_per_herd")
+        .select("user:users(*), role")
+        .eq("herd_id", herd_id);
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_upsert_user_with_role(herd_id, username, role) {
+    const supabase = await newServerClient();
+    // first try to get user by username
+    const { data: user, error: user_error } = await supabase
+        .from("users")
+        .select("*")
+        .eq("username", username)
+        .single();
+    if (user_error) {
+        return IWebResponse.error("Unable to fetch user with provided username").to_compatible();
+    }
+    if (!user) {
+        return IWebResponse.error("User not found").to_compatible();
+    }
+    const newRoleForDb = {
+        user_id: user.id,
+        herd_id: herd_id,
+        role: role,
+    };
+    // upddate or insert user role
+    const { data, error } = await supabase
+        .from("users_roles_per_herd")
+        .upsert(newRoleForDb);
+    if (error) {
+        return IWebResponse.error("Unable to update or add user with provided username. Ensure you have sufficient permissions.").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/helpers/web.d.ts

@@ -0,0 +1 @@
+export declare function getOrigin(): string;

package/dist/helpers/web.js

@@ -0,0 +1,7 @@
+export function getOrigin() {
+    let url = process?.env?.NEXT_PUBLIC_SITE_URL ?? // Set this to your site URL in production env.
+        "http://localhost:3000";
+    // Make sure to include `https://` when not localhost.
+    url = url.startsWith("http") ? url : `https://${url}`;
+    return url;
+}

package/dist/helpers/zones.d.ts

@@ -0,0 +1,18 @@
+import { IZoneWithActions } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+/**
+ * Get more zones and actions for a herd
+ * @param herd_id - The ID of the herd to get zones and actions for
+ * @param offset - The offset to start the query from
+ * @param page_count - The number of zones and actions to return
+ * @returns A list of zones and actions
+ * @throws An error if the zones or actions are not fetched
+ */
+export declare function server_get_more_zones_and_actions_for_herd(herd_id: number, offset: number, page_count?: number): Promise<IWebResponseCompatible<IZoneWithActions[]>>;
+/**
+ * Create zones and actions for a herd
+ * @param zones - The zones to create
+ * @returns A list of zones and actions
+ * @throws An error if the zones or actions are not created
+ */
+export declare function server_create_zones_with_actions(zones: IZoneWithActions[]): Promise<IWebResponseCompatible<IZoneWithActions[]>>;

package/dist/helpers/zones.js

@@ -0,0 +1,108 @@
+import { newServerClient } from "../supabase/server";
+import { EnumWebResponse, IWebResponse, } from "../types/requests";
+/**
+ * Get more zones and actions for a herd
+ * @param herd_id - The ID of the herd to get zones and actions for
+ * @param offset - The offset to start the query from
+ * @param page_count - The number of zones and actions to return
+ * @returns A list of zones and actions
+ * @throws An error if the zones or actions are not fetched
+ */
+export async function server_get_more_zones_and_actions_for_herd(herd_id, offset, page_count = 10) {
+    const from = offset * page_count;
+    const to = from + page_count - 1;
+    const supabase = await newServerClient();
+    // make rpc call to get_events_with_tags_for_herd(herd_id, offset, limit)
+    const { data, error } = await supabase.rpc("get_zones_and_actions_for_herd", {
+        herd_id_caller: herd_id,
+        offset_caller: from,
+        limit_caller: page_count,
+    });
+    if (error) {
+        console.warn("Error fetching zones and actions for herd:", error.message);
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: error.message,
+            data: [],
+        };
+    }
+    return IWebResponse.success(data.map((zone) => ({
+        ...zone,
+        actions: zone.actions ?? [],
+    }))).to_compatible();
+}
+/**
+ * Create zones and actions for a herd
+ * @param zones - The zones to create
+ * @returns A list of zones and actions
+ * @throws An error if the zones or actions are not created
+ */
+export async function server_create_zones_with_actions(zones) {
+    // loop through plans and format
+    let actions = zones.flatMap((zone) => zone.actions);
+    let formatted_zones = zones.map((zone) => {
+        let formatted_zone = { ...zone };
+        delete formatted_zone.id;
+        delete formatted_zone.inserted_at;
+        delete formatted_zone.actions;
+        return formatted_zone;
+    });
+    let formatted_actions = actions.map((action) => {
+        let formatted_action = { ...action };
+        delete formatted_action.id;
+        delete formatted_action.zone_id;
+        delete formatted_action.inserted_at;
+        return formatted_action;
+    });
+    const supabase = await newServerClient();
+    // insert data and return the response
+    const { data, error } = await supabase
+        .from("zones")
+        .insert(formatted_zones)
+        .select("*");
+    if (error) {
+        let msg = `Error creating zones: ${error.message}`;
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: msg,
+            data: null,
+        };
+    }
+    // get zone id
+    let zone_ids = data.map((zone) => {
+        return zone.id;
+    });
+    // if zone ids length is zero, return error
+    if (zone_ids.length === 0) {
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: "No zones created",
+            data: null,
+        };
+    }
+    // add zone id to formatted actions
+    formatted_actions.forEach((action) => {
+        action.zone_id = zone_ids[0];
+    });
+    // insert actions
+    const { data: data_actions, error: error_actions } = await supabase
+        .from("actions")
+        .insert(formatted_actions)
+        .select("*");
+    if (error_actions) {
+        let msg = `Error creating actions: ${error_actions.message}`;
+        return {
+            status: EnumWebResponse.ERROR,
+            msg: msg,
+            data: null,
+        };
+    }
+    // merge data and data_actions
+    const merged_data = data.map((zone) => {
+        return {
+            ...zone,
+            actions: data_actions.filter((action) => action.zone_id === zone.id),
+        };
+    });
+    return IWebResponse.success(merged_data).to_compatible();
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./useScoutDbListener";
+export * from "./useScoutRefresh";

package/dist/hooks/index.js

@@ -0,0 +1,2 @@
+export * from "./useScoutDbListener";
+export * from "./useScoutRefresh";

package/dist/hooks/useScoutDbListener.d.ts

@@ -0,0 +1 @@
+export declare function useScoutDbListener(): void;

package/dist/hooks/useScoutDbListener.js

@@ -0,0 +1,94 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useEffect, useRef } from "react";
+import { addDevice, addPlan, addTag, deleteDevice, deletePlan, deleteTag, updateDevice, updatePlan, updateTag, } from "../store/scout";
+import { createBrowserClient } from "@supabase/ssr";
+import { get_device_by_id } from "../helpers/devices";
+import { EnumWebResponse } from "../types/requests";
+export function useScoutDbListener() {
+    const url = process.env.NEXT_PUBLIC_SUPABASE_URL || "";
+    const anon_key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "";
+    const supabase = useRef(null);
+    const dispatch = useAppDispatch();
+    function handleTagInserts(payload) {
+        dispatch(addTag(payload.new));
+    }
+    function handleTagDeletes(payload) {
+        dispatch(deleteTag(payload.old));
+    }
+    function handleTagUpdates(payload) {
+        dispatch(updateTag(payload.new));
+    }
+    async function handleDeviceInserts(payload) {
+        const response_device = await get_device_by_id(payload.new.id);
+        if (response_device.status == EnumWebResponse.SUCCESS &&
+            response_device.data) {
+            dispatch(addDevice(response_device.data));
+        }
+        else {
+            console.error("error getting device by id", payload);
+        }
+    }
+    function handleDeviceDeletes(payload) {
+        dispatch(deleteDevice(payload.old));
+    }
+    async function handleDeviceUpdates(payload) {
+        const response_device = await get_device_by_id(payload.new.id);
+        if (response_device.status == EnumWebResponse.SUCCESS &&
+            response_device.data) {
+            dispatch(updateDevice(response_device.data));
+        }
+        else {
+            console.error("error getting device by id", payload);
+        }
+    }
+    function handlePlanInserts(payload) {
+        dispatch(addPlan(payload.new));
+    }
+    function handlePlanDeletes(payload) {
+        dispatch(deletePlan(payload.old));
+    }
+    function handlePlanUpdates(payload) {
+        dispatch(updatePlan(payload.new));
+    }
+    useEffect(() => {
+        const newSupabase = createBrowserClient(url, anon_key);
+        newSupabase
+            .channel("plans_insert")
+            .on("postgres_changes", { event: "INSERT", schema: "public", table: "plans" }, handlePlanInserts)
+            .subscribe();
+        newSupabase
+            .channel("plans_delete")
+            .on("postgres_changes", { event: "DELETE", schema: "public", table: "plans" }, handlePlanDeletes)
+            .subscribe();
+        newSupabase
+            .channel("plans_update")
+            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "plans" }, handlePlanUpdates)
+            .subscribe();
+        newSupabase
+            .channel("devices_delete")
+            .on("postgres_changes", { event: "DELETE", schema: "public", table: "devices" }, handleDeviceDeletes)
+            .subscribe();
+        newSupabase
+            .channel("devices_insert")
+            .on("postgres_changes", { event: "INSERT", schema: "public", table: "devices" }, handleDeviceInserts)
+            .subscribe();
+        newSupabase
+            .channel("devices_update")
+            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "devices" }, handleDeviceUpdates)
+            .subscribe();
+        newSupabase
+            .channel("tags_insert")
+            .on("postgres_changes", { event: "INSERT", schema: "public", table: "tags" }, handleTagInserts)
+            .subscribe();
+        newSupabase
+            .channel("tags_delete")
+            .on("postgres_changes", { event: "DELETE", schema: "public", table: "tags" }, handleTagDeletes)
+            .subscribe();
+        newSupabase
+            .channel("tags_update")
+            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "tags" }, handleTagUpdates)
+            .subscribe();
+        supabase.current = newSupabase;
+    }, []);
+}

package/dist/hooks/useScoutRefresh.d.ts

@@ -0,0 +1,7 @@
+export interface UseScoutRefreshOptions {
+    autoRefresh?: boolean;
+    onRefreshComplete?: () => void;
+}
+export declare function useScoutRefresh(options?: UseScoutRefreshOptions): {
+    handleRefresh: () => Promise<void>;
+};

package/dist/hooks/useScoutRefresh.js

@@ -0,0 +1,45 @@
+import { useEffect } from "react";
+import { useAppDispatch } from "../store/hooks";
+import { EnumScoutStateStatus, setActiveHerdId, setHerdModules, setStatus, setUser, } from "../store/scout";
+import { server_load_herd_modules } from "../helpers/herds";
+import { server_get_user } from "../helpers/users";
+export function useScoutRefresh(options = {}) {
+    const { autoRefresh = true, onRefreshComplete } = options;
+    const dispatch = useAppDispatch();
+    const handleRefresh = async () => {
+        dispatch(setStatus(EnumScoutStateStatus.LOADING));
+        try {
+            const compatible_new_herd_modules = await server_load_herd_modules();
+            const res_new_user = await server_get_user();
+            dispatch(setHerdModules(compatible_new_herd_modules));
+            dispatch(setUser(res_new_user.data));
+            // Check local storage for a last selected herd
+            if (localStorage.getItem("last_selected_herd")) {
+                const found_herd = compatible_new_herd_modules.find((hm) => hm.herd.id.toString() === localStorage.getItem("last_selected_herd"))?.herd;
+                // If herd is found then set it
+                if (found_herd) {
+                    dispatch(setActiveHerdId(found_herd.id.toString()));
+                }
+            }
+            // If there is no last selected herd then select the first one
+            else if (compatible_new_herd_modules.length > 0) {
+                localStorage.setItem("last_selected_herd", compatible_new_herd_modules[0].herd.id.toString());
+                dispatch(setActiveHerdId(compatible_new_herd_modules[0].herd.id.toString()));
+            }
+            dispatch(setStatus(EnumScoutStateStatus.DONE_LOADING));
+            onRefreshComplete?.();
+        }
+        catch (error) {
+            console.error("Error refreshing scout data:", error);
+            dispatch(setStatus(EnumScoutStateStatus.DONE_LOADING));
+        }
+    };
+    useEffect(() => {
+        if (autoRefresh) {
+            handleRefresh();
+        }
+    }, [autoRefresh]);
+    return {
+        handleRefresh,
+    };
+}