@dative-gpi/foundation-core-services 0.0.229 → 0.1.68

package/composables/app/index.ts

@@ -1 +1,2 @@
-export * from "./useAppOrganisationId";
+export * from "./useAppOrganisationId";
+export * from "./useEntityId";

package/composables/app/useEntityId.ts

@@ -0,0 +1,19 @@
+import { ref, watch } from "vue";
+import { useRouter } from "vue-router";
+
+import { ENTITY_ID } from "../../config";
+
+export const useEntityId = () => {
+    const entityId = ref<string | null>(null);
+
+    const router = useRouter();
+
+    watch(router.currentRoute, () => {
+        const id = router.currentRoute.value.params[ENTITY_ID] as string | null;
+        if(id) {
+            entityId.value = id;
+        }
+    }, { immediate: true })
+
+    return { entityId }
+}

package/composables/index.ts

@@ -1,3 +1,4 @@
 export * from "./app";
 export * from "./services";
-export * from "./useFoundationCore";
+export * from "./useFoundationCore";
+export * from "./useRouteOrganisation";

package/composables/services/index.ts

@@ -25,7 +25,6 @@ export * from "./useGroups";
 export * from "./useLocations";
 export * from "./useManufacturers";
 export * from "./useModels";
-export * from "./useNotifications";
 export * from "./useOrganisations";
 export * from "./useOrganisationTypes";
 export * from "./usePermissionCategories";
@@ -36,6 +35,7 @@ export * from "./useScenarioOrganisations";
 export * from "./useScenarioOrganisationTypes";
 export * from "./useServiceAccountOrganisationAuthTokens";
 export * from "./useServiceAccountOrganisations";
+export * from "./useServiceAccountRoleOrganisations";
 export * from "./useUserOrganisations";
 export * from "./useUserOrganisationTables";
 export * from "./useWidgetTemplates";

package/composables/services/useActions.ts

@@ -1,12 +1,11 @@
-import type { ActionDetailsDTO, ActionFilters, ActionInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { ActionDetails, ActionInfos } from "@dative-gpi/foundation-core-domain/models";
+import { ActionDetails, type ActionDetailsDTO, type ActionFilters, ActionInfos, type ActionInfosDTO } 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, ActionFilters>(ACTIONS_URL, ActionInfos),
-    factory.addNotify()
+  factory.addGetMany<ActionInfosDTO, ActionInfos, ActionFilters>(ACTIONS_URL, ActionInfos),
+  factory.addNotify()
 ));
 
 export const useActions = ComposableFactory.getMany(ActionServiceFactory);

package/composables/services/useAlerts.ts

@@ -1,9 +1,9 @@
 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 "@dative-gpi/foundation-shared-services/config";
 
 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),

package/composables/services/useArticles.ts

@@ -1,13 +1,12 @@
-import type { ArticleDetailsDTO, ArticleFilters, ArticleInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { ArticleDetails, ArticleInfos } from "@dative-gpi/foundation-core-domain/models";
+import { ArticleDetails, type ArticleDetailsDTO, type ArticleFilters, ArticleInfos, type ArticleInfosDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 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()
+  factory.addGet(ARTICLE_URL),
+  factory.addGetMany<ArticleInfosDTO, ArticleInfos, ArticleFilters>(ARTICLES_URL, ArticleInfos),
+  factory.addNotify()
 ));
 
 export const useArticle = ComposableFactory.get(ArticleServiceFactory);

package/composables/services/useChartCategories.ts

@@ -1,5 +1,4 @@
-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 { ChartCategoryDetails, type ChartCategoryDetailsDTO, type ChartCategoryFilters, ChartCategoryInfos, type ChartCategoryInfosDTO, type CreateChartCategoryDTO, type UpdateChartCategoryDTO } 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";

package/composables/services/useChartOrganisationTypes.ts

@@ -1,5 +1,4 @@
-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 { ChartOrganisationTypeDetails, type ChartOrganisationTypeDetailsDTO, type ChartOrganisationTypeFilters, ChartOrganisationTypeInfos, type ChartOrganisationTypeInfosDTO, type CreateChartOrganisationTypeDTO, type UpdateChartOrganisationTypeDTO } 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";
@@ -7,16 +6,15 @@ import { CHART_ORGANISATION_TYPE_URL, CHART_ORGANISATION_TYPES_URL } from "../..
 const ChartOrganisationTypeServiceFactory = new ServiceFactory<ChartOrganisationTypeDetailsDTO, ChartOrganisationTypeDetails>("chartOrganisationType", ChartOrganisationTypeDetails)
   .createComplete<ChartOrganisationTypeInfos, ChartOrganisationTypeInfosDTO, CreateChartOrganisationTypeDTO, UpdateChartOrganisationTypeDTO, ChartOrganisationTypeFilters>(CHART_ORGANISATION_TYPES_URL, CHART_ORGANISATION_TYPE_URL, ChartOrganisationTypeInfos);
 
-const ChartOrganisationTypeServiceFactoryIncomplete = new ServiceFactory("chartOrganisationType", ChartOrganisationTypeDetails)
-  .create(factory => factory.build(
-    factory.addNotify(notifyService => ({
-      ...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;
-      })
-    }))
-  ));
+const ChartOrganisationTypeServiceFactoryIncomplete = new ServiceFactory("chartOrganisationType", ChartOrganisationTypeDetails).create(factory => factory.build(
+  factory.addNotify(notifyService => ({
+    ...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;
+    })
+  }))
+));
 
 export const useChartOrganisationType = ComposableFactory.get(ChartOrganisationTypeServiceFactory);
 export const useChartOrganisationTypes = ComposableFactory.getMany(ChartOrganisationTypeServiceFactory);

package/composables/services/useChartOrganisations.ts

@@ -1,5 +1,4 @@
-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 { ChartOrganisationDetails, type ChartOrganisationDetailsDTO, type ChartOrganisationFilters, ChartOrganisationInfos, type ChartOrganisationInfosDTO, type CreateChartOrganisationDTO, type UpdateChartOrganisationDTO } 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";
@@ -7,16 +6,15 @@ import { CHART_ORGANISATION_URL, CHART_ORGANISATIONS_URL } from "../../config/ur
 const ChartOrganisationServiceFactory = new ServiceFactory<ChartOrganisationDetailsDTO, ChartOrganisationDetails>("chartOrganisation", ChartOrganisationDetails)
   .createComplete<ChartOrganisationInfos, ChartOrganisationInfosDTO, CreateChartOrganisationDTO, UpdateChartOrganisationDTO, ChartOrganisationFilters>(CHART_ORGANISATIONS_URL, CHART_ORGANISATION_URL, ChartOrganisationInfos);
 
-const ChartOrganisationServiceFactoryIncomplete = new ServiceFactory("chartOrganisation", ChartOrganisationDetails)
-  .create(factory => factory.build(
-    factory.addNotify(notifyService => ({
-      ...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;
-      })
-    }))
-  ));
+const ChartOrganisationServiceFactoryIncomplete = new ServiceFactory("chartOrganisation", ChartOrganisationDetails).create(factory => factory.build(
+  factory.addNotify(notifyService => ({
+    ...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;
+    })
+  }))
+));
 
 export const useChartOrganisation = ComposableFactory.get(ChartOrganisationServiceFactory);
 export const useChartOrganisations = ComposableFactory.getMany(ChartOrganisationServiceFactory);

package/composables/services/useCharts.ts

@@ -1,6 +1,4 @@
-
-import type { ChartDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
-import { ChartDetails } from "@dative-gpi/foundation-core-domain/models";
+import { ChartDetails, type ChartDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { CHART_URL } from "../../config/urls";

package/composables/services/useComments.ts

@@ -1,11 +1,10 @@
-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 { CommentDetails, type CommentDetailsDTO, type CommentFilters, CommentInfos, type CommentInfosDTO, type CreateCommentDTO, type UpdateCommentDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { COMMENTS_URL, COMMENT_URL } from "../../config/urls";
 
 const CommentServiceFactory = new ServiceFactory<CommentDetailsDTO, CommentDetails>("comment", CommentDetails)
-    .createComplete<CommentInfos, CommentInfosDTO, CreateCommentDTO, UpdateCommentDTO, CommentFilters>(COMMENTS_URL, COMMENT_URL, CommentInfos);
+  .createComplete<CommentInfos, CommentInfosDTO, CreateCommentDTO, UpdateCommentDTO, CommentFilters>(COMMENTS_URL, COMMENT_URL, CommentInfos);
 
 export const useComment = ComposableFactory.get(CommentServiceFactory);
 export const useComments = ComposableFactory.getMany(CommentServiceFactory);

package/composables/services/useConnectivityAlerts.ts

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

package/composables/services/useConnectivityScenarios.ts

@@ -1,6 +1,5 @@
+import { ConnectivityScenarioDetails, type ConnectivityScenarioDetailsDTO, type ConnectivityScenarioFilters, ConnectivityScenarioInfos, type ConnectivityScenarioInfosDTO, type CreateConnectivityScenarioDTO, type UpdateConnectivityScenarioDTO } from "@dative-gpi/foundation-core-domain/models";
 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";
 

package/composables/services/useCustomProperties.ts

@@ -1,12 +1,11 @@
-import type { CustomPropertyDetailsDTO, CustomPropertyFilters, CustomPropertyInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { CustomPropertyDetails, CustomPropertyInfos } from "@dative-gpi/foundation-core-domain/models";
+import { CustomPropertyDetails, type CustomPropertyDetailsDTO, type CustomPropertyFilters, CustomPropertyInfos, type CustomPropertyInfosDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 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()
+  factory.addGetMany<CustomPropertyInfosDTO, CustomPropertyInfos, CustomPropertyFilters>(CUSTOM_PROPERTIES_URL, CustomPropertyInfos),
+  factory.addNotify()
 ));
 
 export const useCustomProperties = ComposableFactory.getMany(CustomPropertyServiceFactory);

package/composables/services/useCustomPropertyValues.ts

@@ -1,11 +1,11 @@
-import type { CustomPropertyValueInfosDTO, PropertyEntity } from "@dative-gpi/foundation-core-domain/models";
-import { CustomPropertyValueInfos } from "@dative-gpi/foundation-core-domain/models";
+import { CustomPropertyValueInfos, type CustomPropertyValueInfosDTO } from "@dative-gpi/foundation-core-domain/models";
+import { type PropertyEntity } from "@dative-gpi/foundation-shared-domain/enums";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { CUSTOM_PROPERTY_VALUES_URL } from "../../config/urls";
 
 const CustomPropertyValueServiceFactory = {
-    ...ServiceFactory.addCustom("getMany", (axios, entity: PropertyEntity, entityId: string, code: string) => axios.get(CUSTOM_PROPERTY_VALUES_URL(entity, entityId, code)), (dtos: CustomPropertyValueInfosDTO[]) => dtos.map((dto: CustomPropertyValueInfosDTO) => new CustomPropertyValueInfos(dto))),
+  ...ServiceFactory.addCustom("getMany", (axios, entity: PropertyEntity, entityId: string, code: string) => axios.get(CUSTOM_PROPERTY_VALUES_URL(entity, entityId, code)), (dtos: CustomPropertyValueInfosDTO[]) => dtos.map((dto: CustomPropertyValueInfosDTO) => new CustomPropertyValueInfos(dto))),
 };
 
 export const useCustomPropertyValues = ComposableFactory.custom(CustomPropertyValueServiceFactory.getMany);

package/composables/services/useDashboardOrganisationTypes.ts

@@ -1,33 +1,31 @@
-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 { DashboardOrganisationTypeDetails, type DashboardOrganisationTypeDetailsDTO, type DashboardOrganisationTypeFilters, DashboardOrganisationTypeInfos, type DashboardOrganisationTypeInfosDTO, type LockDashboardOrganisationTypeDTO, type PublishDashboardOrganisationTypeDTO, type UpdateDashboardOrganisationTypeDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 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.addUpdate<UpdateDashboardOrganisationTypeDTO>(DASHBOARD_ORGANISATION_TYPE_URL),
-    factory.addRemove(DASHBOARD_ORGANISATION_TYPE_URL),
-    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;
-      })
-    }))
-  ));
+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.addUpdate<UpdateDashboardOrganisationTypeDTO>(DASHBOARD_ORGANISATION_TYPE_URL),
+  factory.addRemove(DASHBOARD_ORGANISATION_TYPE_URL),
+  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);
@@ -35,5 +33,4 @@ export const useUpdateDashboardOrganisationType = ComposableFactory.update(Dashb
 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);
-
+export const useLockDashboardOrganisationType = ComposableFactory.custom(DashboardOrganisationTypeServiceFactory.lock);

package/composables/services/useDashboardOrganisations.ts

@@ -1,5 +1,4 @@
-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 { type ChangeDashboardOrganisationFolderDTO, type CreateDashboardOrganisationDTO, DashboardOrganisationDetails, type DashboardOrganisationDetailsDTO, type DashboardOrganisationFilters, DashboardOrganisationInfos, type DashboardOrganisationInfosDTO, type LockDashboardOrganisationDTO, type UpdateDashboardOrganisationDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { DASHBOARD_ORGANISATION_FOLDER_URL, DASHBOARD_ORGANISATION_LOCK_URL, DASHBOARD_ORGANISATION_URL, DASHBOARD_ORGANISATIONS_URL } from "../../config/urls";
@@ -7,26 +6,25 @@ import { DASHBOARD_ORGANISATION_FOLDER_URL, DASHBOARD_ORGANISATION_LOCK_URL, DAS
 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.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;
-      })
-    }))
-  ));
+const DashboardOrganisationServiceFactoryIncomplete = new ServiceFactory("dashboardOrganisation", DashboardOrganisationDetails).create(factory => factory.build(
+  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);
 export const useDashboardOrganisations = ComposableFactory.getMany(DashboardOrganisationServiceFactory);

package/composables/services/useDashboardShallows.ts

@@ -1,5 +1,4 @@
-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 { type ChangeDashboardShallowFolderDTO, type CreateDashboardShallowDTO, DashboardShallowDetails, type DashboardShallowDetailsDTO, type DashboardShallowFilters, DashboardShallowInfos, type DashboardShallowInfosDTO, type UpdateDashboardShallowDTO  } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
 import { DASHBOARD_SHALLOW_FOLDER_URL, DASHBOARD_SHALLOW_URL, DASHBOARD_SHALLOWS_URL } from "../../config/urls/dashboardShallows";
@@ -7,21 +6,20 @@ import { DASHBOARD_SHALLOW_FOLDER_URL, DASHBOARD_SHALLOW_URL, DASHBOARD_SHALLOWS
 const DashboardShallowServiceFactory = new ServiceFactory<DashboardShallowDetailsDTO, DashboardShallowDetails>("dashboardShallow", DashboardShallowDetails)
   .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;
-      })
-    }))
-  ));
+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);

package/composables/services/useDashboards.ts

@@ -1,12 +1,10 @@
+import { DashboardDetails, type DashboardDetailsDTO } from "@dative-gpi/foundation-core-domain/models";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
 
-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";
 
 const DashboardServiceFactory = new ServiceFactory<DashboardDetailsDTO, DashboardDetails>("dashboard", DashboardDetails).create(factory => factory.build(
-    ServiceFactory.addCustom("getCurrent", (axios) => axios.get(DASHBOARD_CURRENT_URL()), (dto: DashboardDetailsDTO) => new DashboardDetails(dto))
+  ServiceFactory.addCustom("getCurrent", (axios) => axios.get(DASHBOARD_CURRENT_URL()), (dto: DashboardDetailsDTO) => new DashboardDetails(dto))
 ));
 
 export const useCurrentDashboard = ComposableFactory.custom(DashboardServiceFactory.getCurrent);

package/composables/services/useDataCategories.ts

@@ -1,13 +1,12 @@
-import type { DataCategoryDetailsDTO, DataCategoryFilters, DataCategoryInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { DataCategoryDetails, DataCategoryInfos } from "@dative-gpi/foundation-core-domain/models";
+import { DataCategoryDetails, type DataCategoryDetailsDTO, type DataCategoryFilters, DataCategoryInfos, type DataCategoryInfosDTO } 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";
 
 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()
+  factory.addGet(DATA_CATEGORY_URL),
+  factory.addGetMany<DataCategoryInfosDTO, DataCategoryInfos, DataCategoryFilters>(DATA_CATEGORIES_URL, DataCategoryInfos),
+  factory.addNotify()
 ));
 
 export const useDataCategory = ComposableFactory.get(DataCategoryServiceFactory);

package/composables/services/useDataDefinitions.ts

@@ -1,13 +1,12 @@
-import type { DataDefinitionDetailsDTO, DataDefinitionFilters, DataDefinitionInfosDTO } from "@dative-gpi/foundation-core-domain/models";
-import { DataDefinitionDetails, DataDefinitionInfos } from "@dative-gpi/foundation-core-domain/models";
+import { DataDefinitionDetails, type DataDefinitionDetailsDTO, type DataDefinitionFilters, DataDefinitionInfos, type DataDefinitionInfosDTO } 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";
 
 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()
+  factory.addGet(DATA_DEFINITION_URL),
+  factory.addGetMany<DataDefinitionInfosDTO, DataDefinitionInfos, DataDefinitionFilters>(DATA_DEFINITIONS_URL, DataDefinitionInfos),
+  factory.addNotify()
 ));
 
 export const useDataDefinition = ComposableFactory.get(DataDefinitionServiceFactory);

package/composables/services/useDataTables.ts

@@ -1,26 +1,30 @@
 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";
+import { type FSDataTable, type FSDataTableColumn } from "@dative-gpi/foundation-shared-components/models";
 
 export const useDataTables = () => {
   const initialized = ref(false);
 
   const table = ref<FSDataTable>({
     headers: [],
-    mode: "table",
+    mode: "iterator",
     sortBy: null,
     rowsPerPage: 10,
     filters: {},
     page: 1
   });
 
-  const computeTable = ((customSorts: { [key: string]: any }, customSortRaws: { [key: string]: any }) => ({
+  const computeTable = ((headersOptions: { [key: string]: Partial<FSDataTableColumn> }) => ({
     ...table.value,
     headers: table.value.headers.map(header => ({
       ...header,
-      sort: header.value && customSorts[header.value] || null,
-      sortRaw: header.value && customSortRaws[header.value] || null 
+      fixedFilters: (header.value && headersOptions[header.value] && headersOptions[header.value].fixedFilters) || null,
+      methodFilter: (header.value && headersOptions[header.value] && headersOptions[header.value].methodFilter) || null,
+      methodFilterRaw: (header.value && headersOptions[header.value] && headersOptions[header.value].methodFilterRaw) || null,
+      sort: (header.value && headersOptions[header.value] && headersOptions[header.value].sort) || null,
+      sortRaw: (header.value && headersOptions[header.value] && headersOptions[header.value].sortRaw) || null ,
+      innerValue: (header.value && headersOptions[header.value] && headersOptions[header.value].innerValue) || null 
     }))
   }));
 
@@ -87,4 +91,4 @@ export const useDataTables = () => {
     computeTable,
     updateTable
   };
-};
+};