@dative-gpi/foundation-core-services 0.1.120 → 1.0.0

package/composables/services/index.ts

@@ -1,12 +1,13 @@
 export * from "./useActions";
 export * from "./useAlerts";
 export * from "./useArticles";
-export * from "./useAuthTokens";
+export * from "./useChartCategories";
 export * from "./useChartOrganisationTypes";
 export * from "./useChartOrganisations";
 export * from "./useCharts";
 export * from "./useComments";
 export * from "./useConnectivityAlerts";
+export * from "./useConnectivityScenarios";
 export * from "./useCustomProperties";
 export * from "./useCustomPropertyValues";
 export * from "./useDashboardOrganisations";
@@ -15,6 +16,7 @@ export * from "./useDashboards";
 export * from "./useDashboardShallows";
 export * from "./useDataCategories";
 export * from "./useDataDefinitions";
+export * from "./useDataTables";
 export * from "./useDeviceConnectivities";
 export * from "./useDeviceOrganisations";
 export * from "./useDeviceStatuses";
@@ -23,12 +25,17 @@ export * from "./useGroups";
 export * from "./useLocations";
 export * from "./useManufacturers";
 export * from "./useModels";
+export * from "./useNotifications";
 export * from "./useOrganisations";
 export * from "./useOrganisationTypes";
 export * from "./usePermissionCategories";
 export * from "./useRoleOrganisations";
 export * from "./useRoleOrganisationTypes";
-export * from "./useServiceAccounts";
+export * from "./useScenarioDeviceOrganisations";
+export * from "./useScenarioOrganisations";
+export * from "./useScenarioOrganisationTypes";
+export * from "./useServiceAccountOrganisationAuthTokens";
+export * from "./useServiceAccountOrganisations";
 export * from "./useUserOrganisations";
 export * from "./useUserOrganisationTables";
 export * from "./useWidgetTemplates";

package/composables/services/useActions.ts

@@ -1,10 +1,11 @@
-import { ActionDetails, ActionDetailsDTO, ActionInfos, ActionInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+import type { ActionDetailsDTO, ActionFilters, ActionInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ActionDetails, ActionInfos } from "@dative-gpi/foundation-core-domain/models";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
 import { ACTIONS_URL } from "../../config/urls";
 
 const ActionServiceFactory = new ServiceFactory<ActionDetailsDTO, ActionDetails>("action", ActionDetails).create(factory => factory.build(
-    factory.addGetMany<ActionInfosDTO, ActionInfos, string>(ACTIONS_URL, ActionInfos),
+    factory.addGetMany<ActionInfosDTO, ActionInfos, ActionFilters>(ACTIONS_URL, ActionInfos),
     factory.addNotify()
 ));
 

package/composables/services/useAlerts.ts

@@ -1,57 +1,57 @@
-import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { AlertDetails, AlertDetailsDTO, AlertFilters, AlertInfos, AlertInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { AlertDetails, type AlertDetailsDTO, type AlertFilters, AlertInfos, type AlertInfosDTO } from "@dative-gpi/foundation-core-domain/models";
 import { HubFactory } from "@dative-gpi/foundation-shared-services/tools/hubFactory";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
-import { HUBS } from "../../config/literals";
 import { ALERTS_HUB_URL, ALERTS_URL, ALERT_URL } from "../../config/urls";
+import { HUBS } from "../../config/literals";
 
 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 => ({
-        notifyCreate: (alert: AlertDetails) => notifyService.notify("add", alert),
-        notifyUpdate: (alert: AlertDetails) => notifyService.notify("update", alert),
-        notifyRemove: (alertId: string) => notifyService.notify("delete", alertId),
-        ...ServiceFactory.addCustom("acknowledge", (axios, alertId: string) => axios.patch(ALERT_URL(alertId)), (dto: AlertDetailsDTO) => {
-            const result = new AlertDetails(dto);
-            notifyService.notify("update", result);
-            return result;
-        })
-    }))
+  factory.addGet(ALERT_URL),
+  factory.addGetMany<AlertInfosDTO, AlertInfos, AlertFilters>(ALERTS_URL, AlertInfos),
+  factory.addRemove(ALERT_URL),
+  factory.addNotify(notifyService => ({
+    notifyCreate: (alert: AlertDetails) => notifyService.notify("add", alert),
+    notifyUpdate: (alert: AlertDetails) => notifyService.notify("update", alert),
+    notifyRemove: (alertId: string) => notifyService.notify("delete", alertId),
+    ...ServiceFactory.addCustom("acknowledge", (axios, alertId: string) => axios.patch(ALERT_URL(alertId)), (dto: AlertDetailsDTO) => {
+      const result = new AlertDetails(dto);
+      notifyService.notify("update", result);
+      return result;
+    })
+  }))
 ));
 
 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);
-    }
+  (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);
-    }
+  const { watchOne } = useWatchAlerts();
+  return (alert) => {
+    watchOne(alert.value.id);
+  }
 });
 
 export const useAlerts = ComposableFactory.getMany(AlertServiceFactory, () => {
-    const { watchMany } = useWatchAlerts();
-    return () => {
-        watchMany();
-    }
+  const { watchMany } = useWatchAlerts();
+  return () => {
+    watchMany();
+  }
 });
 
 export const useRemoveAlert = ComposableFactory.remove(AlertServiceFactory);

package/composables/services/useArticles.ts

@@ -1,4 +1,5 @@
-import { ArticleDetails, ArticleDetailsDTO, ArticleFilters, ArticleInfos, ArticleInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { ArticleDetailsDTO, ArticleFilters, ArticleInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ArticleDetails, ArticleInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { ARTICLES_URL, ARTICLE_URL } from "../../config/urls";

package/composables/services/useChartCategories.ts

@@ -0,0 +1,14 @@
+import type { CreateChartCategoryDTO, ChartCategoryDetailsDTO, ChartCategoryFilters, ChartCategoryInfosDTO, UpdateChartCategoryDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ChartCategoryDetails, ChartCategoryInfos } from "@dative-gpi/foundation-core-domain/models";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+
+import { CHART_CATEGORIES_URL, CHART_CATEGORY_URL } from "../../config/urls";
+
+const ChartCategoryServiceFactory = new ServiceFactory<ChartCategoryDetailsDTO, ChartCategoryDetails>("chartCategory", ChartCategoryDetails)
+  .createComplete<ChartCategoryInfos, ChartCategoryInfosDTO, CreateChartCategoryDTO, UpdateChartCategoryDTO, ChartCategoryFilters>(CHART_CATEGORIES_URL, CHART_CATEGORY_URL, ChartCategoryInfos);
+
+export const useChartCategory = ComposableFactory.get(ChartCategoryServiceFactory);
+export const useChartCategories = ComposableFactory.getMany(ChartCategoryServiceFactory);
+export const useCreateChartCategory = ComposableFactory.create(ChartCategoryServiceFactory);
+export const useUpdateChartCategory = ComposableFactory.update(ChartCategoryServiceFactory);
+export const useRemoveChartCategory = ComposableFactory.remove(ChartCategoryServiceFactory);

package/composables/services/useChartOrganisationTypes.ts

@@ -1,7 +1,8 @@
+import type { ChartOrganisationTypeDetailsDTO, ChartOrganisationTypeFilters, ChartOrganisationTypeInfosDTO, CreateChartOrganisationTypeDTO, UpdateChartOrganisationTypeDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ChartOrganisationTypeDetails, ChartOrganisationTypeInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { CHART_ORGANISATION_TYPE_URL, CHART_ORGANISATION_TYPES_URL } from "../../config/urls";
-import { ChartOrganisationTypeDetails, ChartOrganisationTypeDetailsDTO, ChartOrganisationTypeFilters, ChartOrganisationTypeInfos, ChartOrganisationTypeInfosDTO, CreateChartOrganisationTypeDTO, UpdateChartOrganisationTypeDTO } from "@dative-gpi/foundation-core-domain/models";
 
+import { CHART_ORGANISATION_TYPE_URL, CHART_ORGANISATION_TYPES_URL } from "../../config/urls";
 
 const ChartOrganisationTypeServiceFactory = new ServiceFactory<ChartOrganisationTypeDetailsDTO, ChartOrganisationTypeDetails>("chartOrganisationType", ChartOrganisationTypeDetails)
   .createComplete<ChartOrganisationTypeInfos, ChartOrganisationTypeInfosDTO, CreateChartOrganisationTypeDTO, UpdateChartOrganisationTypeDTO, ChartOrganisationTypeFilters>(CHART_ORGANISATION_TYPES_URL, CHART_ORGANISATION_TYPE_URL, ChartOrganisationTypeInfos);
@@ -9,7 +10,7 @@ const ChartOrganisationTypeServiceFactory = new ServiceFactory<ChartOrganisation
 const ChartOrganisationTypeServiceFactoryIncomplete = new ServiceFactory("chartOrganisationType", ChartOrganisationTypeDetails)
   .create(factory => factory.build(
     factory.addNotify(notifyService => ({
-      ...ServiceFactory.addCustom("chartOrganisationType", (axios, charOrganisationTypeId: string) => axios.patch(CHART_ORGANISATION_TYPE_URL(charOrganisationTypeId)), (dto: ChartOrganisationTypeDetailsDTO) => {
+      ...ServiceFactory.addCustom("duplicate", (axios, charOrganisationTypeId: string) => axios.patch(CHART_ORGANISATION_TYPE_URL(charOrganisationTypeId)), (dto: ChartOrganisationTypeDetailsDTO) => {
         const result = new ChartOrganisationTypeDetails(dto);
         notifyService.notify("update", result);
         return result;
@@ -22,5 +23,4 @@ export const useChartOrganisationTypes = ComposableFactory.getMany(ChartOrganisa
 export const useCreateChartOrganisationType = ComposableFactory.create(ChartOrganisationTypeServiceFactory);
 export const useUpdateChartOrganisationType = ComposableFactory.update(ChartOrganisationTypeServiceFactory);
 export const useRemoveChartOrganisationType = ComposableFactory.remove(ChartOrganisationTypeServiceFactory);
-export const useDuplicateChartOrganisationType = ComposableFactory.custom(ChartOrganisationTypeServiceFactoryIncomplete.chartOrganisationType);
-
+export const useDuplicateChartOrganisationType = ComposableFactory.custom(ChartOrganisationTypeServiceFactoryIncomplete.duplicate);

package/composables/services/useChartOrganisations.ts

@@ -1,7 +1,8 @@
+import type { ChartOrganisationDetailsDTO, ChartOrganisationFilters, ChartOrganisationInfosDTO, CreateChartOrganisationDTO, UpdateChartOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ChartOrganisationDetails, ChartOrganisationInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { CHART_ORGANISATION_URL, CHART_ORGANISATIONS_URL } from "../../config/urls";
-import { ChartOrganisationDetails, ChartOrganisationDetailsDTO, ChartOrganisationFilters, ChartOrganisationInfos, ChartOrganisationInfosDTO, CreateChartOrganisationDTO, UpdateChartOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
 
+import { CHART_ORGANISATION_URL, CHART_ORGANISATIONS_URL } from "../../config/urls";
 
 const ChartOrganisationServiceFactory = new ServiceFactory<ChartOrganisationDetailsDTO, ChartOrganisationDetails>("chartOrganisation", ChartOrganisationDetails)
   .createComplete<ChartOrganisationInfos, ChartOrganisationInfosDTO, CreateChartOrganisationDTO, UpdateChartOrganisationDTO, ChartOrganisationFilters>(CHART_ORGANISATIONS_URL, CHART_ORGANISATION_URL, ChartOrganisationInfos);
@@ -9,7 +10,7 @@ const ChartOrganisationServiceFactory = new ServiceFactory<ChartOrganisationDeta
 const ChartOrganisationServiceFactoryIncomplete = new ServiceFactory("chartOrganisation", ChartOrganisationDetails)
   .create(factory => factory.build(
     factory.addNotify(notifyService => ({
-      ...ServiceFactory.addCustom("chartOrganisation", (axios, chartOrganisationId: string) => axios.patch(CHART_ORGANISATION_URL(chartOrganisationId)), (dto: ChartOrganisationDetailsDTO) => {
+      ...ServiceFactory.addCustom("duplicate", (axios, chartOrganisationId: string) => axios.patch(CHART_ORGANISATION_URL(chartOrganisationId)), (dto: ChartOrganisationDetailsDTO) => {
         const result = new ChartOrganisationDetails(dto);
         notifyService.notify("update", result);
         return result;
@@ -22,5 +23,4 @@ export const useChartOrganisations = ComposableFactory.getMany(ChartOrganisation
 export const useCreateChartOrganisation = ComposableFactory.create(ChartOrganisationServiceFactory);
 export const useUpdateChartOrganisation = ComposableFactory.update(ChartOrganisationServiceFactory);
 export const useRemoveChartOrganisation = ComposableFactory.remove(ChartOrganisationServiceFactory);
-export const useDuplicateChartOrganisation = ComposableFactory.custom(ChartOrganisationServiceFactoryIncomplete.chartOrganisation);
-
+export const useDuplicateChartOrganisation = ComposableFactory.custom(ChartOrganisationServiceFactoryIncomplete.duplicate);

package/composables/services/useCharts.ts

@@ -1,7 +1,9 @@
 
+import type { ChartDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ChartDetails } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+
 import { CHART_URL } from "../../config/urls";
-import { ChartDetails, ChartDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
 
 const ChartServiceFactory = new ServiceFactory<ChartDetailsDTO, ChartDetails>("chart", ChartDetails).create(factory => factory.build(
   factory.addGet(CHART_URL),

package/composables/services/useComments.ts

@@ -1,4 +1,5 @@
-import { CreateCommentDTO, CommentDetails, CommentDetailsDTO, CommentFilters, CommentInfos, CommentInfosDTO, UpdateCommentDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { CreateCommentDTO, CommentDetailsDTO, CommentFilters, CommentInfosDTO, UpdateCommentDTO } from "@dative-gpi/foundation-core-domain/models";
+import { CommentDetails, CommentInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { COMMENTS_URL, COMMENT_URL } from "../../config/urls";

package/composables/services/useConnectivityAlerts.ts

@@ -1,5 +1,6 @@
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { ConnectivityAlertDetails, ConnectivityAlertDetailsDTO, ConnectivityAlertFilters, ConnectivityAlertInfos, ConnectivityAlertInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { ConnectivityAlertDetailsDTO, ConnectivityAlertFilters, ConnectivityAlertInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ConnectivityAlertDetails, ConnectivityAlertInfos } from "@dative-gpi/foundation-core-domain/models";
 import { HubFactory } from "@dative-gpi/foundation-shared-services/tools/hubFactory";
 
 import { CONNECTIVITY_ALERTS_HUB_URL, CONNECTIVITY_ALERTS_URL, CONNECTIVITY_ALERT_URL } from "../../config/urls";
@@ -44,7 +45,7 @@ export const useConnectivityAlert = ComposableFactory.get(ConnectivityAlertServi
 
 export const useConnectivityAlerts = ComposableFactory.getMany(ConnectivityAlertServiceFactory, () => {
     const { watchMany } = useWatchConnectivityAlerts();
-    return (_alerts) => {
+    return () => {
         watchMany();
     }
 });

package/composables/services/useConnectivityScenarios.ts

@@ -0,0 +1,15 @@
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+import type { CreateConnectivityScenarioDTO, ConnectivityScenarioDetailsDTO, ConnectivityScenarioFilters, ConnectivityScenarioInfosDTO, UpdateConnectivityScenarioDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ConnectivityScenarioDetails, ConnectivityScenarioInfos } from "@dative-gpi/foundation-core-domain/models";
+
+import { CONNECTIVITY_SCENARIOS_URL, CONNECTIVITY_SCENARIO_URL } from "../../config";
+
+const ConnectivityScenarioServiceFactory = new ServiceFactory<ConnectivityScenarioDetailsDTO, ConnectivityScenarioDetails>("ConnectivityScenario", ConnectivityScenarioDetails)
+  .createComplete<ConnectivityScenarioInfos, ConnectivityScenarioInfosDTO, CreateConnectivityScenarioDTO, UpdateConnectivityScenarioDTO, ConnectivityScenarioFilters>(CONNECTIVITY_SCENARIOS_URL, CONNECTIVITY_SCENARIO_URL, ConnectivityScenarioInfos);
+
+export const useConnectivityScenario = ComposableFactory.get(ConnectivityScenarioServiceFactory);
+export const useConnectivityScenarios = ComposableFactory.getMany(ConnectivityScenarioServiceFactory);
+export const useCreateConnectivityScenario = ComposableFactory.create(ConnectivityScenarioServiceFactory);
+export const useUpdateConnectivityScenario = ComposableFactory.update(ConnectivityScenarioServiceFactory);
+export const useRemoveConnectivityScenario = ComposableFactory.remove(ConnectivityScenarioServiceFactory);
+

package/composables/services/useCustomProperties.ts

@@ -1,4 +1,5 @@
-import { CustomPropertyDetails, CustomPropertyDetailsDTO, CustomPropertyFilters, CustomPropertyInfos, CustomPropertyInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { CustomPropertyDetailsDTO, CustomPropertyFilters, CustomPropertyInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { CustomPropertyDetails, CustomPropertyInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { CUSTOM_PROPERTIES_URL } from "../../config/urls";

package/composables/services/useCustomPropertyValues.ts

@@ -1,4 +1,5 @@
-import { CustomPropertyValueInfos, CustomPropertyValueInfosDTO, PropertyEntity } from "@dative-gpi/foundation-core-domain/models";
+import type { CustomPropertyValueInfosDTO, PropertyEntity } from "@dative-gpi/foundation-core-domain/models";
+import { CustomPropertyValueInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { CUSTOM_PROPERTY_VALUES_URL } from "../../config/urls";

package/composables/services/useDashboardOrganisationTypes.ts

@@ -1,21 +1,39 @@
+import type { DashboardOrganisationTypeDetailsDTO, DashboardOrganisationTypeFilters, DashboardOrganisationTypeInfosDTO, LockDashboardOrganisationTypeDTO, PublishDashboardOrganisationTypeDTO, UpdateDashboardOrganisationTypeDTO } from "@dative-gpi/foundation-core-domain/models";
+import { DashboardOrganisationTypeDetails, DashboardOrganisationTypeInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { CreateDashboardOrganisationTypeDTO, DashboardOrganisationTypeDetails, DashboardOrganisationTypeDetailsDTO, DashboardOrganisationTypeFilters, DashboardOrganisationTypeInfos, DashboardOrganisationTypeInfosDTO, UpdateDashboardOrganisationTypeDTO } from "@dative-gpi/foundation-core-domain/models";
 
-import { DASHBOARD_ORGANISATION_TYPE_URL, DASHBOARD_ORGANISATION_TYPES_URL } from "../../config";
+import { DASHBOARD_ORGANISATION_TYPE_LOCK_URL, DASHBOARD_ORGANISATION_TYPE_URL, DASHBOARD_ORGANISATION_TYPES_URL } from "../../config";
 
 const DashboardOrganisationTypeServiceFactory = new ServiceFactory<DashboardOrganisationTypeDetailsDTO, DashboardOrganisationTypeDetails>("dashboardOrganisationType", DashboardOrganisationTypeDetails)
   .create(factory => factory.build(
     factory.addGet(DASHBOARD_ORGANISATION_TYPE_URL),
     factory.addGetMany<DashboardOrganisationTypeInfosDTO, DashboardOrganisationTypeInfos, DashboardOrganisationTypeFilters>(DASHBOARD_ORGANISATION_TYPES_URL, DashboardOrganisationTypeInfos),
-    factory.addCreate<CreateDashboardOrganisationTypeDTO>(DASHBOARD_ORGANISATION_TYPES_URL),
     factory.addUpdate<UpdateDashboardOrganisationTypeDTO>(DASHBOARD_ORGANISATION_TYPE_URL),
     factory.addRemove(DASHBOARD_ORGANISATION_TYPE_URL),
-    factory.addNotify()
+    factory.addNotify(notifyService => ({
+      ...ServiceFactory.addCustom("publish", (axios, payload: PublishDashboardOrganisationTypeDTO) => axios.post(DASHBOARD_ORGANISATION_TYPES_URL(), payload), (dto: DashboardOrganisationTypeDetailsDTO) => {
+        const result = new DashboardOrganisationTypeDetails(dto);
+        notifyService.notify("update", result);
+        return result;
+      }),
+      ...ServiceFactory.addCustom("duplicate", (axios, dashboardOrganisationTypeId: string) => axios.patch(DASHBOARD_ORGANISATION_TYPE_URL(dashboardOrganisationTypeId)), (dto: DashboardOrganisationTypeDetailsDTO) => {
+        const result = new DashboardOrganisationTypeDetails(dto);
+        notifyService.notify("update", result);
+        return result;
+      }),
+      ...ServiceFactory.addCustom("lock", (axios, dashboardOrganisationTypeId: string, payload: LockDashboardOrganisationTypeDTO) => axios.put(DASHBOARD_ORGANISATION_TYPE_LOCK_URL(dashboardOrganisationTypeId), payload), (dto: DashboardOrganisationTypeDetailsDTO) => {
+        const result = new DashboardOrganisationTypeDetails(dto);
+        notifyService.notify("update", result);
+        return result;
+      })
+    }))
   ));
 
 export const useDashboardOrganisationType = ComposableFactory.get(DashboardOrganisationTypeServiceFactory);
 export const useDashboardOrganisationTypes = ComposableFactory.getMany(DashboardOrganisationTypeServiceFactory);
-export const useCreateDashboardOrganisationType = ComposableFactory.create(DashboardOrganisationTypeServiceFactory);
 export const useUpdateDashboardOrganisationType = ComposableFactory.update(DashboardOrganisationTypeServiceFactory);
 export const useRemoveDashboardOrganisationType = ComposableFactory.remove(DashboardOrganisationTypeServiceFactory);
+export const usePublishDashboardOrganisationType = ComposableFactory.custom(DashboardOrganisationTypeServiceFactory.publish);
+export const useDuplicateDashboardOrganisationType = ComposableFactory.custom(DashboardOrganisationTypeServiceFactory.duplicate);
+export const useLockDashboardOrganisationType = ComposableFactory.custom(DashboardOrganisationTypeServiceFactory.lock);
 

package/composables/services/useDashboardOrganisations.ts

@@ -1,15 +1,31 @@
+import type { DashboardOrganisationDetailsDTO, DashboardOrganisationFilters, DashboardOrganisationInfosDTO, CreateDashboardOrganisationDTO, UpdateDashboardOrganisationDTO, LockDashboardOrganisationDTO, ChangeDashboardOrganisationFolderDTO } from "@dative-gpi/foundation-core-domain/models";
+import { DashboardOrganisationDetails, DashboardOrganisationInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { CreateDashboardOrganisationDTO, DashboardOrganisationDetails, DashboardOrganisationDetailsDTO, DashboardOrganisationFilters, DashboardOrganisationInfos, DashboardOrganisationInfosDTO, UpdateDashboardOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
-import { DASHBOARD_ORGANISATION_URL, DASHBOARD_ORGANISATIONS_URL } from "../../config";
+
+import { DASHBOARD_ORGANISATION_FOLDER_URL, DASHBOARD_ORGANISATION_LOCK_URL, DASHBOARD_ORGANISATION_URL, DASHBOARD_ORGANISATIONS_URL } from "../../config/urls";
 
 const DashboardOrganisationServiceFactory = new ServiceFactory<DashboardOrganisationDetailsDTO, DashboardOrganisationDetails>("dashboardOrganisation", DashboardOrganisationDetails)
+  .createComplete<DashboardOrganisationInfos, DashboardOrganisationInfosDTO, CreateDashboardOrganisationDTO, UpdateDashboardOrganisationDTO, DashboardOrganisationFilters>(DASHBOARD_ORGANISATIONS_URL, DASHBOARD_ORGANISATION_URL, DashboardOrganisationInfos);
+
+const DashboardOrganisationServiceFactoryIncomplete = new ServiceFactory("dashboardOrganisation", DashboardOrganisationDetails)
   .create(factory => factory.build(
-    factory.addGet(DASHBOARD_ORGANISATION_URL),
-    factory.addGetMany<DashboardOrganisationInfosDTO, DashboardOrganisationInfos, DashboardOrganisationFilters>(DASHBOARD_ORGANISATIONS_URL, DashboardOrganisationInfos),
-    factory.addCreate<CreateDashboardOrganisationDTO>(DASHBOARD_ORGANISATIONS_URL),
-    factory.addUpdate<UpdateDashboardOrganisationDTO>(DASHBOARD_ORGANISATION_URL),
-    factory.addRemove(DASHBOARD_ORGANISATION_URL),
-    factory.addNotify()
+    factory.addNotify(notifyService => ({
+      ...ServiceFactory.addCustom("duplicate", (axios, dashboardOrganisationId: string) => axios.patch(DASHBOARD_ORGANISATION_URL(dashboardOrganisationId)), (dto: DashboardOrganisationDetailsDTO) => {
+        const result = new DashboardOrganisationDetails(dto);
+        notifyService.notify("update", result);
+        return result;
+      }),
+      ...ServiceFactory.addCustom("lock", (axios, dashboardOrganisationId: string, payload: LockDashboardOrganisationDTO) => axios.put(DASHBOARD_ORGANISATION_LOCK_URL(dashboardOrganisationId), payload), (dto: DashboardOrganisationDetailsDTO) => {
+        const result = new DashboardOrganisationDetails(dto);
+        notifyService.notify("update", result);
+        return result;
+      }),
+      ...ServiceFactory.addCustom("changeFolder", (axios, dashboardOrganisationId: string, payload: ChangeDashboardOrganisationFolderDTO) => axios.put(DASHBOARD_ORGANISATION_FOLDER_URL(dashboardOrganisationId), payload), (dto: DashboardOrganisationDetailsDTO) => {
+        const result = new DashboardOrganisationDetails(dto);
+        notifyService.notify("update", result);
+        return result;
+      })
+    }))
   ));
 
 export const useDashboardOrganisation = ComposableFactory.get(DashboardOrganisationServiceFactory);
@@ -17,4 +33,6 @@ export const useDashboardOrganisations = ComposableFactory.getMany(DashboardOrga
 export const useCreateDashboardOrganisation = ComposableFactory.create(DashboardOrganisationServiceFactory);
 export const useUpdateDashboardOrganisation = ComposableFactory.update(DashboardOrganisationServiceFactory);
 export const useRemoveDashboardOrganisation = ComposableFactory.remove(DashboardOrganisationServiceFactory);
-
+export const useDuplicateDashboardOrganisation = ComposableFactory.custom(DashboardOrganisationServiceFactoryIncomplete.duplicate);
+export const useLockDashboardOrganisation = ComposableFactory.custom(DashboardOrganisationServiceFactoryIncomplete.lock);
+export const useChangeDashboardOrganisationFolder = ComposableFactory.custom(DashboardOrganisationServiceFactoryIncomplete.changeFolder);

package/composables/services/useDashboardShallows.ts

@@ -1,19 +1,32 @@
+import type { ChangeDashboardShallowFolderDTO, CreateDashboardShallowDTO, DashboardShallowDetailsDTO, DashboardShallowFilters, DashboardShallowInfosDTO, UpdateDashboardShallowDTO } from "@dative-gpi/foundation-core-domain/models";
+import { DashboardShallowDetails, DashboardShallowInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { CreateDashboardShallowDTO, DashboardShallowDetails, DashboardShallowDetailsDTO, DashboardShallowFilters, DashboardShallowInfos, DashboardShallowInfosDTO, UpdateDashboardShallowDTO } from "@dative-gpi/foundation-core-domain/models";
-import { DASHBOARD_SHALLOW_URL, DASHBOARD_SHALLOWS_URL } from "../../config/urls/dashboardShallows";
+
+import { DASHBOARD_SHALLOW_FOLDER_URL, DASHBOARD_SHALLOW_URL, DASHBOARD_SHALLOWS_URL } from "../../config/urls/dashboardShallows";
 
 const DashboardShallowServiceFactory = new ServiceFactory<DashboardShallowDetailsDTO, DashboardShallowDetails>("dashboardShallow", DashboardShallowDetails)
-    .create(factory => factory.build(
-        factory.addGet(DASHBOARD_SHALLOW_URL),
-        factory.addGetMany<DashboardShallowInfosDTO, DashboardShallowInfos, DashboardShallowFilters>(DASHBOARD_SHALLOWS_URL, DashboardShallowInfos),
-        factory.addCreate<CreateDashboardShallowDTO>(DASHBOARD_SHALLOWS_URL),
-        factory.addUpdate<UpdateDashboardShallowDTO>(DASHBOARD_SHALLOW_URL),
-        factory.addRemove(DASHBOARD_SHALLOW_URL),
-        factory.addNotify()
-    ));
+  .createComplete<DashboardShallowInfos, DashboardShallowInfosDTO, CreateDashboardShallowDTO, UpdateDashboardShallowDTO, DashboardShallowFilters>(DASHBOARD_SHALLOWS_URL, DASHBOARD_SHALLOW_URL, DashboardShallowInfos);
+
+const DashboardShallowServiceFactoryIncomplete = new ServiceFactory("dashboardShallow", DashboardShallowDetails)
+  .create(factory => factory.build(
+    factory.addNotify(notifyService => ({
+      ...ServiceFactory.addCustom("duplicate", (axios, dashboardShallowId: string) => axios.patch(DASHBOARD_SHALLOW_URL(dashboardShallowId)), (dto: DashboardShallowDetailsDTO) => {
+        const result = new DashboardShallowDetails(dto);
+        notifyService.notify("update", result);
+        return result;
+      }),
+      ...ServiceFactory.addCustom("changeFolder", (axios, dashboardShallowId: string, payload: ChangeDashboardShallowFolderDTO) => axios.put(DASHBOARD_SHALLOW_FOLDER_URL(dashboardShallowId), payload), (dto: DashboardShallowDetailsDTO) => {
+        const result = new DashboardShallowDetails(dto);
+        notifyService.notify("update", result);
+        return result;
+      })
+    }))
+  ));
 
 export const useDashboardShallow = ComposableFactory.get(DashboardShallowServiceFactory);
 export const useDashboardShallows = ComposableFactory.getMany(DashboardShallowServiceFactory);
 export const useCreateDashboardShallow = ComposableFactory.create(DashboardShallowServiceFactory);
 export const useUpdateDashboardShallow = ComposableFactory.update(DashboardShallowServiceFactory);
-export const useRemoveDashboardShallow = ComposableFactory.remove(DashboardShallowServiceFactory);
+export const useRemoveDashboardShallow = ComposableFactory.remove(DashboardShallowServiceFactory);
+export const useDuplicateDashboardShallow = ComposableFactory.custom(DashboardShallowServiceFactoryIncomplete.duplicate);
+export const useChangeDashboardShallowFolder = ComposableFactory.custom(DashboardShallowServiceFactoryIncomplete.changeFolder);

package/composables/services/useDashboards.ts

@@ -1,6 +1,7 @@
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
-import { DashboardDetails, DashboardDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { DashboardDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import { DashboardDetails } from "@dative-gpi/foundation-core-domain/models";
 
 import { DASHBOARD_CURRENT_URL } from "../../config";
 

package/composables/services/useDataCategories.ts

@@ -1,4 +1,5 @@
-import { DataCategoryDetails, DataCategoryDetailsDTO, DataCategoryFilters, DataCategoryInfos, DataCategoryInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { DataCategoryDetailsDTO, DataCategoryFilters, DataCategoryInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { DataCategoryDetails, DataCategoryInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { DATA_CATEGORIES_URL, DATA_CATEGORY_URL } from "../../config/urls";

package/composables/services/useDataDefinitions.ts

@@ -1,4 +1,5 @@
-import { DataDefinitionDetails, DataDefinitionDetailsDTO, DataDefinitionFilters, DataDefinitionInfos, DataDefinitionInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { DataDefinitionDetailsDTO, DataDefinitionFilters, DataDefinitionInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { DataDefinitionDetails, DataDefinitionInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { DATA_DEFINITIONS_URL, DATA_DEFINITION_URL } from "../../config/urls";

package/composables/services/useDataTables.ts

@@ -0,0 +1,90 @@
+import { ref, type Ref } from "vue";
+
+import { type UpdateUserOrganisationTableDTO, type UserOrganisationTableDetails } from "@dative-gpi/foundation-core-domain/models";
+import { type FSDataTable } from "@dative-gpi/foundation-shared-components/models";
+
+export const useDataTables = () => {
+  const initialized = ref(false);
+
+  const table = ref<FSDataTable>({
+    headers: [],
+    mode: "table",
+    sortBy: null,
+    rowsPerPage: 10,
+    filters: {},
+    page: 1
+  });
+
+  const computeTable = ((customSorts: { [key: string]: any }, customSortRaws: { [key: string]: any }) => ({
+    ...table.value,
+    headers: table.value.headers.map(header => ({
+      ...header,
+      sort: header.value && customSorts[header.value] || null,
+      sortRaw: header.value && customSortRaws[header.value] || null 
+    }))
+  }));
+
+  const updateTable = (
+    updateUserOrganisationTable: (id: string, payload: UpdateUserOrganisationTableDTO) => Promise<Ref<UserOrganisationTableDetails>>,
+    setTable: (tableCode: string, value: FSDataTable) => void,
+    tableCode: string
+  ): void => {
+    if (table.value) {
+      setTable(tableCode, table.value);
+      updateUserOrganisationTable(tableCode, {
+        columns: table.value.headers.map(column => ({
+          columnId: column.columnId,
+          hidden: column.hidden,
+          index: column.index
+        })),
+        rowsPerPage: table.value.rowsPerPage,
+        sortByKey: table.value.sortBy?.key ?? null,
+        sortByOrder: table.value.sortBy?.order ?? null,
+        mode: table.value.mode
+      });
+    }
+  };
+
+  const onTableCodeChange = async (
+    getUserOrganisationTable: (id: string) => Promise<Ref<UserOrganisationTableDetails | null>>,
+    getTable: (tableCode: string) => FSDataTable | null,
+    tableCode: string
+  ): Promise<void> => {
+    if (tableCode) {
+      const composableTable = getTable(tableCode);
+      if (composableTable) {
+        table.value = composableTable;
+      }
+      else {
+        try {
+          const userOrganisationTable = await getUserOrganisationTable(tableCode);
+          if (userOrganisationTable.value) {
+            table.value = {
+              headers: userOrganisationTable.value.columns,
+              sortBy: {
+                key: userOrganisationTable.value.sortByKey,
+                order: userOrganisationTable.value.sortByOrder
+              },
+              mode: userOrganisationTable.value.mode,
+              rowsPerPage: userOrganisationTable.value.rowsPerPage,
+              filters: {},
+              page: 1
+            }
+          }
+        }
+        catch {
+          // Do nothing
+        }
+      }
+    }
+    initialized.value = true;
+  };
+
+  return {
+    initialized,
+    table,
+    onTableCodeChange,
+    computeTable,
+    updateTable
+  };
+};

package/composables/services/useDeviceConnectivities.ts

@@ -1,5 +1,6 @@
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { DeviceConnectivityDetails, DeviceConnectivityDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { DeviceConnectivityDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import { DeviceConnectivityDetails } from "@dative-gpi/foundation-core-domain/models";
 import { HubFactory } from "@dative-gpi/foundation-shared-services/tools/hubFactory";
 
 import { DEVICE_CONNECTIVITIES_HUB_URL, DEVICE_CONNECTIVITY_URL } from "../../config/urls";

package/composables/services/useDeviceOrganisations.ts

@@ -1,6 +1,7 @@
-import { Ref } from "vue";
+import type { Ref } from "vue";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { ChangeDeviceOrganisationGroupDTO, ChangeDeviceOrganisationLocationDTO, CreateDeviceOrganisationDTO, DeviceOrganisationDetails, DeviceOrganisationDetailsDTO, DeviceOrganisationFilters, DeviceOrganisationInfos, DeviceOrganisationInfosDTO, UpdateDeviceOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { ChangeDeviceOrganisationGroupDTO, ChangeDeviceOrganisationLocationDTO, CreateDeviceOrganisationDTO, DeviceOrganisationDetailsDTO, DeviceOrganisationFilters, DeviceOrganisationInfosDTO, UpdateDeviceOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
+import { DeviceOrganisationDetails, DeviceOrganisationInfos } 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";
 

package/composables/services/useDeviceStatuses.ts

@@ -1,5 +1,6 @@
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { DeviceStatusDetails, DeviceStatusDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { DeviceStatusDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import { DeviceStatusDetails } from "@dative-gpi/foundation-core-domain/models";
 import { HubFactory } from "@dative-gpi/foundation-shared-services/tools/hubFactory";
 
 import { DEVICE_STATUSES_HUB_URL, DEVICE_STATUS_URL } from "../../config/urls";

package/composables/services/useFolders.ts

@@ -1,5 +1,6 @@
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { CreateFolderDTO, FolderDetails, FolderDetailsDTO, FolderFilters, FolderInfos, FolderInfosDTO, UpdateFolderDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { CreateFolderDTO, FolderDetailsDTO, FolderFilters, FolderInfosDTO, UpdateFolderDTO } from "@dative-gpi/foundation-core-domain/models";
+import { FolderDetails, FolderInfos } from "@dative-gpi/foundation-core-domain/models";
 
 import { FOLDER_URL, FOLDERS_URL } from "../../config";
 

package/composables/services/useGroups.ts

@@ -1,4 +1,5 @@
-import { ChangeGroupParentDTO, CreateGroupDTO, GroupDetails, GroupDetailsDTO, GroupFilters, GroupInfos, GroupInfosDTO, UpdateGroupDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { ChangeGroupParentDTO, CreateGroupDTO, GroupDetailsDTO, GroupFilters, GroupInfosDTO, UpdateGroupDTO } from "@dative-gpi/foundation-core-domain/models";
+import { GroupDetails, GroupInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { GROUPS_URL, GROUP_URL } from "../../config/urls";

package/composables/services/useLocations.ts

@@ -1,4 +1,4 @@
-import { CreateLocationDTO, LocationDetails, LocationDetailsDTO, LocationFilters, LocationInfos, LocationInfosDTO, UpdateLocationDTO } from "@dative-gpi/foundation-core-domain/models";
+import { type CreateLocationDTO, LocationDetails, type LocationDetailsDTO, type LocationFilters, LocationInfos, type LocationInfosDTO, type UpdateLocationDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { LOCATIONS_URL, LOCATION_URL } from "../../config/urls";

package/composables/services/useManufacturers.ts

@@ -1,4 +1,5 @@
-import { ManufacturerDetails, ManufacturerDetailsDTO, ManufacturerFilters, ManufacturerInfos, ManufacturerInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { ManufacturerDetailsDTO, ManufacturerFilters, ManufacturerInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ManufacturerDetails, ManufacturerInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { MANUFACTURERS_URL, MANUFACTURER_URL } from "../../config/urls";

package/composables/services/useModels.ts

@@ -1,4 +1,4 @@
-import { ModelDetails, ModelDetailsDTO, ModelFilters, ModelInfos, ModelInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ModelDetails, type ModelDetailsDTO, type ModelFilters, ModelInfos, type ModelInfosDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { MODELS_URL, MODEL_URL } from "../../config/urls";

package/composables/services/useNotifications.ts

@@ -0,0 +1,48 @@
+import { NotificationDetails, type NotificationDetailsDTO, NotificationInfos, type NotificationInfosDTO, type NotificationFilters } from "@dative-gpi/foundation-core-domain/models";
+import { HubFactory } from "@dative-gpi/foundation-shared-services/tools/hubFactory";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+
+import { NOTIFICATIONS_HUB_URL, NOTIFICATIONS_URL, NOTIFICATION_URL } from "../../config";
+import { HUBS } from "../../config/literals";
+
+const NotificationServiceFactory = new ServiceFactory<NotificationDetailsDTO, NotificationDetails>("notifications", NotificationDetails).create(factory => factory.build( 
+  factory.addGet(NOTIFICATION_URL),
+  factory.addGetMany<NotificationInfosDTO, NotificationInfos, NotificationFilters>(NOTIFICATIONS_URL, NotificationInfos),
+  factory.addNotify(notifyService => ({
+    notifyCreate: (notification: NotificationDetails) => notifyService.notify("add", notification),
+    ...ServiceFactory.addCustom("acknowledge", (axios, notificationId: string) => axios.patch(NOTIFICATION_URL(notificationId)), (dto: NotificationDetailsDTO) => {
+      const result = new NotificationDetails(dto);
+      notifyService.notify("update", result);
+      return result;
+    })
+  }))
+));
+
+const useNotificationsHub = HubFactory.create(NOTIFICATIONS_HUB_URL,
+    (connection, { hasWatchers }) => {
+        connection.on(HUBS.CREATE_NOTIFICATION, (notificationId: string) => hasWatchers()
+            ? NotificationServiceFactory.get(notificationId).then(NotificationServiceFactory.notifyCreate)
+            : null);
+    },
+    async (connection) => {
+        await connection.invoke(HUBS.SUBSCRIBE);
+    }
+);
+
+const useWatchNotifications = HubFactory.createWatcher(useNotificationsHub);
+
+export const useNotification = ComposableFactory.get(NotificationServiceFactory, () => {
+  const { watchOne } = useWatchNotifications();
+  return (notification) => {
+    watchOne(notification.value.id);
+  }
+});
+
+export const useNotifications = ComposableFactory.getMany(NotificationServiceFactory, () => {
+  const { watchMany } = useWatchNotifications();
+  return () => {
+    watchMany();
+  }
+});
+
+export const useAcknowledgeNotification = ComposableFactory.custom(NotificationServiceFactory.acknowledge);

package/composables/services/useOrganisationTypes.ts

@@ -1,4 +1,5 @@
-import { OrganisationTypeDetails, OrganisationTypeDetailsDTO, OrganisationTypeFilters, OrganisationTypeInfos, OrganisationTypeInfosDTO } from "@dative-gpi/foundation-shared-domain/models";
+import type { OrganisationTypeDetailsDTO, OrganisationTypeFilters, OrganisationTypeInfosDTO } from "@dative-gpi/foundation-shared-domain/models";
+import { OrganisationTypeDetails, OrganisationTypeInfos } from "@dative-gpi/foundation-shared-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { ORGANISATION_TYPES_URL, ORGANISATION_TYPE_URL } from "../../config/urls";

package/composables/services/useOrganisations.ts

@@ -1,5 +1,6 @@
-import { OrganisationDetails, OrganisationDetailsDTO } from "@dative-gpi/foundation-shared-domain/models";
-import { ChangeOrganisationDashboardDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { OrganisationDetailsDTO } from "@dative-gpi/foundation-shared-domain/models";
+import { OrganisationDetails } from "@dative-gpi/foundation-shared-domain/models";
+import type { ChangeOrganisationDashboardDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { ORGANISATION_DASHBOARD_URL } from "../../config/urls";

package/composables/services/usePermissionCategories.ts

@@ -1,4 +1,5 @@
-import { PermissionCategoryDetails, PermissionCategoryDetailsDTO, PermissionCategoryFilters, PermissionCategoryInfos, PermissionCategoryInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { PermissionCategoryDetailsDTO, PermissionCategoryFilters, PermissionCategoryInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { PermissionCategoryDetails, PermissionCategoryInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { PERMISSION_CATEGORIES_URL } from "../../config/urls";

package/composables/services/useRoleOrganisationTypes.ts

@@ -1,4 +1,5 @@
-import { RoleOrganisationTypeDetails, RoleOrganisationTypeDetailsDTO, RoleOrganisationTypeFilters, RoleOrganisationTypeInfos, RoleOrganisationTypeInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { RoleOrganisationTypeDetailsDTO, RoleOrganisationTypeFilters, RoleOrganisationTypeInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { RoleOrganisationTypeDetails, RoleOrganisationTypeInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { ROLE_ORGANISATION_TYPES_URL, ROLE_ORGANISATION_TYPE_URL } from "../../config/urls";

package/composables/services/useRoleOrganisations.ts

@@ -1,4 +1,5 @@
-import { CreateRoleOrganisationDTO, RoleOrganisationDetails, RoleOrganisationDetailsDTO, RoleOrganisationFilters, RoleOrganisationInfos, RoleOrganisationInfosDTO, UpdateRoleOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { CreateRoleOrganisationDTO, RoleOrganisationDetailsDTO, RoleOrganisationFilters, RoleOrganisationInfosDTO, UpdateRoleOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
+import { RoleOrganisationDetails, RoleOrganisationInfos } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { ROLE_ORGANISATIONS_URL, ROLE_ORGANISATION_URL } from "../../config/urls";

package/composables/services/useScenarioDeviceOrganisations.ts

@@ -0,0 +1,15 @@
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+import type { CreateScenarioDeviceOrganisationDTO, ScenarioDeviceOrganisationDetailsDTO, ScenarioDeviceOrganisationFilters, ScenarioDeviceOrganisationInfosDTO, UpdateScenarioDeviceOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ScenarioDeviceOrganisationDetails, ScenarioDeviceOrganisationInfos } from "@dative-gpi/foundation-core-domain/models";
+
+import { SCENARIO_DEVICE_ORGANISATIONS_URL, SCENARIO_DEVICE_ORGANISATION_URL } from "../../config";
+
+const ScenarioDeviceOrganisationServiceFactory = new ServiceFactory<ScenarioDeviceOrganisationDetailsDTO, ScenarioDeviceOrganisationDetails>("scenarioDeviceOrganisation", ScenarioDeviceOrganisationDetails)
+  .createComplete<ScenarioDeviceOrganisationInfos, ScenarioDeviceOrganisationInfosDTO, CreateScenarioDeviceOrganisationDTO, UpdateScenarioDeviceOrganisationDTO, ScenarioDeviceOrganisationFilters>(SCENARIO_DEVICE_ORGANISATIONS_URL, SCENARIO_DEVICE_ORGANISATION_URL, ScenarioDeviceOrganisationInfos);
+
+export const useScenarioDeviceOrganisation = ComposableFactory.get(ScenarioDeviceOrganisationServiceFactory);
+export const useScenarioDeviceOrganisations = ComposableFactory.getMany(ScenarioDeviceOrganisationServiceFactory);
+export const useCreateScenarioDeviceOrganisation = ComposableFactory.create(ScenarioDeviceOrganisationServiceFactory);
+export const useUpdateScenarioDeviceOrganisation = ComposableFactory.update(ScenarioDeviceOrganisationServiceFactory);
+export const useRemoveScenarioDeviceOrganisation = ComposableFactory.remove(ScenarioDeviceOrganisationServiceFactory);
+

package/composables/services/useScenarioOrganisationTypes.ts

@@ -0,0 +1,32 @@
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+import type { CreateScenarioOrganisationTypeDTO, ScenarioOrganisationTypeDetailsDTO, ScenarioOrganisationTypeFilters, ScenarioOrganisationTypeInfosDTO, UpdateScenarioOrganisationTypeDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ScenarioOrganisationTypeDetails, ScenarioOrganisationTypeInfos } from "@dative-gpi/foundation-core-domain/models";
+import { SCENARIO_ORGANISATION_TYPE_URL, SCENARIO_ORGANISATION_TYPES_URL } from "../../config/urls/scenarioOrganisationTypes";
+
+const ScenarioOrganisationTypeServiceFactory = new ServiceFactory<ScenarioOrganisationTypeDetailsDTO, ScenarioOrganisationTypeDetails>("scenarioOrganisationType", ScenarioOrganisationTypeDetails)
+    .create(factory => factory.build(
+        factory.addGet(SCENARIO_ORGANISATION_TYPE_URL),
+        factory.addGetMany<ScenarioOrganisationTypeInfosDTO, ScenarioOrganisationTypeInfos, ScenarioOrganisationTypeFilters>(SCENARIO_ORGANISATION_TYPES_URL, ScenarioOrganisationTypeInfos),
+        factory.addUpdate<UpdateScenarioOrganisationTypeDTO>(SCENARIO_ORGANISATION_TYPE_URL),
+        factory.addRemove(SCENARIO_ORGANISATION_TYPE_URL),
+        factory.addRemove(SCENARIO_ORGANISATION_TYPE_URL),
+        factory.addNotify(notifyService => ({
+            ...ServiceFactory.addCustom("duplicate", (axios, scenarioOrganisationTypeId: string) => axios.patch(SCENARIO_ORGANISATION_TYPE_URL(scenarioOrganisationTypeId)), (dto: ScenarioOrganisationTypeDetailsDTO) => {
+              const result = new ScenarioOrganisationTypeDetails(dto);
+              notifyService.notify("update", result);
+              return result;
+            }),
+            ...ServiceFactory.addCustom("publish", (axios, payload: CreateScenarioOrganisationTypeDTO) => axios.post(SCENARIO_ORGANISATION_TYPES_URL(), payload), (dto: ScenarioOrganisationTypeDetailsDTO) => {
+              const result = new ScenarioOrganisationTypeDetails(dto);
+              notifyService.notify("add", result);
+              return result;
+            })
+        }))
+    ));
+
+export const useScenarioOrganisationType = ComposableFactory.get(ScenarioOrganisationTypeServiceFactory);
+export const useScenarioOrganisationTypes = ComposableFactory.getMany(ScenarioOrganisationTypeServiceFactory);
+export const useUpdateScenarioOrganisationType = ComposableFactory.update(ScenarioOrganisationTypeServiceFactory);
+export const useRemoveScenarioOrganisationType = ComposableFactory.remove(ScenarioOrganisationTypeServiceFactory);
+export const useDuplicateScenarioOrganisationType = ComposableFactory.custom(ScenarioOrganisationTypeServiceFactory.duplicate);
+export const usePublishScenarioOrganisationType = ComposableFactory.custom(ScenarioOrganisationTypeServiceFactory.publish);

package/composables/services/useScenarioOrganisations.ts

@@ -0,0 +1,26 @@
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+import type { CreateScenarioOrganisationDTO, ScenarioOrganisationDetailsDTO, ScenarioOrganisationFilters, ScenarioOrganisationInfosDTO, UpdateScenarioOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ScenarioOrganisationDetails, ScenarioOrganisationInfos } from "@dative-gpi/foundation-core-domain/models";
+import { SCENARIO_ORGANISATION_URL, SCENARIO_ORGANISATIONS_URL } from "../../config/urls/scenarioOrganisations";
+
+
+const ScenarioOrganisationServiceFactory = new ServiceFactory<ScenarioOrganisationDetailsDTO, ScenarioOrganisationDetails>("scenarioOrganisation", ScenarioOrganisationDetails)
+  .createComplete<ScenarioOrganisationInfos, ScenarioOrganisationInfosDTO, CreateScenarioOrganisationDTO, UpdateScenarioOrganisationDTO, ScenarioOrganisationFilters>(SCENARIO_ORGANISATIONS_URL, SCENARIO_ORGANISATION_URL, ScenarioOrganisationInfos);
+  
+const ScenarioOrganisationServiceFactoryIncomplete = new ServiceFactory<ScenarioOrganisationDetailsDTO, ScenarioOrganisationDetails>("scenarioOrganisation", ScenarioOrganisationDetails)
+    .create(factory => factory.build(
+        factory.addNotify(notifyService => ({
+            ...ServiceFactory.addCustom("duplicate", (axios, scenarioOrganisationId: string) => axios.patch(SCENARIO_ORGANISATION_URL(scenarioOrganisationId)), (dto: ScenarioOrganisationDetailsDTO) => {
+              const result = new ScenarioOrganisationDetails(dto);
+              notifyService.notify("add", result);
+              return result;
+            })
+        })
+    )));
+
+export const useScenarioOrganisation = ComposableFactory.get(ScenarioOrganisationServiceFactory);
+export const useScenarioOrganisations = ComposableFactory.getMany(ScenarioOrganisationServiceFactory);
+export const useCreateScenarioOrganisation = ComposableFactory.create(ScenarioOrganisationServiceFactory);
+export const useUpdateScenarioOrganisation = ComposableFactory.update(ScenarioOrganisationServiceFactory);
+export const useRemoveScenarioOrganisation = ComposableFactory.remove(ScenarioOrganisationServiceFactory);
+export const useDuplicateScenarioOrganisation = ComposableFactory.custom(ScenarioOrganisationServiceFactoryIncomplete.duplicate);

package/composables/services/useServiceAccountOrganisationAuthTokens.ts

@@ -0,0 +1,20 @@
+import type { ServiceAccountOrganisationAuthTokenDetailsDTO, ServiceAccountOrganisationAuthTokenFilters, CreateServiceAccountOrganisationAuthTokenDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ServiceAccountOrganisationAuthTokenDetails } from "@dative-gpi/foundation-core-domain/models";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+
+import { SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKENS_URL, SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKEN_URL } from "../../config/urls";
+
+const ServiceAccountOrganisationAuthTokenServiceFactory = new ServiceFactory<ServiceAccountOrganisationAuthTokenDetailsDTO, ServiceAccountOrganisationAuthTokenDetails>("serviceAccountOrganisationAuthToken", ServiceAccountOrganisationAuthTokenDetails).create(factory => factory.build(
+    ServiceFactory.addCustom("getMany", (axios, serviceAccountOrganisationId: string, filters: ServiceAccountOrganisationAuthTokenFilters) => axios.get(SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKENS_URL(serviceAccountOrganisationId), filters), (dtos: ServiceAccountOrganisationAuthTokenDetailsDTO[]) => dtos.map((dto: ServiceAccountOrganisationAuthTokenDetailsDTO) => new ServiceAccountOrganisationAuthTokenDetails(dto))),
+    factory.addNotify(notifyService => ({
+        ...ServiceFactory.addCustom("create", (axios, serviceAccountOrganisationId: string, data: CreateServiceAccountOrganisationAuthTokenDTO) => axios.post(SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKENS_URL(serviceAccountOrganisationId), data), (dto: ServiceAccountOrganisationAuthTokenDetailsDTO) => {
+            const result = new ServiceAccountOrganisationAuthTokenDetails(dto);
+            notifyService.notify("add", result);
+        }),
+        ...ServiceFactory.addCustom("remove", (axios, serviceAccountOrganisationId: string, authTokenId: string) => axios.delete(SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKEN_URL(serviceAccountOrganisationId, authTokenId)), () => {})
+    }))
+));
+
+export const useServiceAccountOrganisationAuthTokens = ComposableFactory.custom(ServiceAccountOrganisationAuthTokenServiceFactory.getMany);
+export const useCreateServiceAccountOrganisationAuthToken = ComposableFactory.custom(ServiceAccountOrganisationAuthTokenServiceFactory.create);
+export const useRemoveServiceAccountOrganisationAuthToken = ComposableFactory.custom(ServiceAccountOrganisationAuthTokenServiceFactory.remove);

package/composables/services/useServiceAccountOrganisations.ts

@@ -0,0 +1,14 @@
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+import type { CreateServiceAccountOrganisationDTO, UpdateServiceAccountOrganisationDTO, ServiceAccountOrganisationDetailsDTO, ServiceAccountOrganisationFilters, ServiceAccountOrganisationInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { ServiceAccountOrganisationDetails, ServiceAccountOrganisationInfos } from "@dative-gpi/foundation-core-domain/models";
+
+import { SERVICE_ACCOUNT_ORGANISATIONS_URL, SERVICE_ACCOUNT_ORGANISATION_URL } from "../../config/urls";
+
+const ServiceAccountOrganisationServiceFactory = new ServiceFactory<ServiceAccountOrganisationDetailsDTO, ServiceAccountOrganisationDetails>("serviceAccountOrganisation", ServiceAccountOrganisationDetails)
+.createComplete<ServiceAccountOrganisationInfos, ServiceAccountOrganisationInfosDTO, CreateServiceAccountOrganisationDTO, UpdateServiceAccountOrganisationDTO, ServiceAccountOrganisationFilters>(SERVICE_ACCOUNT_ORGANISATIONS_URL, SERVICE_ACCOUNT_ORGANISATION_URL, ServiceAccountOrganisationInfos);
+
+export const useServiceAccountOrganisation = ComposableFactory.get(ServiceAccountOrganisationServiceFactory);
+export const useServiceAccountOrganisations = ComposableFactory.getMany(ServiceAccountOrganisationServiceFactory);
+export const useCreateServiceAccountOrganisation = ComposableFactory.create(ServiceAccountOrganisationServiceFactory);
+export const useUpdateServiceAccountOrganisation = ComposableFactory.update(ServiceAccountOrganisationServiceFactory);
+export const useRemoveServiceAccountOrganisation = ComposableFactory.remove(ServiceAccountOrganisationServiceFactory);

package/composables/services/useUserOrganisationTables.ts

@@ -1,4 +1,5 @@
-import { UserOrganisationTableDetails, UserOrganisationTableDetailsDTO, UpdateUserOrganisationTableDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { UserOrganisationTableDetailsDTO, UpdateUserOrganisationTableDTO } from "@dative-gpi/foundation-core-domain/models";
+import { UserOrganisationTableDetails } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { USER_ORGANISATION_TABLE_URL } from "../../config/urls";

package/composables/services/useUserOrganisations.ts

@@ -1,6 +1,7 @@
-import { Ref } from "vue";
+import type { Ref } from "vue";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { ChangeCurrentUserOrganisationDashboardDTO, CreateUserOrganisationDTO, UpdateUserOrganisationDTO, UserOrganisationDetails, UserOrganisationDetailsDTO, UserOrganisationFilters, UserOrganisationInfos, UserOrganisationInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { ChangeCurrentUserOrganisationDashboardDTO, CreateUserOrganisationDTO, UpdateUserOrganisationDTO, UserOrganisationDetailsDTO, UserOrganisationFilters, UserOrganisationInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { UserOrganisationDetails, UserOrganisationInfos } from "@dative-gpi/foundation-core-domain/models";
 
 import { USER_ORGANISATIONS_URL, USER_ORGANISATION_CURRENT_DASHBOARD_URL, USER_ORGANISATION_CURRENT_URL, USER_ORGANISATION_URL } from "../../config/urls";
 

package/composables/services/useWidgetTemplates.ts

@@ -1,4 +1,5 @@
-import { WidgetTemplateFilters, WidgetTemplateInfos, WidgetTemplateInfosDTO, WidgetTemplateDetails, WidgetTemplateDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import type { WidgetTemplateFilters, WidgetTemplateInfosDTO, WidgetTemplateDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
+import { WidgetTemplateInfos, WidgetTemplateDetails } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { WIDGET_TEMPLATES_URL, WIDGET_TEMPLATE_URL } from "../../config/urls";

package/config/literals/hubs.ts

@@ -11,4 +11,6 @@ export const REMOVE_ALERT = "RemoveAlert";
 
 export const CREATE_CONNECTIVITY_ALERT = "CreateConnectivityAlert";
 export const UPDATE_CONNECTIVITY_ALERT = "UpdateConnectivityAlert";
-export const REMOVE_CONNECTIVITY_ALERT = "RemoveConnectivityAlert";
+export const REMOVE_CONNECTIVITY_ALERT = "RemoveConnectivityAlert";
+
+export const CREATE_NOTIFICATION = "CreateNotification";

package/config/urls/chartCategories.ts

@@ -0,0 +1,4 @@
+import { CORE_URL } from "./base";
+
+export const CHART_CATEGORIES_URL = () => `${CORE_URL()}/chart-categories`;
+export const CHART_CATEGORY_URL = (chartCategoryId: string) => `${CHART_CATEGORIES_URL()}/${encodeURIComponent(chartCategoryId)}`;

package/config/urls/connectivityScenarios.ts

@@ -0,0 +1,4 @@
+import { CORE_URL } from "./base";
+
+export const CONNECTIVITY_SCENARIOS_URL = () => `${CORE_URL()}/connectivity-scenarios`;
+export const CONNECTIVITY_SCENARIO_URL = (connectivityScenarioId: string) => `${CONNECTIVITY_SCENARIOS_URL()}/${encodeURIComponent(connectivityScenarioId)}`;

package/config/urls/customPropertyValues.ts

@@ -1,4 +1,4 @@
-import { PropertyEntity } from "@dative-gpi/foundation-core-domain/models";
+import type { PropertyEntity } from "@dative-gpi/foundation-core-domain/models";
 
 import { CORE_URL } from "./base";
 

package/config/urls/index.ts

@@ -1,12 +1,13 @@
 export * from "./actions";
 export * from "./alerts";
 export * from "./articles";
-export * from "./authTokens";
 export * from "./charts";
+export * from "./chartCategories";
 export * from "./chartOrganisations";
 export * from "./chartOrganisationTypes";
 export * from "./comments";
 export * from "./connectivityAlerts";
+export * from "./connectivityScenarios";
 export * from "./customProperties";
 export * from "./customPropertyValues";
 export * from "./dashboardOrganisations";
@@ -22,13 +23,18 @@ export * from "./groups";
 export * from "./locations";
 export * from "./manufacturers";
 export * from "./models";
+export * from "./notifications";
 export * from "./organisations";
 export * from "./organisationTypes";
 export * from "./permissionCategories";
 export * from "./permissions";
 export * from "./roleOrganisations";
 export * from "./roleOrganisationTypes";
-export * from "./serviceAccounts";
+export * from "./scenarioDeviceOrganisations";
+export * from "./scenarioOrganisations";
+export * from "./scenarioOrganisationTypes";
+export * from "./serviceAccountOrganisationAuthTokens";
+export * from "./serviceAccountOrganisations";
 export * from "./userOrganisations";
 export * from "./userOrganisationTables";
 export * from "./widgetTemplates";

package/config/urls/notifications.ts

@@ -0,0 +1,6 @@
+import { CORE_URL, HUBS_URL } from "./base";
+
+export const NOTIFICATIONS_URL = () => `${CORE_URL()}/notifications`;
+export const NOTIFICATION_URL = (notificationId: string) => `${CORE_URL()}/notifications/${notificationId}`;
+
+export const NOTIFICATIONS_HUB_URL = () => `${HUBS_URL()}/notifications`;

package/config/urls/scenarioDeviceOrganisations.ts

@@ -0,0 +1,4 @@
+import { CORE_URL } from "./base";
+
+export const SCENARIO_DEVICE_ORGANISATIONS_URL = () => `${CORE_URL()}/scenario-device-organisations`;
+export const SCENARIO_DEVICE_ORGANISATION_URL = (scenarioDeviceOrganisation : string) => `${SCENARIO_DEVICE_ORGANISATIONS_URL()}/${encodeURIComponent(scenarioDeviceOrganisation)}`;

package/config/urls/scenarioOrganisationTypes.ts

@@ -0,0 +1,4 @@
+import { CORE_URL } from "./base";
+
+export const SCENARIO_ORGANISATION_TYPES_URL = () => `${CORE_URL()}/scenario-organisation-types`;
+export const SCENARIO_ORGANISATION_TYPE_URL = (scenarioOrganisationTypeId: string) => `${SCENARIO_ORGANISATION_TYPES_URL()}/${encodeURIComponent(scenarioOrganisationTypeId)}`;

package/config/urls/scenarioOrganisations.ts

@@ -0,0 +1,4 @@
+import { CORE_URL } from "./base";
+
+export const SCENARIO_ORGANISATIONS_URL = () => `${CORE_URL()}/scenario-organisations`;
+export const SCENARIO_ORGANISATION_URL = (scenarioOrganisationId: string) => `${SCENARIO_ORGANISATIONS_URL()}/${encodeURIComponent(scenarioOrganisationId)}`;

package/config/urls/serviceAccountOrganisationAuthTokens.ts

@@ -0,0 +1,5 @@
+import { SERVICE_ACCOUNT_ORGANISATION_URL } from "./serviceAccountOrganisations";
+
+
+export const SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKENS_URL = (serviceAccountOrganisationId: string) => `${SERVICE_ACCOUNT_ORGANISATION_URL(serviceAccountOrganisationId)}/pats`;
+export const SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKEN_URL = (serviceAccountOrganisationId: string, authTokenId: string) => `${SERVICE_ACCOUNT_ORGANISATION_AUTH_TOKENS_URL(serviceAccountOrganisationId)}/${encodeURIComponent(authTokenId)}`;

package/config/urls/serviceAccountOrganisations.ts

@@ -0,0 +1,4 @@
+import { CORE_URL } from "./base";
+
+export const SERVICE_ACCOUNT_ORGANISATIONS_URL = () => `${CORE_URL()}/service-account-organisations`;
+export const SERVICE_ACCOUNT_ORGANISATION_URL = (serviceAccountOrganisationId: string) => `${SERVICE_ACCOUNT_ORGANISATIONS_URL()}/${encodeURIComponent(serviceAccountOrganisationId)}`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dative-gpi/foundation-core-services",
   "sideEffects": false,
-  "version": "0.1.120",
+  "version": "1.0.0",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -10,11 +10,13 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/bones-ui": "^0.0.74",
-    "@dative-gpi/foundation-core-domain": "0.1.120",
+    "@dative-gpi/foundation-core-domain": "1.0.0"
+  },
+  "peerDependencies": {
+    "@dative-gpi/bones-ui": "^0.0.75",
     "@microsoft/signalr": "^8.0.0",
-    "vue": "^3.4.23",
-    "vue-router": "^4.2.5"
+    "vue": "^3.4.29",
+    "vue-router": "^4.3.0"
   },
-  "gitHead": "ea777a3a70e01d2b96981b2cb2e3da7b3af5f59c"
+  "gitHead": "93365f65d39d6c9cc3821ffb48cba187200deaf9"
 }

package/composables/services/useAuthTokens.ts

@@ -1,13 +0,0 @@
-import { AuthTokenDetails, AuthTokenDetailsDTO, AuthTokenFilters, AuthTokenInfos, AuthTokenInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-
-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.addRemove(AUTH_TOKEN_URL),
-    factory.addNotify()
-));
-
-export const useAuthTokens = ComposableFactory.getMany(AuthTokenServiceFactory);
-export const useRemoveAuthToken = ComposableFactory.remove(AuthTokenServiceFactory);

package/composables/services/useServiceAccounts.ts

@@ -1,13 +0,0 @@
-import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
-import { CreateServiceAccountDTO, UpdateServiceAccountDTO, ServiceAccountDetails, ServiceAccountDetailsDTO, ServiceAccountFilters, ServiceAccountInfos, ServiceAccountInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-
-import { SERVICE_ACCOUNTS_URL, SERVICE_ACCOUNT_URL } from "../../config/urls";
-
-const ServiceAccountServiceFactory = new ServiceFactory<ServiceAccountDetailsDTO, ServiceAccountDetails>("serviceAccount", ServiceAccountDetails)
-.createComplete<ServiceAccountInfos, ServiceAccountInfosDTO, CreateServiceAccountDTO, UpdateServiceAccountDTO, ServiceAccountFilters>(SERVICE_ACCOUNTS_URL, SERVICE_ACCOUNT_URL, ServiceAccountInfos);
-
-export const useServiceAccount = ComposableFactory.get(ServiceAccountServiceFactory);
-export const useServiceAccounts = ComposableFactory.getMany(ServiceAccountServiceFactory);
-export const useCreateServiceAccount = ComposableFactory.create(ServiceAccountServiceFactory);
-export const useUpdateServiceAccount = ComposableFactory.update(ServiceAccountServiceFactory);
-export const useRemoveServiceAccount = ComposableFactory.remove(ServiceAccountServiceFactory);

package/config/urls/authTokens.ts

@@ -1,4 +0,0 @@
-import { CORE_URL } from "./base";
-
-export const AUTH_TOKENS_URL = () => `${CORE_URL()}/pats`;
-export const AUTH_TOKEN_URL = (authTokenId: string) => `${AUTH_TOKENS_URL()}/${encodeURIComponent(authTokenId)}`;

package/config/urls/serviceAccounts.ts

@@ -1,4 +0,0 @@
-import { CORE_URL } from "./base";
-
-export const SERVICE_ACCOUNTS_URL = () => `${CORE_URL()}/service-accounts`;
-export const SERVICE_ACCOUNT_URL = (serviceAccountId: string) => `${SERVICE_ACCOUNTS_URL()}/${encodeURIComponent(serviceAccountId)}`;