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

package/composables/services/useAlerts.ts

@@ -1,19 +1,58 @@
-import { onUnmounted, ref } from "vue";
-
-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.addCustom("acknowledge", (axios, alertId: string) => axios.patch(ALERT_URL(alertId))),
-    factory.addNotify()
+    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);
+            return result;
+        })
+    }))
 ));
 
-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, AlertServiceFactory.acknowledge);
+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/useCustomPropertyValues.ts

@@ -1,41 +1,10 @@
-import { ref } from "vue";
-
-import { CustomPropertyValueDetails, CustomPropertyValueDetailsDTO, CustomPropertyValueInfos, CustomPropertyValueInfosDTO, PropertyEntity } from "@dative-gpi/foundation-core-domain/models";
-import { ServiceFactory } from "@dative-gpi/bones-ui";
+import { CustomPropertyValueInfos, CustomPropertyValueInfosDTO, PropertyEntity } from "@dative-gpi/foundation-core-domain/models";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
 import { CUSTOM_PROPERTY_VALUES_URL } from "../../config/urls";
 
-const CustomPropertyValueServiceFactory = new ServiceFactory<CustomPropertyValueDetailsDTO, CustomPropertyValueDetails>("customPropertyValue", CustomPropertyValueDetails).create(factory => factory.build(
-    factory.addNotify(() => ({
-        getMany: async (entity: PropertyEntity, entityId: string, code: string): Promise<CustomPropertyValueInfos[]> => {
-            const response = await ServiceFactory.http.get(CUSTOM_PROPERTY_VALUES_URL(entity, entityId, code));
-            const result = response.data.map((dto: CustomPropertyValueInfosDTO) => new CustomPropertyValueInfos(dto));
-
-            return result;
-        }
-    }))
-));
-
-export const useCustomPropertyValues = () => {
-    const service = CustomPropertyValueServiceFactory();
-
-    const fetching = ref(false);
-    const fetched = ref<CustomPropertyValueInfos[] | null>(null);
-
-    const fetch = async (entity: PropertyEntity, entityId: string, code: string) => {
-        fetching.value = true;
-        try {
-            fetched.value = await service.getMany(entity, entityId, code);
-        }
-        finally {
-            fetching.value = false;
-        }
-        return fetched;
-    }
+const CustomPropertyValueServiceFactory = {
+    ...ServiceFactory.addCustom("getMany", (axios, entity: PropertyEntity, entityId: string, code: string) => axios.get(CUSTOM_PROPERTY_VALUES_URL(entity, entityId, code)), (dtos: CustomPropertyValueInfosDTO[]) => dtos.map((dto: CustomPropertyValueInfosDTO) => new CustomPropertyValueInfos(dto))),
+};
 
-    return {
-        fetching,
-        fetch,
-        fetched
-    }
-}
+export const useCustomPropertyValues = ComposableFactory.custom(CustomPropertyValueServiceFactory.getMany);

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,25 +1,73 @@
-import { onUnmounted, ref } from "vue";
-
+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 { ComposableFactory, onEntityChanged , ServiceFactory } from "@dative-gpi/bones-ui";
 
 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.addCustom("changeGroup", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationGroupDTO) => axios.put(DEVICE_ORGANISATION_GROUP_URL(deviceOrganisationId), payload)),
-    factory.addCustom("changeLocation", (axios, deviceOrganisationId: string, payload: ChangeDeviceOrganisationLocationDTO) => axios.put(DEVICE_ORGANISATION_LOCATION_URL(deviceOrganisationId), payload)),
-    factory.addNotify()
-));
-
-export const useDeviceOrganisation = ComposableFactory.get(DeviceOrganisationServiceFactory);
-export const useDeviceOrganisations = ComposableFactory.getMany(DeviceOrganisationServiceFactory);
-export const useCreateDeviceOrganisation = ComposableFactory.create(DeviceOrganisationServiceFactory);
-export const useUpdateDeviceOrganisation = ComposableFactory.update(DeviceOrganisationServiceFactory);
+    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;
+      })
+    }))
+  ));
+
+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 useRemoveDeviceOrganisation = ComposableFactory.remove(DeviceOrganisationServiceFactory);
-export const useChangeDeviceOrganisationGroup = ComposableFactory.custom(DeviceOrganisationServiceFactory, DeviceOrganisationServiceFactory.changeGroup);
-export const useChangeDeviceOrganisationLocation = ComposableFactory.custom(DeviceOrganisationServiceFactory, 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/useGroups.ts

@@ -9,8 +9,13 @@ const GroupServiceFactory = new ServiceFactory<GroupDetailsDTO, GroupDetails>("g
     factory.addCreate<CreateGroupDTO>(GROUPS_URL),
     factory.addUpdate<UpdateGroupDTO>(GROUP_URL),
     factory.addRemove(GROUP_URL),
-    factory.addCustom("changeParent", (axios, groupdId: string, payload: ChangeGroupParentDTO) => axios.put(GROUP_URL(groupdId), payload)),
-    factory.addNotify()
+    factory.addNotify(notify => ({
+        ...ServiceFactory.addCustom("changeParent", (axios, groupdId: string, payload: ChangeGroupParentDTO) => axios.put(GROUP_URL(groupdId), payload), (dto: GroupDetailsDTO) => {
+            const result = new GroupDetails(dto);
+            notify.notify("update", result);
+            return result;
+        })
+    }))
 ));
 
 export const useGroup = ComposableFactory.get(GroupServiceFactory);
@@ -18,4 +23,4 @@ export const useGroups = ComposableFactory.getMany(GroupServiceFactory);
 export const useCreateGroup = ComposableFactory.create(GroupServiceFactory);
 export const useUpdateGroup = ComposableFactory.update(GroupServiceFactory);
 export const useRemoveGroup = ComposableFactory.remove(GroupServiceFactory);
-export const useChangeGroupParent = ComposableFactory.custom(GroupServiceFactory, GroupServiceFactory.changeParent);
+export const useChangeGroupParent = ComposableFactory.custom(GroupServiceFactory.changeParent);

package/composables/services/useOrganisations.ts

@@ -5,8 +5,13 @@ import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 import { ORGANISATION_DASHBOARD_URL } from "../../config/urls";
 
 const OrganisationServiceFactory = new ServiceFactory<OrganisationDetailsDTO, OrganisationDetails>("organisation", OrganisationDetails).create(factory => factory.build(
-    factory.addCustom("changeDashboard", (axios, payload: ChangeOrganisationDashboardDTO) => axios.put(ORGANISATION_DASHBOARD_URL(), payload)),
-    factory.addNotify()
+    factory.addNotify(notify => ({
+        ...ServiceFactory.addCustom("changeDashboard", (axios, payload: ChangeOrganisationDashboardDTO) => axios.put(ORGANISATION_DASHBOARD_URL(), payload), (dto: OrganisationDetailsDTO) => {
+            const result = new OrganisationDetails(dto);
+            notify.notify("update", result);
+            return result;
+        })
+    }))
 ));
 
-export const useChangeDashboardOrganisation = ComposableFactory.custom(OrganisationServiceFactory, OrganisationServiceFactory.changeDashboard);
+export const useChangeDashboardOrganisation = ComposableFactory.custom(OrganisationServiceFactory.changeDashboard);

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";
 
@@ -9,15 +10,32 @@ const UserOrganisationServiceFactory = new ServiceFactory<UserOrganisationDetail
     factory.addCreate<CreateUserOrganisationDTO>(USER_ORGANISATIONS_URL),
     factory.addUpdate<UpdateUserOrganisationDTO>(USER_ORGANISATION_URL),
     factory.addRemove(USER_ORGANISATION_URL),
-    factory.addCustom("getCurrent", (axios) => axios.get(USER_ORGANISATION_CURRENT_URL())),
-    factory.addCustom("updateCurrent", (axios, payload: UpdateUserOrganisationDTO) => axios.post(USER_ORGANISATION_CURRENT_URL(), payload)),
-    factory.addNotify()
+    ServiceFactory.addCustom("getCurrent", (axios) => axios.get(USER_ORGANISATION_CURRENT_URL()), (dto: UserOrganisationDetailsDTO) => new UserOrganisationDetails(dto)),
+    factory.addNotify(notify => ({
+        ...ServiceFactory.addCustom("updateCurrent", (axios, payload: UpdateUserOrganisationDTO) => axios.post(USER_ORGANISATION_CURRENT_URL(), payload), (dto: UserOrganisationDetailsDTO) => {
+            const result = new UserOrganisationDetails(dto)
+            notify.notify("update", result);
+            return result;
+        }),
+    }))
 ));
 
+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, UserOrganisationServiceFactory.getCurrent);
-export const useUpdateCurrentUserOrganisation = ComposableFactory.custom(UserOrganisationServiceFactory, 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.53",
+  "version": "0.0.55",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -10,11 +10,11 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/bones-ui": "^0.0.67",
-    "@dative-gpi/foundation-core-domain": "0.0.53",
+    "@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": "4ecd4c47590cb49ab9f480e12202cde9af5396e1"
+  "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,51 +0,0 @@
-import { onMounted, ref, watch } from "vue";
-
-import * as signalR from "@microsoft/signalr";
-
-import { useNotifyAlert, useNotifyRemoveAlert } from "../services/useAlerts";
-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,51 +0,0 @@
-import { onMounted, ref, watch } from "vue";
-
-import * as signalR from "@microsoft/signalr";
-
-import { useNotifyConnectivityAlert, useNotifyRemoveConnectivityAlert } from "../services/useConnectivityAlerts";
-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,49 +0,0 @@
-import { onMounted, ref, watch } from "vue";
-
-import * as signalR from "@microsoft/signalr";
-
-import { useNotifyDeviceConnectivity } from "../services/useDeviceConnectivities";
-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,49 +0,0 @@
-import { onMounted, ref, watch } from "vue";
-
-import * as signalR from "@microsoft/signalr";
-
-import { useNotifyDeviceStatus } from "../services/useDeviceStatuses";
-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
-    };
-}