@dative-gpi/foundation-core-services 0.0.2

package/composables/hubs/index.ts

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

package/composables/hubs/useAlertsHub.ts

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,49 @@
+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
+    };
+}

package/composables/index.ts

@@ -0,0 +1,5 @@
+export * from "./hubs";
+export * from "./services";
+export * from "./useLanguageCode";
+export * from "./useOrganisationId";
+export * from "./useTimeZone";

package/composables/services/index.ts

@@ -0,0 +1,27 @@
+export * from "./useAlerts";
+export * from "./useArticles";
+export * from "./useAuthTokens";
+export * from "./useConnectivityAlerts";
+export * from "./useCustomProperties";
+export * from "./useCustomPropertyValues";
+export * from "./useDataCategories";
+export * from "./useDataDefinitions";
+export * from "./useDeviceConnectivities";
+export * from "./useDeviceOrganisations";
+export * from "./useDeviceStatuses";
+export * from "./useFamilies";
+export * from "./useGroups";
+export * from "./useLanguages";
+export * from "./useLocations";
+export * from "./useManufacturers";
+export * from "./useModels";
+export * from "./useOrganisations";
+export * from "./useOrganisationTypes";
+export * from "./usePermissionCategories";
+export * from "./usePermissions";
+export * from "./useRoleOrganisations";
+export * from "./useRoleOrganisationTypes";
+export * from "./useTimeZones";
+export * from "./useTranslations";
+export * from "./useUserOrganisations";
+export * from "./useUsers";

package/composables/services/useAlerts.ts

@@ -0,0 +1,95 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { AlertDetails, AlertDetailsDTO, AlertFilters, AlertInfos, AlertInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, onEntityChanged , ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { 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((notifyService) => ({
+        acknowledge: async (alertId: string): Promise<AlertDetails> => {
+            const response = await ServiceFactory.http.patch(ALERT_URL(alertId));
+            const result = new AlertDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        },
+        getNotify: async (alertId: string): Promise<AlertDetails> => {
+            const response = await ServiceFactory.http.get(ALERT_URL(alertId));
+            const result = new AlertDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        },
+        removeNotify: (alertId: string): void => {
+            notifyService.notify("delete", alertId);
+        }
+    }))
+));
+
+export const useAlert = ComposableFactory.get(AlertServiceFactory);
+export const useAlerts = ComposableFactory.getMany(AlertServiceFactory);
+export const useRemoveAlert = ComposableFactory.remove(AlertServiceFactory);
+export const useAcknowledgeAlert = () => {
+    const service = AlertServiceFactory();
+
+    const changing = ref(false);
+    const changed = ref<AlertDetails | null>(null) as Ref<AlertDetails | null>;
+
+    const change = async (alertId: string) => {
+        changing.value = true;
+        try {
+            changed.value = await service.acknowledge(alertId);
+        }
+        finally {
+            changing.value = false;
+        }
+
+        const subscriberId = service.subscribe("all", onEntityChanged(changed))
+        onUnmounted(() => service.unsubscribe(subscriberId));
+
+        return readonly(changed as Ref<AlertDetails>);
+    }
+
+    return {
+        changing: readonly(changing),
+        change,
+        changed: readonly(changed)
+    };
+}
+export const useNotifyAlert = () => {
+    const service = AlertServiceFactory();
+
+    const fetching = ref(false);
+    const fetched = ref<AlertDetails | null>(null) as Ref<AlertDetails | null>;
+
+    const fetch = async (alertId: string) => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getNotify(alertId);
+        }
+        finally {
+            fetching.value = false;
+        }
+
+        return readonly(fetched as Ref<AlertDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    };
+}
+export const useNotifyRemoveAlert = () => {
+    const service = AlertServiceFactory();
+
+    return {
+        remove: service.removeNotify
+    };
+}

package/composables/services/useApplications.ts

@@ -0,0 +1,47 @@
+import { Ref, onUnmounted, readonly, ref } from "vue";
+
+import { ApplicationDetails, ApplicationDetailsDTO } from "@dative-gpi/foundation-core-domain";
+import { onEntityChanged, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { APPLICATION_CURRENT_URL } from "../../config/urls";
+
+const ApplicationServiceFactory = new ServiceFactory<ApplicationDetailsDTO, ApplicationDetails>("application", ApplicationDetails).create(factory => factory.build(
+    factory.addNotify((notifyService) => ({
+        getCurrent: async (): Promise<ApplicationDetails> => {
+            const response = await ServiceFactory.http.get(APPLICATION_CURRENT_URL);
+            const result = new ApplicationDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useCurrentApplication = () => {
+    const service = ApplicationServiceFactory();
+
+    const fetching = ref(false);
+    const fetched = ref<ApplicationDetails | null>(null) as Ref<ApplicationDetails | null>;
+
+    const fetch = async () => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getCurrent();
+        }
+        finally {
+            fetching.value = false;
+        }
+
+        const subscriberId = service.subscribe("all", onEntityChanged(fetched))
+        onUnmounted(() => service.unsubscribe(subscriberId));
+
+        return readonly(fetched as Ref<ApplicationDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}

package/composables/services/useArticles.ts

@@ -0,0 +1,13 @@
+import { ArticleDetails, ArticleDetailsDTO, ArticleFilters, ArticleInfos, ArticleInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { ARTICLES_URL, ARTICLE_URL } from "../../config/urls";
+
+const ArticleServiceFactory = new ServiceFactory<ArticleDetailsDTO, ArticleDetails>("article", ArticleDetails).create(factory => factory.build(
+    factory.addGet(ARTICLE_URL),
+    factory.addGetMany<ArticleInfosDTO, ArticleInfos, ArticleFilters>(ARTICLES_URL, ArticleInfos),
+    factory.addNotify()
+));
+
+export const useArticle = ComposableFactory.get(ArticleServiceFactory);
+export const useArticles = ComposableFactory.getMany(ArticleServiceFactory);

package/composables/services/useAuthTokens.ts

@@ -0,0 +1,15 @@
+import { AuthTokenDetails, AuthTokenDetailsDTO, AuthTokenFilters, AuthTokenInfos, AuthTokenInfosDTO, CreateAuthTokenDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { AUTH_TOKENS_URL, AUTH_TOKEN_URL } from "../../config/urls";
+
+const AuthTokenServiceFactory = new ServiceFactory<AuthTokenDetailsDTO, AuthTokenDetails>("authToken", AuthTokenDetails).create(factory => factory.build(
+    factory.addGetMany<AuthTokenInfosDTO, AuthTokenInfos, AuthTokenFilters>(AUTH_TOKENS_URL, AuthTokenInfos),
+    factory.addCreate<CreateAuthTokenDTO>(AUTH_TOKENS_URL),
+    factory.addRemove(AUTH_TOKEN_URL),
+    factory.addNotify()
+));
+
+export const useAuthTokens = ComposableFactory.getMany(AuthTokenServiceFactory);
+export const useCreateAuthToken = ComposableFactory.create(AuthTokenServiceFactory);
+export const useRemoveAuthToken = ComposableFactory.remove(AuthTokenServiceFactory);

package/composables/services/useConnectivityAlerts.ts

@@ -0,0 +1,60 @@
+import { Ref, readonly, ref } from "vue";
+
+import { ConnectivityAlertDetails, ConnectivityAlertDetailsDTO, ConnectivityAlertFilters, ConnectivityAlertInfos, ConnectivityAlertInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { CONNECTIVITY_ALERTS_URL, CONNECTIVITY_ALERT_URL } from "../../config/urls";
+
+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((notifyService) => ({
+        getNotify: async (connectivityAlertId: string): Promise<ConnectivityAlertDetails> => {
+            const response = await ServiceFactory.http.get(CONNECTIVITY_ALERT_URL(connectivityAlertId));
+            const result = new ConnectivityAlertDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        },
+        removeNotify: (connectivityAlertId: string): void => {
+            notifyService.notify("delete", connectivityAlertId);
+        }
+    }))
+));
+
+export const useConnectivityAlert = ComposableFactory.get(ConnectivityAlertServiceFactory);
+export const useConnectivityAlerts = ComposableFactory.getMany(ConnectivityAlertServiceFactory);
+export const useRemoveConnectivityAlert = ComposableFactory.remove(ConnectivityAlertServiceFactory);
+export const useNotifyConnectivityAlert = () => {
+    const service = ConnectivityAlertServiceFactory();
+
+    const fetching = ref(false);
+    const fetched = ref<ConnectivityAlertDetails | null>(null) as Ref<ConnectivityAlertDetails | null>;
+
+    const fetch = async (connectivityAlertId: string) => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getNotify(connectivityAlertId);
+        }
+        finally {
+            fetching.value = false;
+        }
+
+        return readonly(fetched as Ref<ConnectivityAlertDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        notified: readonly(fetched)
+    };
+}
+export const useNotifyRemoveConnectivityAlert = () => {
+    const service = ConnectivityAlertServiceFactory();
+
+    return {
+        remove: service.removeNotify
+    };
+}

package/composables/services/useCustomProperties.ts

@@ -0,0 +1,11 @@
+import { CustomPropertyDetails, CustomPropertyDetailsDTO, CustomPropertyFilters, CustomPropertyInfos, CustomPropertyInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { CUSTOM_PROPERTIES_URL } from "../../config/urls";
+
+const CustomPropertyServiceFactory = new ServiceFactory<CustomPropertyDetailsDTO, CustomPropertyDetails>("customProperty", CustomPropertyDetails).create(factory => factory.build(
+    factory.addGetMany<CustomPropertyInfosDTO, CustomPropertyInfos, CustomPropertyFilters>(CUSTOM_PROPERTIES_URL, CustomPropertyInfos),
+    factory.addNotify()
+));
+
+export const useCustomProperties = ComposableFactory.getMany(CustomPropertyServiceFactory);

package/composables/services/useCustomPropertyValues.ts

@@ -0,0 +1,42 @@
+import { Ref, readonly, ref } from "vue";
+
+import { CustomPropertyValueDetails, CustomPropertyValueDetailsDTO, CustomPropertyValueInfos, CustomPropertyValueInfosDTO, PropertyEntity } from "@dative-gpi/foundation-core-domain";
+import { 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) as Ref<CustomPropertyValueInfos[] | 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 readonly(fetched as Ref<CustomPropertyValueInfos[]>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    }
+}

package/composables/services/useDataCategories.ts

@@ -0,0 +1,13 @@
+import { DataCategoryDetails, DataCategoryDetailsDTO, DataCategoryFilters, DataCategoryInfos, DataCategoryInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { DATA_CATEGORIES_URL, DATA_CATEGORY_URL } from "../../config/urls";
+
+const DataCategoryServiceFactory = new ServiceFactory<DataCategoryDetailsDTO, DataCategoryDetails>("dataCategory", DataCategoryDetails).create(factory => factory.build(
+    factory.addGet(DATA_CATEGORY_URL),
+    factory.addGetMany<DataCategoryInfosDTO, DataCategoryInfos, DataCategoryFilters>(DATA_CATEGORIES_URL, DataCategoryInfos),
+    factory.addNotify()
+));
+
+export const useDataCategory = ComposableFactory.get(DataCategoryServiceFactory);
+export const useDataCategories = ComposableFactory.getMany(DataCategoryServiceFactory);

package/composables/services/useDataDefinitions.ts

@@ -0,0 +1,13 @@
+import { DataDefinitionDetails, DataDefinitionDetailsDTO, DataDefinitionFilters, DataDefinitionInfos, DataDefinitionInfosDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { DATA_DEFINITIONS_URL, DATA_DEFINITION_URL } from "../../config/urls";
+
+const DataDefinitionServiceFactory = new ServiceFactory<DataDefinitionDetailsDTO, DataDefinitionDetails>("dataDefinition", DataDefinitionDetails).create(factory => factory.build(
+    factory.addGet(DATA_DEFINITION_URL),
+    factory.addGetMany<DataDefinitionInfosDTO, DataDefinitionInfos, DataDefinitionFilters>(DATA_DEFINITIONS_URL, DataDefinitionInfos),
+    factory.addNotify()
+));
+
+export const useDataDefinition = ComposableFactory.get(DataDefinitionServiceFactory);
+export const useDataDefinitions = ComposableFactory.getMany(DataDefinitionServiceFactory);

package/composables/services/useDeviceConnectivities.ts

@@ -0,0 +1,46 @@
+import { Ref, readonly, ref } from "vue";
+
+import { DeviceConnectivityDetails, DeviceConnectivityDetailsDTO } from "@dative-gpi/foundation-core-domain";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { DEVICE_CONNECTIVITY_URL } from "../../config/urls";
+
+const DeviceConnectivityServiceFactory = new ServiceFactory<DeviceConnectivityDetailsDTO, DeviceConnectivityDetails>("deviceConnectivity", DeviceConnectivityDetails).create(factory => factory.build(
+    factory.addGet(DEVICE_CONNECTIVITY_URL),
+    factory.addNotify((notifyService) => ({
+        getNotify: async (deviceConnectivityId: string): Promise<DeviceConnectivityDetails> => {
+            const response = await ServiceFactory.http.get(DEVICE_CONNECTIVITY_URL(deviceConnectivityId));
+            const result = new DeviceConnectivityDetails(response.data);
+
+            notifyService.notify("update", result);
+
+            return result;
+        }
+    }))
+));
+
+export const useDeviceConnectivity = ComposableFactory.get(DeviceConnectivityServiceFactory);
+export const useNotifyDeviceConnectivity = () => {
+    const service = DeviceConnectivityServiceFactory();
+
+    const fetching = ref(false);
+    const fetched = ref<DeviceConnectivityDetails | null>(null) as Ref<DeviceConnectivityDetails | null>;
+
+    const fetch = async (deviceConnectivityId: string) => {
+        fetching.value = true;
+        try {
+            fetched.value = await service.getNotify(deviceConnectivityId);
+        }
+        finally {
+            fetching.value = false;
+        }
+
+        return readonly(fetched as Ref<DeviceConnectivityDetails>);
+    }
+
+    return {
+        fetching: readonly(fetching),
+        fetch,
+        fetched: readonly(fetched)
+    };
+}