@dative-gpi/foundation-core-services 0.0.54 → 0.0.55

package/composables/services/useAlerts.ts

@@ -1,13 +1,18 @@
-import { AlertDetails, AlertDetailsDTO, AlertFilters, AlertInfos, AlertInfosDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+import { AlertDetails, AlertDetailsDTO, AlertFilters, AlertInfos, AlertInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { HubFactory } from "@dative-gpi/foundation-shared-services/tools/hubFactory";
 
-import { ALERTS_URL, ALERT_URL } from "../../config/urls";
+import { HUBS } from "../../config/literals";
+import { ALERTS_HUB_URL, ALERTS_URL, ALERT_URL } from "../../config/urls";
 
 const AlertServiceFactory = new ServiceFactory<AlertDetailsDTO, AlertDetails>("alert", AlertDetails).create(factory => factory.build(
     factory.addGet(ALERT_URL),
     factory.addGetMany<AlertInfosDTO, AlertInfos, AlertFilters>(ALERTS_URL, AlertInfos),
     factory.addRemove(ALERT_URL),
     factory.addNotify(notify => ({
+        notifyCreate: (alert: AlertDetails) => notify.notify("add", alert),
+        notifyUpdate: (alert: AlertDetails) => notify.notify("update", alert),
+        notifyRemove: (alertId: string) => notify.notify("delete", alertId),
         ...ServiceFactory.addCustom("acknowledge", (axios, alertId: string) => axios.patch(ALERT_URL(alertId)), (dto: AlertDetailsDTO) => {
             const result = new AlertDetails(dto);
             notify.notify("update", result);
@@ -16,7 +21,38 @@ const AlertServiceFactory = new ServiceFactory<AlertDetailsDTO, AlertDetails>("a
     }))
 ));
 
-export const useAlert = ComposableFactory.get(AlertServiceFactory);
-export const useAlerts = ComposableFactory.getMany(AlertServiceFactory);
+const useAlertsHub = HubFactory.create(ALERTS_HUB_URL,
+    (connection, { isWatched, hasWatchers }) => {
+        connection.on(HUBS.CREATE_ALERT, (alertId: string) => hasWatchers()
+            ? AlertServiceFactory.get(alertId).then(AlertServiceFactory.notifyCreate)
+            : null);
+        connection.on(HUBS.UPDATE_ALERT, (alertId: string) => isWatched(alertId) || hasWatchers()
+            ? AlertServiceFactory.get(alertId).then(AlertServiceFactory.notifyUpdate)
+            : null);
+        connection.on(HUBS.REMOVE_ALERT, (alertId: string) => hasWatchers()
+            ? AlertServiceFactory.notifyRemove(alertId)
+            : null);
+    },
+    async (connection) => {
+        await connection.invoke(HUBS.SUBSCRIBE);
+    }
+);
+
+const useWatchAlerts = HubFactory.createWatcher(useAlertsHub);
+
+export const useAlert = ComposableFactory.get(AlertServiceFactory, () => {
+    const { watchOne } = useWatchAlerts();
+    return (alert) => {
+        watchOne(alert.value.id)
+    }
+});
+
+export const useAlerts = ComposableFactory.getMany(AlertServiceFactory, () => {
+    const { watchMany } = useWatchAlerts();
+    return (_alert) => {
+        watchMany();
+    }
+});
+
 export const useRemoveAlert = ComposableFactory.remove(AlertServiceFactory);
 export const useAcknowledgeAlert = ComposableFactory.custom(AlertServiceFactory.acknowledge);

package/composables/services/useConnectivityAlerts.ts

@@ -1,15 +1,52 @@
-import { ConnectivityAlertDetails, ConnectivityAlertDetailsDTO, ConnectivityAlertFilters, ConnectivityAlertInfos, ConnectivityAlertInfosDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+import { ConnectivityAlertDetails, ConnectivityAlertDetailsDTO, ConnectivityAlertFilters, ConnectivityAlertInfos, ConnectivityAlertInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { HubFactory } from "@dative-gpi/foundation-shared-services/tools/hubFactory";
 
-import { CONNECTIVITY_ALERTS_URL, CONNECTIVITY_ALERT_URL } from "../../config/urls";
+import { CONNECTIVITY_ALERTS_HUB_URL, CONNECTIVITY_ALERTS_URL, CONNECTIVITY_ALERT_URL } from "../../config/urls";
+import { HUBS } from "../../config/literals";
 
 const ConnectivityAlertServiceFactory = new ServiceFactory<ConnectivityAlertDetailsDTO, ConnectivityAlertDetails>("connectivityAlert", ConnectivityAlertDetails).create(factory => factory.build(
     factory.addGet(CONNECTIVITY_ALERT_URL),
     factory.addGetMany<ConnectivityAlertInfosDTO, ConnectivityAlertInfos, ConnectivityAlertFilters>(CONNECTIVITY_ALERTS_URL, ConnectivityAlertInfos),
     factory.addRemove(CONNECTIVITY_ALERT_URL),
-    factory.addNotify()
+    factory.addNotify(notify => ({
+        notifyCreate: (alert: ConnectivityAlertDetails) => notify.notify("add", alert),
+        notifyUpdate: (alert: ConnectivityAlertDetails) => notify.notify("update", alert),
+        notifyRemove: (alertId: string) => notify.notify("delete", alertId),
+    }))
 ));
 
-export const useConnectivityAlert = ComposableFactory.get(ConnectivityAlertServiceFactory);
-export const useConnectivityAlerts = ComposableFactory.getMany(ConnectivityAlertServiceFactory);
+const useConnectivityAlertsHub = HubFactory.create(CONNECTIVITY_ALERTS_HUB_URL,
+    (connection, { isWatched, hasWatchers }) => {
+        connection.on(HUBS.CREATE_CONNECTIVITY_ALERT, (alertId: string) => hasWatchers()
+            ? ConnectivityAlertServiceFactory.get(alertId).then(ConnectivityAlertServiceFactory.notifyCreate)
+            : null);
+        connection.on(HUBS.UPDATE_CONNECTIVITY_ALERT, (alertId: string) => isWatched(alertId) || hasWatchers()
+            ? ConnectivityAlertServiceFactory.get(alertId).then(ConnectivityAlertServiceFactory.notifyCreate)
+            : null);
+        connection.on(HUBS.REMOVE_CONNECTIVITY_ALERT, (alertId: string) => hasWatchers()
+            ? ConnectivityAlertServiceFactory.notifyRemove(alertId)
+            : null);
+    },
+    async (connection) => {
+        await connection.invoke(HUBS.SUBSCRIBE);
+    }
+);
+
+const useWatchConnectivityAlerts = HubFactory.createWatcher(useConnectivityAlertsHub);
+
+export const useConnectivityAlert = ComposableFactory.get(ConnectivityAlertServiceFactory, () => {
+    const { watchOne } = useWatchConnectivityAlerts();
+    return (alert) => {
+        watchOne(alert.value.id)
+    }
+});
+
+export const useConnectivityAlerts = ComposableFactory.getMany(ConnectivityAlertServiceFactory, () => {
+    const { watchMany } = useWatchConnectivityAlerts();
+    return (_alerts) => {
+        watchMany();
+    }
+});
+
 export const useRemoveConnectivityAlert = ComposableFactory.remove(ConnectivityAlertServiceFactory);

package/composables/services/useDeviceConnectivities.ts

@@ -1,11 +1,27 @@
-import { DeviceConnectivityDetails, DeviceConnectivityDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+import { DeviceConnectivityDetails, DeviceConnectivityDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import { HubFactory } from "@dative-gpi/foundation-shared-services/tools/hubFactory";
 
-import { DEVICE_CONNECTIVITY_URL } from "../../config/urls";
+import { DEVICE_CONNECTIVITIES_HUB_URL, DEVICE_CONNECTIVITY_URL } from "../../config/urls";
+import { HUBS } from "../../config/literals";
 
 const DeviceConnectivityServiceFactory = new ServiceFactory<DeviceConnectivityDetailsDTO, DeviceConnectivityDetails>("deviceConnectivity", DeviceConnectivityDetails).create(factory => factory.build(
     factory.addGet(DEVICE_CONNECTIVITY_URL),
-    factory.addNotify()
+    factory.addNotify(notify => ({
+        notifyUpdate: (connectivity: DeviceConnectivityDetails) => notify.notify("update", connectivity)
+    }))
 ));
 
-export const useDeviceConnectivity = ComposableFactory.get(DeviceConnectivityServiceFactory);
+const useDeviceConnectivityHub = HubFactory.create(DEVICE_CONNECTIVITIES_HUB_URL,
+    (connection) => {
+        connection.on(HUBS.UPDATE_DEVICE_CONNECTIVITY,
+            (payload: DeviceConnectivityDetailsDTO) => DeviceConnectivityServiceFactory.notifyUpdate(new DeviceConnectivityDetails(payload)));
+    },
+    async (connection) => {
+        await connection.invoke(HUBS.SUBSCRIBE);
+    }
+);
+
+export const useDeviceConnectivity = ComposableFactory.get(DeviceConnectivityServiceFactory);
+export const useTrackDeviceConnectivity = ComposableFactory.track(DeviceConnectivityServiceFactory);
+export const useWatchDeviceConnectivity = HubFactory.createWatcher(useDeviceConnectivityHub);

package/composables/services/useDeviceOrganisations.ts

@@ -1,32 +1,73 @@
-import { ChangeDeviceOrganisationGroupDTO, ChangeDeviceOrganisationLocationDTO, CreateDeviceOrganisationDTO, DeviceOrganisationDetails, DeviceOrganisationDetailsDTO, DeviceOrganisationFilters, DeviceOrganisationInfos, DeviceOrganisationInfosDTO, UpdateDeviceOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
+import { Ref } from "vue";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+import { ChangeDeviceOrganisationGroupDTO, ChangeDeviceOrganisationLocationDTO, CreateDeviceOrganisationDTO, DeviceOrganisationDetails, DeviceOrganisationDetailsDTO, DeviceOrganisationFilters, DeviceOrganisationInfos, DeviceOrganisationInfosDTO, UpdateDeviceOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
 
 import { DEVICE_ORGANISATIONS_URL, DEVICE_ORGANISATION_URL, DEVICE_ORGANISATION_GROUP_URL, DEVICE_ORGANISATION_LOCATION_URL } from "../../config/urls";
 
-const DeviceOrganisationServiceFactory = new ServiceFactory<DeviceOrganisationDetailsDTO, DeviceOrganisationDetails>("deviceOrganisation", DeviceOrganisationDetails).create(factory => factory.build(
+import { useTrackDeviceStatuses, useWatchDeviceStatuses } from "./useDeviceStatuses";
+import { useTrackDeviceConnectivity, useWatchDeviceConnectivity } from "./useDeviceConnectivities";
+
+const DeviceOrganisationServiceFactory = new ServiceFactory<DeviceOrganisationDetailsDTO, DeviceOrganisationDetails>("deviceOrganisation", DeviceOrganisationDetails)
+  .create(factory => factory.build(
     factory.addGet(DEVICE_ORGANISATION_URL),
     factory.addGetMany<DeviceOrganisationInfosDTO, DeviceOrganisationInfos, DeviceOrganisationFilters>(DEVICE_ORGANISATIONS_URL, DeviceOrganisationInfos),
     factory.addCreate<CreateDeviceOrganisationDTO>(DEVICE_ORGANISATIONS_URL),
     factory.addUpdate<UpdateDeviceOrganisationDTO>(DEVICE_ORGANISATION_URL),
     factory.addRemove(DEVICE_ORGANISATION_URL),
     factory.addNotify(notify => ({
-        ...ServiceFactory.addCustom("changeGroup", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationGroupDTO) => axios.put(DEVICE_ORGANISATION_GROUP_URL(deviceOrganisationId), payload), (dto: DeviceOrganisationDetailsDTO) => {
-            const result = new DeviceOrganisationDetails(dto);
-            notify.notify("update", result);
-            return result;
-        }),
-        ...ServiceFactory.addCustom("changeLocation", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationLocationDTO) => axios.put(DEVICE_ORGANISATION_LOCATION_URL(deviceOrganisationId), payload), (dto: DeviceOrganisationDetailsDTO) => {
-            const result = new DeviceOrganisationDetails(dto);
-            notify.notify("update", result);
-            return result;
-        })
+      ...ServiceFactory.addCustom("changeGroup", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationGroupDTO) => axios.put(DEVICE_ORGANISATION_GROUP_URL(deviceOrganisationId), payload), (dto: DeviceOrganisationDetailsDTO) => {
+        const result = new DeviceOrganisationDetails(dto);
+        notify.notify("update", result);
+        return result;
+      }),
+      ...ServiceFactory.addCustom("changeLocation", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationLocationDTO) => axios.put(DEVICE_ORGANISATION_LOCATION_URL(deviceOrganisationId), payload), (dto: DeviceOrganisationDetailsDTO) => {
+        const result = new DeviceOrganisationDetails(dto);
+        notify.notify("update", result);
+        return result;
+      })
     }))
-));
+  ));
+
+const trackDeviceOrganisation = () => {
+  const { track: trackDeviceStatuses } = useTrackDeviceStatuses();
+  const { track: trackDeviceConnectivity } = useTrackDeviceConnectivity();
+
+  const { watchOne: watchDeviceStatuses } = useWatchDeviceStatuses();
+  const { watchOne: watchDeviceConnectivity } = useWatchDeviceConnectivity();
+
+  return (deviceOrganisation: Ref<DeviceOrganisationDetails>) => {
+    watchDeviceStatuses(deviceOrganisation.value.status.id);
+    watchDeviceConnectivity(deviceOrganisation.value.connectivity.id);
+
+    trackDeviceStatuses(deviceOrganisation.value.status, s => deviceOrganisation.value.status = s);
+    trackDeviceConnectivity(deviceOrganisation.value.connectivity, c => deviceOrganisation.value.connectivity = c);
+  }
+};
+
+const trackDeviceOrganisations = () => {
+  const { track: trackDeviceStatuses } = useTrackDeviceStatuses();
+  const { track: trackDeviceConnectivity } = useTrackDeviceConnectivity();
+
+  const { watchMany: watchDevicesStatuses } = useWatchDeviceStatuses();
+  const { watchMany: watchDevicesConnectivity } = useWatchDeviceConnectivity();
+
+  return (deviceOrganisations: Ref<DeviceOrganisationInfos[]>) => {
+    watchDevicesStatuses();
+    watchDevicesConnectivity();
+
+    for (const deviceOrganisation of deviceOrganisations.value) {
+      trackDeviceStatuses(deviceOrganisation.status, s => deviceOrganisation.status = s);
+      trackDeviceConnectivity(deviceOrganisation.connectivity, c => deviceOrganisation.connectivity = c);
+    }
+  }
+}
+
+export const useDeviceOrganisation = ComposableFactory.get(DeviceOrganisationServiceFactory, trackDeviceOrganisation);
+export const useDeviceOrganisations = ComposableFactory.getMany(DeviceOrganisationServiceFactory, trackDeviceOrganisations);
+export const useCreateDeviceOrganisation = ComposableFactory.create(DeviceOrganisationServiceFactory, trackDeviceOrganisation);
+export const useUpdateDeviceOrganisation = ComposableFactory.update(DeviceOrganisationServiceFactory, trackDeviceOrganisation);
 
-export const useDeviceOrganisation = ComposableFactory.get(DeviceOrganisationServiceFactory);
-export const useDeviceOrganisations = ComposableFactory.getMany(DeviceOrganisationServiceFactory);
-export const useCreateDeviceOrganisation = ComposableFactory.create(DeviceOrganisationServiceFactory);
-export const useUpdateDeviceOrganisation = ComposableFactory.update(DeviceOrganisationServiceFactory);
 export const useRemoveDeviceOrganisation = ComposableFactory.remove(DeviceOrganisationServiceFactory);
-export const useChangeDeviceOrganisationGroup = ComposableFactory.custom(DeviceOrganisationServiceFactory.changeGroup);
-export const useChangeDeviceOrganisationLocation = ComposableFactory.custom(DeviceOrganisationServiceFactory.changeLocation);
+
+export const useChangeDeviceOrganisationGroup = ComposableFactory.custom(DeviceOrganisationServiceFactory.changeGroup, trackDeviceOrganisation);
+export const useChangeDeviceOrganisationLocation = ComposableFactory.custom(DeviceOrganisationServiceFactory.changeLocation, trackDeviceOrganisation);

package/composables/services/useDeviceStatuses.ts

@@ -1,11 +1,27 @@
-import { DeviceStatusDetails, DeviceStatusDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+import { DeviceStatusDetails, DeviceStatusDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import { HubFactory } from "@dative-gpi/foundation-shared-services/tools/hubFactory";
 
-import { DEVICE_STATUS_URL } from "../../config/urls";
+import { DEVICE_STATUSES_HUB_URL, DEVICE_STATUS_URL } from "../../config/urls";
+import { HUBS } from "../../config/literals";
 
 const DeviceStatusServiceFactory = new ServiceFactory<DeviceStatusDetailsDTO, DeviceStatusDetails>("deviceStatus", DeviceStatusDetails).create(factory => factory.build(
     factory.addGet(DEVICE_STATUS_URL),
-    factory.addNotify()
+    factory.addNotify(notify => ({
+        notifyUpdate: (status: DeviceStatusDetails) => notify.notify("update", status)
+    }))
 ));
 
-export const useDeviceStatus = ComposableFactory.get(DeviceStatusServiceFactory);
+const useDeviceStatusesHub = HubFactory.create(DEVICE_STATUSES_HUB_URL,
+    (connection) => {
+        connection.on(HUBS.UPDATE_DEVICE_STATUS,
+            (payload: DeviceStatusDetailsDTO) => DeviceStatusServiceFactory.notifyUpdate(new DeviceStatusDetails(payload)));
+    },
+    async (connection) => {
+        await connection.invoke(HUBS.SUBSCRIBE);
+    }
+);
+
+export const useDeviceStatus = ComposableFactory.get(DeviceStatusServiceFactory);
+export const useTrackDeviceStatuses = ComposableFactory.track(DeviceStatusServiceFactory);
+export const useWatchDeviceStatuses = HubFactory.createWatcher(useDeviceStatusesHub);

package/composables/services/useUserOrganisations.ts

@@ -1,5 +1,6 @@
-import { CreateUserOrganisationDTO, UpdateUserOrganisationDTO, UserOrganisationDetails, UserOrganisationDetailsDTO, UserOrganisationFilters, UserOrganisationInfos, UserOrganisationInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { Ref } from "vue";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+import { CreateUserOrganisationDTO, UpdateUserOrganisationDTO, UserOrganisationDetails, UserOrganisationDetailsDTO, UserOrganisationFilters, UserOrganisationInfos, UserOrganisationInfosDTO } from "@dative-gpi/foundation-core-domain/models";
 
 import { USER_ORGANISATIONS_URL, USER_ORGANISATION_CURRENT_URL, USER_ORGANISATION_URL } from "../../config/urls";
 
@@ -20,17 +21,21 @@ const UserOrganisationServiceFactory = new ServiceFactory<UserOrganisationDetail
 ));
 
 export const useTrackUserOrganisation = ComposableFactory.track(UserOrganisationServiceFactory);
+export const useTrackUserOrganisationRef = ComposableFactory.trackRef(UserOrganisationServiceFactory);
+
+const trackUserOrganisation = () => {
+    const { track } = useTrackUserOrganisationRef();
+
+    return (userOrganisation: Ref<UserOrganisationDetails>) => {
+        track(userOrganisation);
+    }
+}
 
 export const useUserOrganisation = ComposableFactory.get(UserOrganisationServiceFactory);
 export const useUserOrganisations = ComposableFactory.getMany(UserOrganisationServiceFactory);
 export const useCreateUserOrganisation = ComposableFactory.create(UserOrganisationServiceFactory);
 export const useUpdateUserOrganisation = ComposableFactory.update(UserOrganisationServiceFactory);
 export const useRemoveUserOrganisation = ComposableFactory.remove(UserOrganisationServiceFactory);
-export const useCurrentUserOrganisation = ComposableFactory.custom(UserOrganisationServiceFactory.getCurrent, () => {
-    const { track } = useTrackUserOrganisation();
- 
-    return (userOrganisation) => {
-        track(userOrganisation);
-    }
-});
-export const useUpdateCurrentUserOrganisation = ComposableFactory.custom(UserOrganisationServiceFactory.updateCurrent);
+
+export const useCurrentUserOrganisation = ComposableFactory.custom(UserOrganisationServiceFactory.getCurrent, trackUserOrganisation);
+export const useUpdateCurrentUserOrganisation = ComposableFactory.custom(UserOrganisationServiceFactory.updateCurrent, trackUserOrganisation);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dative-gpi/foundation-core-services",
   "sideEffects": false,
-  "version": "0.0.54",
+  "version": "0.0.55",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -10,11 +10,11 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/bones-ui": "^0.0.70",
-    "@dative-gpi/foundation-core-domain": "0.0.54",
+    "@dative-gpi/bones-ui": "^0.0.73",
+    "@dative-gpi/foundation-core-domain": "0.0.55",
     "@microsoft/signalr": "^8.0.0",
     "vue": "^3.2.0",
     "vue-router": "^4.2.5"
   },
-  "gitHead": "391503e595cd9d731fca14b5bb2d3a10b6efee95"
+  "gitHead": "c7ec3fb302319a1f49bb44f60c288eda9dec57d6"
 }

package/composables/hubs/index.ts

@@ -1,4 +0,0 @@
-export * from "./useAlertsHub";
-export * from "./useConnectivityAlertsHub";
-export * from "./useDeviceConnectivitiesHub";
-export * from "./useDeviceStatusesHub";

package/composables/hubs/useAlertsHub.ts

@@ -1,50 +0,0 @@
-import { onMounted, ref, watch } from "vue";
-
-import * as signalR from "@microsoft/signalr";
-
-import { ALERTS_HUB_URL } from "../../config/urls";
-import { HUBS } from "../../config/literals";
-
-let initialized = false;
-
-const connection = ref<signalR.HubConnection | null>(null);
-
-export const useAlertsHub = () => {
-    if (!initialized) {
-        onMounted(async () => {
-            if (!connection.value) {
-                connection.value = new signalR.HubConnectionBuilder()
-                    .withUrl(ALERTS_HUB_URL())
-                    .configureLogging(signalR.LogLevel.Warning)
-                    .withAutomaticReconnect()
-                    .build(); 
-            }
-            if (connection.value.state !== signalR.HubConnectionState.Connected) {
-                await connection.value.start();
-            }
-            connection.value.invoke(HUBS.SUBSCRIBE);
-            // connection.value.on(HUBS.CREATE_ALERT, (alertId: string) => useNotifyAlert().fetch(alertId));
-            // connection.value.on(HUBS.UPDATE_ALERT, (alertId: string) => useNotifyAlert().fetch(alertId));
-            // connection.value.on(HUBS.REMOVE_ALERT, (alertId: string) => useNotifyRemoveAlert().remove(alertId));
-        });
-
-        initialized = true;
-    }
-
-    const ready = new Promise((resolve) => {
-        if (connection.value && connection.value.state === signalR.HubConnectionState.Connected) {
-            resolve(true);
-        }
-        else {
-            watch(connection, () => {
-                if (connection.value && connection.value.state === signalR.HubConnectionState.Connected) {
-                    resolve(true);
-                }
-            });
-        }
-    });
-
-    return {
-        ready
-    };
-}

package/composables/hubs/useConnectivityAlertsHub.ts

@@ -1,50 +0,0 @@
-import { onMounted, ref, watch } from "vue";
-
-import * as signalR from "@microsoft/signalr";
-
-import { CONNECTIVITY_ALERTS_HUB_URL } from "../../config/urls";
-import { HUBS } from "../../config/literals";
-
-let initialized = false;
-
-const connection = ref<signalR.HubConnection | null>(null);
-
-export const useConnectivityAlertsHub = () => {
-    if (!initialized) {
-        onMounted(async () => {
-            if (!connection.value) {
-                connection.value = new signalR.HubConnectionBuilder()
-                    .withUrl(CONNECTIVITY_ALERTS_HUB_URL())
-                    .configureLogging(signalR.LogLevel.Warning)
-                    .withAutomaticReconnect()
-                    .build(); 
-            }
-            if (connection.value.state !== signalR.HubConnectionState.Connected) {
-                await connection.value.start();
-            }
-            connection.value.invoke(HUBS.SUBSCRIBE);
-            // connection.value.on(HUBS.CREATE_CONNECTIVITY_ALERT, (connectivityAlertId: string) => useNotifyConnectivityAlert().fetch(connectivityAlertId));
-            // connection.value.on(HUBS.UPDATE_CONNECTIVITY_ALERT, (connectivityAlertId: string) => useNotifyConnectivityAlert().fetch(connectivityAlertId));
-            // connection.value.on(HUBS.REMOVE_CONNECTIVITY_ALERT, (connectivityAlertId: string) => useNotifyRemoveConnectivityAlert().remove(connectivityAlertId));
-        });
-
-        initialized = true;
-    }
-
-    const ready = new Promise((resolve) => {
-        if (connection.value && connection.value.state === signalR.HubConnectionState.Connected) {
-            resolve(true);
-        }
-        else {
-            watch(connection, () => {
-                if (connection.value && connection.value.state === signalR.HubConnectionState.Connected) {
-                    resolve(true);
-                }
-            });
-        }
-    });
-
-    return {
-        ready
-    };
-}

package/composables/hubs/useDeviceConnectivitiesHub.ts

@@ -1,48 +0,0 @@
-import { onMounted, ref, watch } from "vue";
-
-import * as signalR from "@microsoft/signalr";
-
-import { DEVICE_CONNECTIVITIES_HUB_URL } from "../../config/urls";
-import { HUBS } from "../../config/literals";
-
-let initialized = false;
-
-const connection = ref<signalR.HubConnection | null>(null);
-
-export const useDeviceConnectivitiesHub = () => {
-    if (!initialized) {
-        onMounted(async () => {
-            if (!connection.value) {
-                connection.value = new signalR.HubConnectionBuilder()
-                    .withUrl(DEVICE_CONNECTIVITIES_HUB_URL())
-                    .configureLogging(signalR.LogLevel.Warning)
-                    .withAutomaticReconnect()
-                    .build(); 
-            }
-            if (connection.value.state !== signalR.HubConnectionState.Connected) {
-                await connection.value.start();
-            }
-            connection.value.invoke(HUBS.SUBSCRIBE);
-            // connection.value.on(HUBS.UPDATE_DEVICE_CONNECTIVITY, (deviceOrganisationId: string) => useNotifyDeviceConnectivity().fetch(deviceOrganisationId));
-        });
-
-        initialized = true;
-    }
-
-    const ready = new Promise((resolve) => {
-        if (connection.value && connection.value.state === signalR.HubConnectionState.Connected) {
-            resolve(true);
-        }
-        else {
-            watch(connection, () => {
-                if (connection.value && connection.value.state === signalR.HubConnectionState.Connected) {
-                    resolve(true);
-                }
-            });
-        }
-    });
-
-    return {
-        ready
-    };
-}

package/composables/hubs/useDeviceStatusesHub.ts

@@ -1,48 +0,0 @@
-import { onMounted, ref, watch } from "vue";
-
-import * as signalR from "@microsoft/signalr";
-
-import { DEVICE_STATUSES_HUB_URL } from "../../config/urls";
-import { HUBS } from "../../config/literals";
-
-let initialized = false;
-
-const connection = ref<signalR.HubConnection | null>(null);
-
-export const useDeviceStatusesHub = () => {
-    if (!initialized) {
-        onMounted(async () => {
-            if (!connection.value) {
-                connection.value = new signalR.HubConnectionBuilder()
-                    .withUrl(DEVICE_STATUSES_HUB_URL())
-                    .configureLogging(signalR.LogLevel.Warning)
-                    .withAutomaticReconnect()
-                    .build(); 
-            }
-            if (connection.value.state !== signalR.HubConnectionState.Connected) {
-                await connection.value.start();
-            }
-            connection.value.invoke(HUBS.SUBSCRIBE);
-            // connection.value.on(HUBS.UPDATE_DEVICE_STATUS, (deviceOrganisationId: string) => useNotifyDeviceStatus().fetch(deviceOrganisationId));
-        });
-
-        initialized = true;
-    }
-
-    const ready = new Promise((resolve) => {
-        if (connection.value && connection.value.state === signalR.HubConnectionState.Connected) {
-            resolve(true);
-        }
-        else {
-            watch(connection, () => {
-                if (connection.value && connection.value.state === signalR.HubConnectionState.Connected) {
-                    resolve(true);
-                }
-            });
-        }
-    });
-
-    return {
-        ready
-    };
-}